def test_false(self):
bt = BinaryTree()
for x in [4, 2, 6, 8, 1, 5]:
bt.add(x)
self.assertEqual(bt.contains(3), False)
self.assertEqual(bt.contains(7), False)
self.assertEqual(bt.contains(9), False)
def test_true(self):
bt = BinaryTree()
for x in [4, 2, 6, 8, 1, 5]:
bt.add(x)
self.assertEqual(bt.contains(4), True)
self.assertEqual(bt.contains(5), True)
self.assertEqual(bt.contains(6), True)
self.assertEqual(bt.contains(8), True)
def test_add_to_tree(self):
name = "Jose"
value = 1
node = Node(name, value)
binary_tree = BinaryTree()
binary_tree.add(node)
self.assertEqual(binary_tree.get_root(), node)
def test_find_in_tree(self):
names = (("Jose", 2), ("Rolf", 1), ("Anna", 3))
nodes = [Node(name, value) for name, value in names]
binary_tree = BinaryTree()
for node in nodes:
binary_tree.add(node)
for i in range(0, len(nodes)):
self.assertEqual(binary_tree.find(nodes[i].value), nodes[i])
def test_add_many_to_tree(self):
names = (("Jose", 2), ("Rolf", 1), ("Anna", 3))
nodes = [Node(name, value) for name, value in names]
binary_tree = BinaryTree()
for node in nodes:
binary_tree.add(node)
self.assertEqual(binary_tree.get_root(), nodes[0])
self.assertEqual(binary_tree.get_root().get_left(), nodes[1])
self.assertEqual(binary_tree.get_root().get_right(), nodes[2])
def test_binary_tree():
b = BinaryTree()
b.add(4)
b.add(2)
b.add(5)
b.add(3)
b.add(1)
b.inorder()
from node import Node
from binary_tree import BinaryTree
tree = BinaryTree(Node(9))
tree.add(Node(5))
tree.add(Node(11))
tree.inorder()
tree.pre_order()
print(tree.find(11))
# print(tree.find(200)) -> LookUpError: A node with value 200 was not found.
print('--------')
tree = BinaryTree(Node(6))
nodes = [5, 3, 9, 7, 8, 7.5, 12, 11]
for n in nodes:
tree.add(Node(n))
tree.delete(9)
tree.inorder()
tree.pre_order()
from binary_tree import BinaryTree
from node import Node
tree = BinaryTree(Node(6))
nodes = [5, 3, 9, 7, 8, 7.5, 12, 11]
for n in nodes:
tree.add(Node(n))
tree.delete(9)
tree.inorder()
#######
from node import Node
left = Node(5)
head = Node(9)
right = Node(13)
head.left = left
head.right = right
print(head)
print(head.left)
print(head.right)
from node import Node
from binary_tree import BinaryTree
tree = BinaryTree(Node(6))
nodes = [5, 3, 9, 7, 8, 7.5, 12, 11]
for node in nodes:
tree.add(Node(node))
tree.delete(9)
tree.inorder()
class TestBinaryTree(unittest.TestCase):
def setUp(self) -> None:
self.binary_tree = BinaryTree()
def test_a_new_node_should_be_added_to_the_root_when_root_is_none(self):
self.binary_tree.add(5)
self.assertIsNotNone(self.binary_tree.root)
self.assertIsInstance(self.binary_tree.root, Node)
def test_a_new_node_should_not_be_added_to_the_root_when_it_is_not_none(
self):
self.binary_tree.add(5)
self.binary_tree.add(3)
self.assertEqual(self.binary_tree.root.data, 5)
def test_a_new_node_should_be_added_to_right_when_left_is_not_none(self):
self.binary_tree.add(5)
self.binary_tree.root.insert_left(2)
self.binary_tree.add(3)
self.assertEqual(self.binary_tree.root.preorder_traversal(), [5, 2, 3])
def test_a_new_node_should_be_added_to_left_when_right_is_not_none(self):
self.binary_tree.add(5)
self.binary_tree.root.insert_right(2)
self.binary_tree.add(3)
self.assertEqual(self.binary_tree.root.preorder_traversal(), [5, 3, 2])
def test_a_new_node_should_be_added_to_next_level_when_left_and_right_already_filled(
self):
self.binary_tree.add(0)
self.binary_tree.root.insert_right(1)
self.binary_tree.root.insert_left(2)
self.binary_tree.add(3)
self.assertEqual(self.binary_tree.root.preorder_traversal(),
[0, 2, 1, 3])
def test_right_node_should_be_filled_before_its_left_sibling(self):
self.binary_tree.add(0) # root
self.binary_tree.add(1) # root->right
self.binary_tree.add(2) # root->left
self.binary_tree.add(3) # root->right->right
self.binary_tree.add(4) # root->right->left
self.binary_tree.add(5) # root->left->right
self.binary_tree.add(6) # root->left->left
self.binary_tree.add(7) # root->right->right->right
self.assertEqual(self.binary_tree.root.preorder_traversal(),
[0, 2, 6, 5, 1, 4, 3, 7])
from binary_tree import BinaryTree
from node import Node
bt = BinaryTree(Node(14))
# num_list = [5,6,30,99,100,60,10,4]
num_list = [9, 13, 22, 34]
num_str = [str(i) for i in num_list]
for i in num_list:
bt.add(Node(i))
# bt.inorder()
#
# print(bt.find(99))
#
# bt.delete(99)
#
# bt.inorder()
#
# bt.delete(20)
#
bt.inorder()
bt.perorder()
bt.postorder()
# print("->".join(num_str))
from binary_tree import BinaryTree
if __name__ == '__main__':
tree = BinaryTree()
values = [5, 3, 2, 4, 7, 6, 8]
# 5
# / \
# 3 7
# / \ / \
# 2 4 6 8
[tree.add(x) for x in values]
print 'Input:',
print ', '.join(str(x) for x in values)
print '\nPrefixed.:',
for node in tree.course_prefixed():
print node.data,
print
print '\nInfixed..:',
for node in tree.course_infixed():
print node.data,
print
print '\nPostfixed:',
from binary_tree import BinaryTree
from datastructures.trees.binary_tree_traversal import BinaryTraversal
if __name__ == '__main__':
tree = BinaryTree()
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
tree.add(10)
tree.add(11)
tree.add(12)
tree.add(14)
tree.add(15)
tree.add(15)
tree.add(17)
tree.add(18)
traversal = BinaryTraversal()
print("Print level by Reverse Ordering")
traversal.level_order(tree.root, reverse=True)
print("\nPrint level by Natural Ordering")
traversal.level_order(tree.root)
print('\nHeight Of the Tree: ', traversal.height(tree.root))
print("Deepest Node: ", traversal.deepest_by_level(tree.root))
print("Test Node")
left = Node(5)
head = Node(9)
right = Node(13)
head.left = left
head.right = right
print(head)
print(head.left)
print(head.right)
print("Test Tree")
tree = BinaryTree(Node(9))
tree.add(Node(5))
tree.add(Node(13))
# print(tree.head)
# print(tree.head.left)
# print(tree.head.right)
tree.print_inorder(tree.head)
tree.print_pretty()
print(tree.find_parent(5))
print(tree.find_parent(9))
print(tree.find_parent(13))
print(tree.find_parent(20))
print(tree.find_max(tree.head))
def demo():
binary = BinaryTree()
for i in range(count):
binary.add(i)
binary.dump()
right_item = inorder(node.right)
return left_item + res + right_item
def preorder(node):
if node is None:
return []
res = [node.item]
left_item = preorder(node.left)
right_item = preorder(node.right)
return res + left_item + right_item
def postorder(node):
if node is None:
return []
res = [node.item]
left_item = postorder(node.left)
right_item = postorder(node.right)
return left_item + right_item + res
if __name__ == '__main__':
tree = BinaryTree()
for i in range(10):
tree.add(i)
tree.show_tree()
print('inorder:', inorder(tree.root))
print('preorder:', preorder(tree.root))
print('postorder:', postorder(tree.root))
# -*- coding: utf-8 -*-
# @Time : 2017/12/20 下午10:29
# @Author : KaWa
# @File : tests.py
# @Project : python-libs
# @Copyright(c) 2017 By KaWa All rights reserved.
from binary_tree import BinaryTree
if __name__ == "__main__":
tree = BinaryTree()
tree.add(0)
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
tree.breadth_travel()
print(" ")
tree.preorder_travel(tree.root)
print(" ")
tree.inorder_travel(tree.root)
print(" ")
tree.postorder_travel(tree.root)
print(" ")
