def test_balance_on_inserts():
"""Test balance after inserts."""
new_tree = BinarySearchTree()
assert new_tree.balance() == 0
new_tree.insert(2)
assert new_tree.balance() == 0
new_tree.insert(1)
assert new_tree.balance() == -1
new_tree.insert(3)
assert new_tree.balance() == 0
new_tree.insert(4)
assert new_tree.balance() == 1
def test_balance():
tree = BinarySearchTree()
tree.insert(2)
tree.insert(4)
tree.insert(5)
tree.insert(1)
assert tree.balance() == -1
def test___init__(self):
bst1 = BinarySearchTree()
self.assertIsNone(bst1.head)
self.assertEqual(bst1.contains(0), False)
self.assertEqual(bst1.contains(None), False)
self.assertEqual(bst1.size(), 0)
self.assertEqual(bst1.depth(), 0)
self.assertEqual(bst1.balance(), 0)
def test_tree_balance_returns_correctly():
"""Test balance function returns currect balance."""
from bst import BinarySearchTree
bst = BinarySearchTree()
bst.insert(85)
bst.insert(55)
bst.insert(88)
bst.insert(2)
bst.insert(79)
bst.insert(50)
assert bst.balance() == 2
def test_tree_autobalances():
"""Test that a right skewed tree is balanced after many insertions."""
tree = BinarySearchTree()
tree.insert(50)
tree.insert(60)
tree.insert(70)
tree.insert(80)
tree.insert(90)
tree.insert(100)
tree.insert(66)
tree.insert(59)
tree.insert(89)
assert abs(tree.balance()) <= 1
def test_balance_nobalance(self):
bst1 = BinarySearchTree()
bst2 = BinarySearchTree()
bst3 = BinarySearchTree()
bst4 = BinarySearchTree()
bst5 = BinarySearchTree()
bst6 = BinarySearchTree()
bst1.insert(0)
bst1.insert(1)
bst1.insert(2)
self.assertEqual(bst1.balance(), 2)
bst2.insert(1)
bst2.insert(2)
bst2.insert(0)
self.assertEqual(bst2.balance(), 0)
bst3.insert(2)
bst3.insert(0)
bst3.insert(1)
self.assertEqual(bst3.balance(), -2)
bst4.insert(2)
bst4.insert(1)
bst4.insert(0)
self.assertEqual(bst4.balance(), -2)
bst5.insert(0)
bst5.insert(2)
bst5.insert(1)
self.assertEqual(bst5.balance(), 2)
bst6.insert(1)
bst6.insert(0)
bst6.insert(2)
self.assertEqual(bst6.balance(), 0)
def test_balance_w_no_left_nodes():
"""Test the balance of a tree with only a root and its right child."""
b_tree = BinarySearchTree()
b_tree.insert(17)
b_tree.insert(43)
assert b_tree.balance() == 1
def test_balance_method_on_pos_balance_with_two_sides():
"""Test the balance method on a positively balanced bst."""
new_bst = BinarySearchTree([10, 0, -10, -20, 20])
assert new_bst.balance() == 2
def test_balance_method_on_neg_balance_with_two_sides():
"""Test the balance method on a negatively balanced bst."""
new_bst = BinarySearchTree([10, 20, 30, 0])
assert new_bst.balance() == -1
def test_balance_method_on_mt_bst():
"""Test the balane method on a mt bst."""
new_bst = BinarySearchTree()
assert new_bst.balance() == 0
def test_balance_right_heavy():
contents = [6, 8, 10]
bst = BinarySearchTree(contents)
assert bst.balance() == -2
def test_bst_balance_empty():
from bst import BinarySearchTree
tree = BinarySearchTree()
assert tree.balance() == 0
