def test_bst_right_setter_parent():
"""test that right child setter sets parent"""
from bst import Node
node1 = Node(7)
node2 = Node(9)
node1.right = node2
assert node2.parent.val == node1.val
def test_right(self):
self.subject.root = Node(80)
self.subject.root.right = Node(100)
result = self.subject.traverse(mode='level_order')
self.assertEqual([80, 100], result)
def test_bst_parent_setter_parent_child_left():
"""test that parent setter sets child left properly"""
from bst import Node
node1 = Node(2)
node2 = Node(1)
node2.parent = node1
assert node1.left.val == node2.val
def test_left(self):
self.subject.root = Node(80)
self.subject.root.left = Node(30)
result = self.subject.traverse(mode='level_order')
self.assertEqual([80, 30], result)
def test_bst_left_setter_child():
"""test that left child setter works"""
from bst import Node
node1 = Node(9)
node2 = Node(7)
node1.left = node2
assert node1.left.val == node2.val
def test_bst_parent_setter_child_parent():
"""test parent setter works properly"""
from bst import Node
node1 = Node(1)
node2 = Node(2)
node2.parent = node1
assert node1.val == node2.parent.val
def test_right(self):
self.subject.root = Node(80)
self.subject.root.right = Node(100)
result = self.subject.traverse(mode='postorder')
self.assertEqual([100, 80], result)
def test_bst_right_setter_child():
"""test rigth child setter works"""
from bst import Node
node1 = Node(7)
node2 = Node(9)
node1.right = node2
assert node1.right.val == node2.val
def test_right(self):
self.subject.root = Node(100)
self.subject.root.right = Node(150)
result = self.subject.search(150)
self.assertEqual(Node(150), result)
def test_left(self):
self.subject.root = Node(100)
self.subject.root.left = Node(50)
result = self.subject.search(50)
self.assertEqual(Node(50), result)
def test_height_one(self):
self.subject.root = Node(5)
self.subject.root.right = Node(8)
result = self.subject.calculate_height()
self.assertEqual(1, result)
def test_left(self):
self.subject.root = Node(80)
self.subject.root.left = Node(30)
result = self.subject.traverse(mode='postorder')
self.assertEqual([30, 80], result)
def test_right_subtree(self):
self.subject.root = Node(3)
self.subject.root.right = Node(4)
self.subject.root.right.right = Node(5)
result = self.subject.traverse(mode='level_order')
self.assertEqual([3, 4, 5], result)
def test_bst_del_right_child():
"""test deleter on right child"""
from bst import Node
node1 = Node(7)
node2 = Node(9)
node1.right = node2
del node1.right
assert node1.right is None
def test_left_subtree(self):
self.subject.root = Node(5)
self.subject.root.left = Node(4)
self.subject.root.left.left = Node(3)
result = self.subject.traverse(mode='level_order')
self.assertEqual([5, 4, 3], result)
def test_bst_del_left_child():
"""test deleter on left child"""
from bst import Node
node1 = Node(9)
node2 = Node(7)
node1.left = node2
del node1.left
assert node1.left is None
def test_init(self):
node1 = Node(5)
node2 = Node(4)
assert (node1.data == 5)
assert (node1.left == None)
assert (node1.right == None)
assert (node2.data == 4)
assert (node2.left == None)
assert (node2.right == None)
def test_uneven_tree(self):
self.subject.root = Node(10)
self.subject.root.left = Node(8)
self.subject.root.right = Node(12)
self.subject.root.left.right = Node(9)
self.subject.root.right.left = Node(11)
result = self.subject.traverse(mode='postorder')
self.assertEqual([9, 8, 11, 12, 10], result)
def test_uneven_tree(self):
self.subject.root = Node(10)
self.subject.root.left = Node(8)
self.subject.root.right = Node(12)
self.subject.root.left.right = Node(9)
self.subject.root.right.left = Node(11)
result = self.subject.traverse(mode='level_order')
self.assertEqual([10, 8, 12, 9, 11], result)
def main():
one = Node(1, "")
two = Node(2, "")
three = Node(3, "")
four = Node(4, "")
five = Node(5, "")
six = Node(6, "")
seven = Node(7, "")
eight = Node(8, "")
nine = Node(9, "")
one.left = two
one.right = three
two.left = four
two.right = five
four.left = six
four.right = seven
tree = Tree()
tree.root = one
tree.levelorder()
inverted = upside_down(tree)
inverted.levelorder()
def main():
one = Node(1, "")
two = Node(2, "")
three = Node(3, "")
four = Node(4, "")
five = Node(5, "")
six = Node(6, "")
seven = Node(7, "")
eight = Node(8, "")
nine = Node(9, "")
one.left = two
one.right = three
two.left = four
two.right = five
three.left = six
three.right = seven
five.left = eight
five.right = nine
assert five is LCA(one, eight, nine)
assert two is LCA(one, two, nine)
assert one is LCA(one, two, seven)
assert one is LCA(one, one, nine)
assert four is LCA(one, four, four)
def test_bst_isbinarysearchtree_recursive(self):
bst = BinarySearchTree()
bst.insert_recursive(14)
bst.insert_recursive(11)
bst.insert_recursive(7)
bst.root.left.right = Node(15)
assert_equal(False, bst.is_binary_search_tree())
def test_node_object_has_value_and_left_right_are_none():
"""Test node constructure creates node with left and right children."""
from bst import Node
n = Node(5)
assert n.value == 5
assert n.left is None
assert n.right is None
def test_in():
root = Node(1)
root.insert(2)
root.insert(3)
assert (0 in root) == False
assert (1 in root) == True
assert (3 in root) == True
def test_node_attributes_exist():
"""Test that node attributes are in Node class."""
n = Node(1)
assert n.val == 1
assert n.left is None
assert n.right is None
assert n.depth == 0
def test_node_has_value_and_left_right_have_value_when_given():
"""Test node node has value given and contains value for left and right."""
from bst import Node
n = Node(4, 3, 5)
assert n.value == 4
assert n.left == 3
assert n.right == 5
def setUp(self):
self.root = Node(5)
self.root.insert(Node(1))
self.root.insert(Node(4))
self.root.insert(Node(8))
self.root.insert(Node(11))
self.root.insert(Node(0))
self.root.insert(Node(12))
self.root.insert(Node(-1))
def test_find():
root = Node(1)
root.insert(2)
root.insert(-5)
assert root.find(1) is root
assert root.find(100) is None
assert root.find(2) is root.right
assert root.find(-5) is root.left
def _create_min_bst(self, array, start, end):
if end < start:
return None
mid = (start + end) // 2
node = Node(array[mid])
node.left = self._create_min_bst(array, start, mid - 1)
node.right = self._create_min_bst(array, mid + 1, end)
return node
def main():
complete_binary_tree = BST()
one = Node(1)
two = Node(2)
three = Node(3)
four = Node(4)
five = Node(5)
six = Node(6)
seven = Node(7)
one.left = two
one.right = three
two.left = four
two.right = five
three.left = six
three.right = seven
complete_binary_tree.root = one
add_sibling_pointers(complete_binary_tree.root)
nodes = list(complete_binary_tree.levelorder_nodes())
# verify the next pointers
assert one.next is None
assert two.next is three
assert three.next is None
assert four.next is five
assert five.next is six
assert six.next is seven
assert seven.next is None
