def test_3(self):
a_3 = Node(1)
b_3 = Node(2)
c_3 = Node(3)
d_3 = Node(4)
a_3.left = b_3
b_3.right = c_3
c_3.left = d_3
tree_3 = Btree(a_3)
assert tree_3.pring() == self.answer_3
def test_2(self):
a_2 = Node(1)
b_2 = Node(2)
c_2 = Node(3)
d_2 = Node(4)
a_2.left = b_2
b_2.left = c_2
c_2.left = d_2
tree_2 = Btree(a_2)
assert tree_2.pring() == self.answer_2
def test_4(self):
a_4 = Node(1)
b_4 = Node(2)
c_4 = Node(3)
d_4 = Node(4)
e_4 = Node(5)
f_4 = Node(6)
a_4.left = b_4
a_4.right = c_4
b_4.left = d_4
b_4.right = e_4
c_4.right = f_4
tree_4 = Btree(a_4)
assert tree_4.pring() == self.answer_4
def test_get_tree_list3(self):
"""
Test a tree with only left child nodes
:return:
"""
a = Node(1, None, None)
b = Node(2, None, None)
c = Node(3, None, None)
a.left = b
b.left = c
tree3 = Tree(a)
expected_list3 = [['|', '|', '|', '1', '|', '|', '|'],
['|', '2', '|', '|', '|', '|', '|'],
['3', '|', '|', '|', '|', '|', '|']]
assert tree3.get_tree_list(a) == expected_list3
def test_displays_in_order_with_BinaryTree():
node1 = Node(5)
node2 = Node(10)
node3 = Node(2)
node4 = Node(7)
node5 = Node(25)
node1.left = node2
node1.right = node3
node2.left = node4
node2.right = node5
tree = BinaryTree(node1)
actual = breadthFirst(tree)
expected = [5, 10, 2, 7, 25]
assert actual == expected
def test_2(self):
node = Node(1, None, None)
node.left = Node(2, Node(4, None, None), Node(5, None, None))
node.right = Node(3, Node(6, None, None), Node(7, None, None))
t = Tree(node)
assert t.print_tree() == [['|', '|', '|', '1', '|', '|', '|'],
['|', '2', '|', '|', '|', '3', '|'],
['4', '|', '5', '|', '6', '|', '7']]
def test_tree_add_children_to_single_root():
expected = [2, 5, 6]
node = Node(5)
node.left = Node(2)
node.right = Node(6)
btt = BinaryTree(node)
actual = btt.inOrder()
assert actual == expected
def tree_test_two():
node1 = Node(1)
node1.left = Node(2)
node1.left.right = Node(7)
node1.left.left = Node(9)
node1.right = Node(3)
node1.right.left = Node(4)
node1.right.right = Node(5)
bts = BinarySearchTree(node1)
return bts
def tree_test():
node1 = Node(1)
node1.left = Node(2)
node1.left.right = Node(7)
node1.left.left = Node(9)
node1.right = Node(3)
node1.right.left = Node(4)
node1.right.right = Node(5)
binary_tree = BinaryTree(node1)
return binary_tree
def test_get_tree_list4(self):
"""
Test a irregular shape tree
:return:
"""
a = Node(1, None, None)
b = Node(2, None, None)
c = Node(3, None, None)
d = Node(4, None, None)
e = Node(5, None, None)
f = Node(6, None, None)
g = Node(7, None, None)
h = Node(8, None, None)
i = Node(9, None, None)
j = Node(10, None, None)
k = Node(11, None, None)
a.left = b
a.right = c
b.right = d
d.left = e
c.left = f
c.right = g
g.left = h
e.right = i
b.left = j
j.right = k
tree4 = Tree(a)
el_4 = [['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '1',
'|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
['|', '|', '|', '|', '|', '|', '|', '2', '|', '|', '|', '|', '|', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '3', '|', '|', '|', '|', '|', '|', '|'],
['|', '|', '|', '10', '|', '|', '|', '|', '|', '|', '|', '4', '|', '|', '|', '|',
'|', '|', '|', '6', '|', '|', '|', '|', '|', '|', '|', '7', '|', '|', '|'],
['|', '|', '|', '|', '|', '11', '|', '|', '|', '5', '|', '|', '|', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '|', '|', '8', '|', '|', '|', '|', '|'],
['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '9', '|', '|', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|']]
assert tree4.get_tree_list(a) == el_4
def test_binary_tree_breath_first():
bt = BinaryTree()
root = Node(2)
bt.root = root
root.left = Node(7)
root.right = Node(5)
root.left.left = Node(2)
root.left.right = Node(6)
root.right.right = Node(9)
root.left.right.left = Node(5)
root.left.right.right = Node(11)
root.right.right.left = Node(4)
bt.breadth_first()
assert bt.breadth_first() == [2, 7, 5, 2, 6, 9, 5, 11, 4]
def test_3(self):
node = Node(1, None, None)
node.left = Node(2, None, None)
node.left.left = Node(3, None, None)
node.left.left.left = Node(4, None, None)
t = Tree(node)
assert t.print_tree() == [['|', '|', '|', '|', '|', '|', '|',
'1', '|', '|', '|', '|', '|', '|', '|'],
['|', '|', '|', '2', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '|'],
['|', '3', '|', '|', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '|'],
['4', '|', '|', '|', '|', '|', '|',
'|', '|', '|', '|', '|', '|', '|', '|']]
def test_get_tree_list2(self):
"""
Test a complete binary tree
:return:
"""
a = Node(1, None, None)
b = Node(2, None, None)
c = Node(3, None, None)
d = Node(4, None, None)
e = Node(5, None, None)
f = Node(6, None, None)
g = Node(7, None, None)
a.left = b
a.right = c
b.left = d
b.right = e
c.left = f
c.right = g
tree2 = Tree(a)
expected_list2 = [['|', '|', '|', '1', '|', '|', '|'],
['|', '2', '|', '|', '|', '3', '|'],
['4', '|', '5', '|', '6', '|', '7']]
assert tree2.get_tree_list(a) == expected_list2
def test_find_max_value_within_tree():
test_node = Node(1)
test_node.left = Node(2)
test_node.right = Node(3)
test_node.left.left = Node(4)
test_node.left.right = Node(5)
test_node.right.left = Node(6)
test_node.right.right = Node(7)
test_tree = BinaryTree(test_node)
expected = 7
actual = test_tree.find_maximum_value()
assert actual == expected
def test_breadth_first():
test_node = Node(1)
test_node.left = Node(2)
test_node.right = Node(3)
test_node.left.left = Node(4)
test_node.left.right = Node(5)
test_node.right.left = Node(6)
test_node.right.right = Node(7)
test_tree = BinaryTree(test_node)
actual = test_tree.breadth_first()
expected = [1, 2, 3, 4, 5, 6, 7]
assert actual == expected