def repeated_word(str):
tree = BinarySearchTree()
array = str.split(' ')
node = Node(array[0])
tree.root = node
curr = tree.root
def _check(curr, node):
if node.data == curr.data:
return curr.data
if node.data < curr.data:
if not curr.left:
curr.left = node
else:
return _check(curr.left, node)
if node.data > curr.data:
if not curr.right:
curr.right = node
else:
return _check(curr.right, node)
return False
result = False
for i in range(1, len(array)):
node = Node(array[i])
result = _check(curr, node)
if result is not False:
break
return result
def test_add_right_and_left():
tree = BinaryTree()
tree.root = Node(10)
tree.root.left = Node(3)
tree.root.right = Node(15)
actual = f"{tree.root.value}, {tree.root.left.value}, {tree.root.right.value}"
expected = "10, 3, 15"
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 test4(self):
d = Node(4, None, None)
e = Node(2, None, None)
b = Node(9, None, d)
c = Node(6, e, None)
a = Node(7, b, c)
tree4 = Tree(a)
assert tree4.print_tree() == self.answer4
def test_case_2(self):
node = Node(1, Node(2, Node(3, Node(4, None, None), None), None), None)
self.tree = Tree(node)
self.answer = [['|', '|', '|', '|', '|', '|', '|', 1, '|', '|', '|', '|', '|', '|', '|'],
['|', '|', '|', 2, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
['|', 3, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
[4, '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|']]
assert self.tree.print_tree() == self.answer
def test_printtree(self):
a = Node(1, Node(2, Node(4, None, None), None), Node(3, None, None))
b = Tree(a)
res = [['|', '|', '|', '1', '|', '|', '|'],
['|', '2', '|', '|', '|', '3', '|'],
['4', '|', '|', '|', '|', '|', '|']]
assert res == b.printTree(a)
def test_add_left_and_right():
tree = BinaryTree()
tree.root = Node(111)
tree.left = Node(11)
tree.right = Node(1)
actual = f"{tree.root.value}, {tree.left.value}, {tree.right.value}"
expected = "111, 11, 1"
assert actual == expected
def test_can_successfully_add_a_left_child_and_right_child_to_a_single_root_node():
new_tree = BinaryTree()
new_tree.root = Node(1)
new_tree.root.left = Node(2)
new_tree.root.right = Node(3)
expected = [1, 2, 3]
actual = new_tree.preOrder()
assert expected == actual
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_postorder():
tree = BinaryTree()
tree.root = Node(50)
tree.root.left = Node(30)
tree.root.right = Node(70)
tree.root.left.left = Node(20)
tree.root.left.right = Node(40)
actual = tree.post_order()
expected = [20, 40, 30, 70, 50]
assert actual == expected
def test_tree_preorder():
tree = BinaryTree()
tree.root = Node(1)
tree.root.left = Node(11)
tree.root.right = Node(111)
tree.root.left.left = Node(1111)
tree.root.left.right = Node(11111)
actual = tree.pre_order()
expected = [1, 11, 1111, 11111, 111]
assert actual == expected
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_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_tree_postorder():
tree = BinaryTree()
tree.root = Node(1)
tree.root.left = Node(11)
tree.root.right = Node(2)
tree.root.left.left = Node(111)
tree.root.left.right = Node(112)
actual = tree.post_order()
expected = [111, 112, 11, 2, 1]
assert actual == expected
def test_tree_inorder():
tree = BinaryTree()
tree.root = Node(1)
tree.root.left = Node(11)
tree.root.right = Node(2)
tree.root.left.left = Node(111)
tree.root.right.right = Node(22)
actual = tree.in_order()
expected = [111, 11, 1, 2, 22]
assert actual == expected
def test_two_duplicate_strings():
binarytree1, binarytree2 = BinaryTreeSearch(), BinaryTreeSearch()
binarytree1.root.value = "cat"
binarytree1.root.right_node = Node("dog")
binarytree1.root.left_node = Node("unicorn")
binarytree1.root.value = "horse"
binarytree1.root.right_node = Node("dog")
binarytree1.root.left_node = Node("unicorn")
binarytree1.root.left_node.left_node = Node("cat")
actual = tree_intersection(binarytree1, binarytree2)
expected = ["cat", "dog"]
assert actual == expected
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
def test_dupes_tree2():
tree2 = BinaryTree()
#tree2
tree2.root = Node(1)
#left
tree2.root.left = Node(3)
tree2.root.left.left = Node(15)
tree2.root.left.right = Node(12)
tree2.root.left.right.left = Node(15)
# right
tree2.root.right = Node(20)
tree2.root.right.left = Node(23)
tree2.root.right.right = Node(11)
tree2.root.right.right.left = Node(2)
tree2.root.right.right.right = Node(12)
return tree2
def test_get_tree_list1(self):
"""
Test a single node tree
:return:
"""
a = Node(1, None, None)
tree1 = Tree(a)
assert tree1.get_tree_list(a) == ['1']
def test_dupes_tree1():
tree1 = BinaryTree()
#tree1
tree1.root = Node(1)
#left
tree1.root.left = Node(1)
tree1.root.left.left = Node(5)
tree1.root.left.right = Node(10)
tree1.root.left.right.left = Node(5)
# right
tree1.root.right = Node(20)
tree1.root.right.left = Node(2)
tree1.root.right.right = Node(14)
tree1.root.right.right.left = Node(2)
tree1.root.right.right.right = Node(100)
return tree1
def test_2(self):
self.test = Node(1, Node(2, Node(3, None, None), Node(4, None, None)),
Node(5, Node(6, None, None), Node(7, None, None)))
self.answer = [['|', '|', '|', 1, '|', '|', '|'],
['|', 2, '|', '|', '|', 5, '|'],
[3, '|', 4, '|', 6, '|', 7]]
assert Tree(self.test).printTree() == self.answer
def test3(self):
# all branches on the left
case3 = Node(1, Node(2, Node(None, None, None), Node(5, None, None)),
Node(3, Node(4, None, None), Node(None, None, None)))
self.input = Tree.PrintTree(case3)
self.answer = "|||1|||\n|2|||3|\n||5|4||\n"
assert self.input == self.answer
def test2(self):
# full balanced tree
case2 = Node(1, Node(2, Node(4, None, None), Node(5, None, None)),
Node(3, Node(6, None, None), Node(7, None, None)))
self.input = Tree.PrintTree(case2)
self.answer = "|||1|||\n|2|||3|\n4|5|6|7\n"
assert self.input == self.answer
def test_instantiate_tree():
tree = BinaryTree()
tree.root = Node(2)
tree.root.left = Node(7)
tree.root.left.left = Node(2)
tree.root.left.right = Node(6)
tree.root.left.right.left = Node(5)
tree.root.left.right.right = Node(11)
tree.root.right = Node(5)
tree.root.right.right = Node(9)
tree.root.right.right.left = Node(4)
actual = tree.find_maximum_value()
expected = 11
assert actual == expected
def test_adding():
test_tree = BinarySearchTree(Node(1))
test_tree.add(2)
test_tree.add(3)
test_tree.add(4)
test_tree.add(5)
actual = test_tree.inOrder()
expected = [1, 2, 3, 4, 5]
assert actual == expected
def binary_tree():
tree = BinaryTree()
tree.root = Node(1)
tree.root.left = Node(5)
tree.root.right = Node(10)
tree.root.left.right = Node(25)
tree.root.left.right.left = Node(13)
tree.root.left.right.right = Node(15)
tree.root.right.right = Node(9)
tree.root.right.right.left = Node(4)
return tree
def binary_tree3():
tree3 = BinaryTree()
tree3.root = Node(2)
tree3.root.left = Node(18)
tree3.root.right = Node(6)
tree3.root.left.right = Node(8)
tree3.root.left.right.left = Node(20)
tree3.root.left.right.right = Node(12)
tree3.root.right.right = Node(14)
tree3.root.right.right.left = Node(16)
return tree3
def test_case_3(self):
node = Node(1, Node(2, Node(4, None, None), Node(5, None, None)),
Node(3, Node(6, None, None), Node(7, None, None)))
self.tree = Tree(node)
self.answer = [['|', '|', '|', 1, '|', '|', '|'],
['|', 2, '|', '|', '|', 3, '|'],
[4, '|', 5, '|', 6, '|', 7]]
assert self.tree.print_tree() == self.answer
return None
if node.right:
in_order(node.right)
return None
def post_order(node):
if node.left:
post_order(node.left)
if node.right:
post_order(node.right)
if node.value:
print node.value
return None
if __name__ == "__main__":
root = Node(None, "F")
B = root.add_left_child("B")
A = B.add_left_child("A")
D = B.add_right_child("D")
C = D.add_left_child("C")
E = D.add_right_child("E")
G = root.add_right_child("G")
I = G.add_right_child("I")
H = I.add_left_child("H")
print "Pre-order depth first:"
pre_order(root)
print "In-order depth first:"
in_order(root)
print "Post-order depth first:"
post_order(root)