def test_intersection_tree():
bt = BinaryTree()
bt1 = BinaryTree()
bt.root = Node(150)
bt.root.left = Node(100)
bt.root.right = Node(250)
bt.root.left.left = Node(75)
bt.root.left.right = Node(160)
bt.root.right.left = Node(200)
bt.root.right.right = Node(350)
bt.root.left.right.left = Node(125)
bt.root.left.right.right = Node(175)
bt.root.right.right.left = Node(300)
bt.root.right.right.right = Node(500)
bt1.root = Node(42)
bt1.root.left = Node(100)
bt1.root.right = Node(600)
bt1.root.left.left = Node(15)
bt1.root.left.right = Node(160)
bt1.root.right.left = Node(200)
bt1.root.right.right = Node(350)
bt1.root.left.right.left = Node(125)
bt1.root.left.right.right = Node(175)
bt1.root.right.right.left = Node(4)
bt1.root.right.right.right = Node(500)
actual = tree_intersection(bt, bt1)
expected = [100, 160, 125, 175, 200, 350, 500]
assert actual == expected
def test_test_three_common():
tr1 = BinaryTree()
tr2 = BinaryTree()
tr1.root = Node(5)
tr1.root.right = Node(10)
tr1.root.left = Node(-2)
tr1.root.right.left = Node(15)
tr1.root.left.left = Node(17)
tr2.root = Node(5)
tr2.root.right = Node(11)
tr2.root.left = Node(-2)
tr2.root.right.left = Node(15)
tr2.root.left.left = Node(111)
assert tree_intersection(tr1, tr2) == [5, -2, 15]
def test_test_with_string():
tr1 = BinaryTree()
tr2 = BinaryTree()
tr1.root = Node(5)
tr1.root.right = Node('omar')
tr1.root.left = Node(-2)
tr1.root.right.left = Node(15)
tr1.root.left.left = Node(17)
tr2.root = Node(5)
tr2.root.right = Node(11)
tr2.root.left = Node(-2)
tr2.root.right.left = Node(15)
tr2.root.left.left = Node('omar')
assert tree_intersection(tr1, tr2) == [5, -2, 'omar', 15]
def fizz_buzz_tree(tree):
"""
Function to change all values in the given tree according to fizz_buzz:
inp ---> tree to be checked..
out >>> new tree with fizz - buzz or the same number if it not..
"""
try:
new_tree = BinaryTree()
if not tree.root:
return new_tree
def helper(current):
"""
Helper function to use in recurtion to add new values in the new_tree according to their positions in the original tree
"""
node = Node(fizz_buzz(current.value))
if current.left:
node.left = helper(current.left)
if current.right:
node.right = helper(current.right)
return node
new_tree.root = helper(tree.root)
return new_tree
except:
raise ValueError('your input not tree')
def test_intersection_tree2():
bt = BinaryTree()
bt1 = BinaryTree()
bt.root = Node(0)
bt.root.left = Node(5)
bt.root.right = Node(10)
bt.root.left.left = Node(15)
bt.root.left.right = Node(20)
bt1.root = Node(5)
bt1.root.left = Node(15)
bt1.root.right = Node(10)
bt1.root.left.left = Node(20)
bt1.root.left.right = Node(0)
actual = tree_intersection(bt, bt1)
expected = [10]
assert actual == expected
def test_intersection_tree1():
bt = BinaryTree()
bt1 = BinaryTree()
bt.root = Node(0)
bt.root.left = Node(5)
bt.root.right = Node(10)
bt.root.left.left = Node(15)
bt.root.left.right = Node(20)
bt1.root = Node(6)
bt1.root.left = Node(12)
bt1.root.right = Node(18)
bt1.root.left.left = Node(24)
bt1.root.left.right = Node(30)
actual = tree_intersection(bt, bt1)
expected = None
assert actual == expected
def fizz_buzz_tree(k_ary):
"""
Function to change all values in the given tree according to fizz_buzz
"""
new_tree = BinaryTree()
if not k_ary.root:
return new_tree
def helper(current):
"""
Helper function to use in recurtion to add new values in the new_tree according to their
positions in the original tree
"""
node = Node(fizz_buzz(current.value))
if current.left:
node.left = helper(current.left)
if current.right:
node.right = helper(current.right)
return node
new_tree.root = helper(k_ary.root)
return new_tree
def test_tree_with_one_value():
test = BinaryTree()
test.root = _Node(5)
expected = ['Buzz']
actual = breadth_first_traversal(fizz_buzz_tree(test).root)
assert expected == actual
def prep_max_min():
bt = BinaryTree()
bt.root = Node(6)
bt.root.right = Node(10)
bt.root.left = Node(5)
bt.root.left.left = Node(20)
bt.root.right.right = Node(15)
bt.root.right.left = Node(-1)
return bt
def prep():
bt = BinaryTree()
bt.root = Node(6)
bt.root.right = Node(10)
bt.root.left = Node(5)
bt.root.left.left = Node(-1)
bt.root.right.right = Node(15)
bt.root.right.left = Node(7)
return bt
def fizzy_tree():
## preparing data
tree = BinaryTree()
tree.root = Node(3)
tree.root.left = Node(5)
tree.root.right = Node(7)
tree.root.left.left = Node(15)
return tree
def prep():
bt = BinaryTree()
bt.root = Node(5)
bt.root.right = Node(10)
bt.root.left = Node(-2)
bt.root.right.left = Node(5)
bt.root.left.left = Node(17)
bt.root.right.right = Node(8)
return bt
def test_leftchild_rightchild():
bt = BinaryTree()
bt.root = Node(5)
bt.root.left = Node(4)
bt.root.right = Node(3)
assert bt.root.value == 5
assert bt.root.left.value == 4
assert bt.root.right.value == 3
assert bt.preorder() == [5, 4, 3]
def test_fizz_buzz_tree3():
bt = BinaryTree()
bt.root = Node(3)
bt.root.left = Node(5)
bt.root.right = Node(6)
bt.root.left.left = Node(9)
bt.root.right.right = Node(15)
actual = fizz_buzz_tree(bt).preorder()
expected = ['Fizz', 'Buzz', 'Fizz', 'Fizz', 'FizzBuzz']
assert actual == expected
def prepare_bt():
bt = BinaryTree()
bt.root = Node(7)
bt.root.left = Node(13)
bt.root.right = Node(5)
bt.root.left.left = Node(8)
bt.root.left.right = Node(9)
bt.root.right.left = Node(1)
bt.root.right.right = Node(-4)
return bt
def test_same_tree_type():
tree1 = BinaryTree()
tree1.root = Node(5)
tree1.root.right = Node(6)
tree1.root.left = Node(4)
tree1.root.right.right = Node(7)
tree1.root.right.left = Node(5)
tree1.root.left.left = Node(2)
tree1.root.left.right = Node(4)
tree2 = BinaryTree()
tree2.root = Node(4)
tree2.root.right = Node(6)
tree2.root.right.right = Node(7)
tree2.root.right.left = Node(5)
tree2.root.left = Node(3)
tree2.root.left.right = Node(3)
tree2.root.left.left = Node(2)
actual = tree_intersection(tree1, tree2)
expected = [6, 2, 5, 7]
assert actual == expected
def test_breadth_first_bt2():
bt = BinaryTree()
bt.root = Node(2)
bt.root.right = Node(7)
bt.root.left = Node(6)
bt.root.right.left = Node(2)
bt.root.left.left = Node(9)
bt.root.right.right = Node(5)
actual = bt.breadth_first(bt)
expected = [2, 7, 5, 2, 6, 9]
assert actual == expected
def test_breadth_first_bt():
bt = BinaryTree()
bt.root = Node(6)
bt.root.right = Node(5)
bt.root.left = Node(-1)
bt.root.right.left = Node(7)
bt.root.left.left = Node(10)
bt.root.right.right = Node(3)
actual = bt.breadth_first(bt)
expected = [6, 5, 3, 7, -1, 10]
assert actual == expected
def test_fizz_buzz_tree2():
bt = BinaryTree()
bt.root = Node(1)
bt.root.left = Node(2)
bt.root.right = Node(4)
bt.root.left.left = Node(13)
bt.root.left.right = Node(7)
bt.root.right.right = Node(8)
bt.root.right.right = Node(17)
actual = fizz_buzz_tree(bt).preorder()
expected = [1, 2, 13, 7, 4, 17]
assert actual == expected
def test_breadth_first_traversal1():
bt = BinaryTree()
bt.root = Node(2)
bt.root.left = Node(7)
bt.root.right = Node(5)
bt.root.left.left = Node(2)
bt.root.left.right = Node(6)
bt.root.left.right.left = Node(5)
bt.root.left.right.right = Node(11)
bt.root.right.right = Node(9)
bt.root.right.right.left = Node(4)
assert bt.breadthFirst(bt.root) == [2,7,5,2,6,9,5,11,4]
def fizz_buzz_tree(k_ary):
tree = BinaryTree()
if not k_ary.root: return tree
def _walk(current):
node = Node(comapre(current.value))
if current.left: node.left = _walk(current.left)
if current.right: node.right = _walk(current.right)
return node
tree.root = _walk(k_ary.root)
return tree
def fizz_buzz_tree(tree):
''' takes a k-ary tree as an argument
determine whether or not the value of each node is
divisible by 3, 5 or both.
'''
new_tree = BinaryTree()
new_node = Node()
if tree.root == None:
return new_tree
old_node = tree.root # root is ref to first node
def visit_node(old_node, new_node):
new_node.data = fizz_buzz(old_node.data)
if old_node.left:
new_node.left = Node()
visit_node(old_node.left, new_node.left)
if old_node.right:
new_node.right = Node()
visit_node(old_node.right, new_node.right)
def fizz_buzz(old_value):
result = ''
if old_value % 3 == 0:
result += 'Fizz'
if old_value % 5 == 0:
result += 'Buzz'
return result or str(old_value)
visit_node(old_node, new_node)
new_tree.root = new_node
return new_tree
# if __name__ == "__main__":
# tree = BinaryTree()
# tree.root = Node(3)
# tree.root.left = Node(5)
# tree.root.right = Node(7)
# tree.root.left.left = Node(15)
# print(fizz_buzz_tree(tree))
def test_fizz_buzz_tree():
bt = BinaryTree()
bt.root = _Node(2)
bt.root.left = _Node(7)
bt.root.right = _Node(5)
bt.root.left.left = _Node(2)
bt.root.left.right = _Node(6)
bt.root.right.right = _Node(9)
bt.root.right.right.left = _Node(4)
bt.root.left.right.right = _Node(11)
bt.root.left.right.left = _Node(15)
new = fizz_buzz_tree(bt)
assert breadth_first_traversal(new.root) == [
'2', '7', 'Buzz', '2', 'Fizz', 'Fizz', 'FizzBuzz', '11', '4'
]
def test_tree_with_minus():
test = BinaryTree()
test.root = _Node(-2)
test.root.left = _Node(-7)
test.root.right = _Node(-5)
test.root.left.left = _Node(-2)
test.root.left.right = _Node(-6)
test.root.right.right = _Node(-9)
test.root.right.right.left = _Node(-4)
test.root.left.right.right = _Node(-15)
test.root.left.right.left = _Node(0)
expected = [
'-2', '-7', 'Buzz', '-2', 'Fizz', 'Fizz', 'FizzBuzz', 'FizzBuzz', '-4'
]
actual = breadth_first_traversal(fizz_buzz_tree(test).root)
assert expected == actual
def test_difrent_tree_type():
tree3 = BinaryTree()
tree3.root = Node(5)
tree3.root.right = Node(6)
tree3.root.left = Node(4)
tree3.root.right.right = Node(7)
tree3.root.right.left = Node(5)
tree3.root.left.left = Node(2)
tree3.root.left.right = Node(4)
tree4 = BinarySearchTree()
tree4.add(4)
tree4.add(6)
tree4.add(7)
tree4.add(5)
tree4.add(3)
tree4.add(3)
tree4.add(2)
actual = tree_intersection(tree3, tree4)
expected = [6, 2, 5, 7]
assert actual == expected
tree = BinaryTree()
if not k_ary.root: return tree
def _walk(current):
node = Node(comapre(current.value))
if current.left: node.left = _walk(current.left)
if current.right: node.right = _walk(current.right)
return node
tree.root = _walk(k_ary.root)
return tree
def comapre(num):
if num % 3 == 0 and num % 5 == 0: return "FizzBuzz"
elif num % 3 == 0: return "Fizz"
elif num % 5 == 0: return "Buzz"
elif num % 3 != 0 and num % 5 != 0: return num
else: return str(num)
if __name__ == "__main__":
bt = BinaryTree()
bt.root = Node(1)
bt.root.left = Node(5)
bt.root.right = Node(9)
bt.root.left.left = Node(2)
bt.root.left.right = Node(18)
bt.root.right.right = Node(15)
print(fizz_buzz_tree(bt).preorder())
try:
x = any_list[0]
for i in any_list:
if i > x:
x = i
return x
except:
raise ValueError("empty tree !!")
output = tree.preOrder()
return _max_value(output)
if __name__ == "__main__":
bt = BinaryTree()
bt.root = Node(2)
bt.root.left = Node(7)
bt.root.right = Node(5)
bt.root.left.left = Node(2)
bt.root.left.right = Node(6)
bt.root.right.right = Node(9)
bt.root.right.right.left = Node(4)
bt.root.left.right.right = Node(11)
bt.root.left.right.left = Node(5)
bb = BinaryTree()
print(find_maximum_value(bb))
def test_breadth_first_traversal2():
bt = BinaryTree()
bt.root = _Node(2)
assert BinaryTree.breadth_first_traversal(bt.root) == [2]
from data_structures_and_algorithms.data_structures.tree.tree import BinaryTree, Node
def tree_intetsaction(tree1, tree2):
output = []
if tree1.root and tree2.root:
list1 = tree1.preorder()
list2 = tree2.preorder()
list2 = set(list2)
for i in list1:
if i in list2:
output.append(i)
return output
if __name__ == "__main__":
tr1 = BinaryTree()
tr2 = BinaryTree()
tr1.root = Node(5)
tr1.root.right = Node(10)
tr1.root.left = Node(-2)
tr1.root.right.left = Node(15)
tr1.root.left.left = Node(17)
tr2.root = Node(5)
tr2.root.right = Node(11)
tr2.root.left = Node(-2)
tr2.root.right.left = Node(15)
tr2.root.left.left = Node(111)
print(tree_intetsaction(tr1, tr2))
def test_test_with_one_node():
tr1 = BinaryTree()
tr2 = BinaryTree()
tr1.root = Node(5)
assert tree_intersection(tr1, tr2) == []