def test_BST_traversal(): t = BinarySearchTree() for i, key in enumerate("ASERCHINGXMPL"): t.insert(key, i) assert t.height() == 9 assert t.traverse_preorder() == list("ASECRHGINMLPX") assert t.traverse_inorder() == list("ACEGHILMNPRSX") assert t.traverse_postorder() == list("CGLMPNIHREXSA") assert t.traverse_preorder_stack() == list("ASECRHGINMLPX")
def test_add_four_member_unbalance(): tree = BinarySearchTree() tree.add(-6) tree.add(8) tree.add(7) tree.add(-7) assert tree._root.value == -6 assert tree._root.left.value == -7 assert tree._root.right.value == 8 assert tree._root.right.left.value == 7
def test_left_right(): bst = BinarySearchTree() bst.add(2) bst.add(4) bst.add(6) expected = [2, 4, 6] actual = bst.pre_order() assert actual == expected
def test_return_postorder_traversal(): tree = BinarySearchTree() tree.add(3) tree.add(2) tree.add(6) actual = tree.post_order() expected = [2,6,3] assert actual == expected
def test_can_use_add_method_to_add_to_tree(): tree = BinarySearchTree() tree.add(3) tree.add(6) tree.add(4) actual = tree.preorder() expected = [3, 6, 4] assert actual == expected
def test_pre_order(): tree_stuff = BinarySearchTree() tree_stuff.add(5) tree_stuff.add(6) tree_stuff.add(7) tree_stuff.add(8) actual = tree_stuff.pre_order() expected = [5, 6, 7, 8] assert actual == expected
def test_return_inorder_traversal(): tree = BinarySearchTree() traverse = BinaryTree() tree.add(3) tree.add(2) tree.add(6) actual = tree.in_order() expected = [2,3,6] assert actual == expected
def test_return_preorder_traversal(): tree = BinarySearchTree() traverse = BinaryTree() tree.add(3) tree.add(2) tree.add(6) actual = tree.pre_order() expected = [3,2,6] assert actual == expected
def test_reads_four(): tree = BinarySearchTree() tree.add(67) tree.add(62) tree.add(65) tree.add(90) assert tree.root.data == 67 assert tree.root.left.data == 62 assert tree.root.right.data == 90 assert tree.breadth_first() == [67, 62, 90, 65]
def pre_order(): """Can successfully return a collection from a preorder traversal""" tree = BinarySearchTree() tree.add(45) tree.add(15) tree.add(60) assert pre_order() == [45,15,60]
def post_order(): """Can successfully return a collection from an postorder traversal""" tree = BinarySearchTree() tree.add(45) tree.add(15) tree.add(60) assert post_order() == [15,60,45]
def test_breadth(): bt = BinaryTree() bst = BinarySearchTree() bt.add(4) bt.add(7) bt.add(5) bt.add(9) bt.add(2) bt.add(30) bt.add(-1) actual = bt.breadth_first() expected = [4, 7, 5, 9, 2, 30, -1] assert actual == expected
def test_BST(): t = BinarySearchTree() data = list(range(100)) random.shuffle(data) for val in data: t.insert(val, val ** 2) for val in range(100): assert t.find(val) == val ** 2 assert t.find_recursive(t.root, val) == val ** 2 assert t.min() == 0 assert t.max() == 99
def test_add_two_nodes(): """Can add multiple nodes/levels to a binary search tree""" bst = BinarySearchTree() bst.add(10) bst.add(5) assert bst.root.value == 10 assert bst.root.left_child.value == 5
def test_three(): tree = BinarySearchTree() tree.add(77) tree.add(66) tree.add(88) actual = breadth_first(tree) expected = [77, 66, 88] assert actual == expected
def test_add_three_member(): tree = BinarySearchTree() tree.add(6) tree.add(5) tree.add(7) assert tree._root.value == 6 assert tree._root.left.value == 5 assert tree._root.right.value == 7
def test_add_left_right(): """Can successfully add a left child and right child to a single root node""" tree = BinarySearchTree() tree.add(45) tree.add(15) tree.add(60) assert tree.root.value==45 assert tree.left.value==15 assert tree.right.value==60
def test_bst(): tree = BinarySearchTree() data_list = [random.randint(0, 10000) for _ in range(1000)] for elem in data_list: tree.insert(elem) for elem in data_list: assert tree.find(elem).data == elem assert is_bst(tree) for elem in data_list: tree.delete(elem) assert is_bst(tree)
def test_insert_method_for_BST(): bst = BinarySearchTree(BinarySearchTree.build(SIMPLE_TREE)) for use_case, *expected_result in [ (1, True, """ -- 8 | |-- 4 | | |-- 2 | | | |-- 1 | | |-- 6 | |-- 10 | | |-- 20"""), (15, True, """ -- 8 | |-- 4 | | |-- 2 | | | |-- 1 | | |-- 6 | |-- 10 | | |-- 20 | | | |-- 15"""), (15, False, """ -- 8 | |-- 4 | | |-- 2 | | | |-- 1 | | |-- 6 | |-- 10 | | |-- 20 | | | |-- 15"""), ]: insert_result, tree_repr = expected_result result = bst.insert(use_case) assert result == insert_result, "{} != {}".format(result, insert_result) assert str(bst) == tree_repr, "{} != {}".format(str(bst), tree_repr)
def test_add_X_random(): vals = [] tree = BinarySearchTree() for j in range(50): # Generate a list of X elements (not duplicate) while True: x = str(random.randint(1, 200)) try: noused = vals.index(x) except: # No Found break vals.append(x) tree.add(x) actual = tree.returnAsArr(TraverseMethod.IN_ORDER) vals.sort() expected = vals assert expected == actual
def test_left_and_right(): tree_stuff = BinarySearchTree() tree_stuff.add(3) tree_stuff.add(2) tree_stuff.add(4) left = tree_stuff.root.left.value expect_left = 2 right = tree_stuff.root.right.value expect_right = 4 assert left == expect_left assert right == expect_right
def test_left_and_right_children(): """ Can successfully add a left child and right child to a single root node """ tree = BinarySearchTree() tree.add(6) tree.add(5) tree.add(7) assert tree.root.left.data == 5 assert tree.root.right.data == 7 assert tree.root.right.right is None
def tree(): ten = Node(10) five = Node(5) two = Node(2) seven = Node(7) six = Node(6) nine = Node(9) twenty = Node(20) fifteen = Node(15) thirty = Node(30) ten.left = five ten.right = twenty five.left = two five.right = seven seven.left = six seven.right = nine twenty.left = fifteen twenty.right = thirty return BinarySearchTree(ten)
def create_int_tree(): """ instantiate and fill a small BST--see visual in images """ eleven = Node(11) ten = Node(10) nine = Node(9) twelve = Node(12) thirteen = Node(13) seven = Node(7) fifteen = Node(15) #sub-trees ten.left = nine ten.right = twelve thirteen.left = seven thirteen.right = fifteen #first sub-tree tree = BinarySearchTree(eleven) tree.root.left = ten tree.root.right = thirteen return tree
from tree import Tree, BinarySearchTree t = Tree() t.insert_root("A") t.insert_left(t.root, "B") t.insert_right(t.root, "C") t.insert_left(t.root.left, "D") t.insert_right(t.root.left, "E") t.insert_right(t.root.right, "F") print(t) t2 = BinarySearchTree() t2.insert(2) t2.insert(5) t2.insert(8) t2.insert(11) t2.insert(1) t2.insert(7) print(t2) print(t2.inorder())
def test_contains(): Binary_tree = BinarySearchTree() Binary_tree.add(2) assert Binary_tree.root.value == 2
cur = cur.left if stack: popped = stack.pop() if popped.value == val: return True cur = popped.right if cur is None and not stack: done = 1 return False if __name__ == '__main__': tree = BinarySearchTree() tree.add(15) tree.add(8) tree.add(18) tree.add(13) tree.add(7) tree.add(20) tree.add(22) tree.add(19) #tree.print_inorder() #print(searchRecursive(tree.root, 20)) #print(searchRecursive(tree.root, 30)) #print(searchLevelOrder(tree.root, 20)) #print(searchLevelOrder(tree.root, 30)) print(searchInorder(tree.root, 20)) print(searchInorder(tree.root, 30))
def test_sanity(self): def check_tree_sanity(cls): array = [2, 3, 1, 7, 9, 5, 6, 11] array_sorted = [1, 2, 3, 5, 6, 7, 9, 11] t = cls(array) self.assertTrue(t.sanity()) #self.assertEqual(t.height(), 5) self.assertListEqual([n.key for n in t.as_list()], array_sorted) self.assertEqual(t.max().key, 11) self.assertEqual(t.min().key, 1) # test predecessor and successor for i in range(len(array_sorted)): if i != 0: # test predecessor self.assertEqual(t.predecessor(array_sorted[i]).key, array_sorted[i - 1]) if i != len(array_sorted) - 1: # test successor self.assertEqual(t.successor(array_sorted[i]).key, array_sorted[i + 1]) # inster & deletion test for key in [8, 4, 20, 100, 12, 10]: t.insert(key) self.assertTrue(t.sanity()) self.assertTrue(t.find(key)) # should find the key keys = [n.key for n in t.as_list()] random.shuffle(keys) length = len(keys) for key in keys: t.delete(key) length -= 1 self.assertTrue(t.sanity()) self.assertEqual(length, len(t.as_list())) self.assertFalse(t.find(key)) # key should gone from tree import BinarySearchTree check_tree_sanity(BinarySearchTree) # test rotate t = BinarySearchTree([10, 7, 5, 8, 4, 6]) t.rotate(7, 'right') self.assertEqual(6, len(t.as_list())) self.assertTrue(t.sanity()) t.rotate(5, 'left') self.assertEqual(6, len(t.as_list())) self.assertTrue(t.sanity()) from rbtree import RBTree check_tree_sanity(RBTree) # treap test from treap import Treap check_tree_sanity(Treap) # split array = [1, 5, 89, 37, 897, 32, 39, 9, 2, 68, 234, 7, 66, 99] t = Treap(array) t.sanity() s = 50 less, more = t.split(s) more.sanity() less.sanity() assert all([n.key >= s for n in more.as_list()]) assert all([n.key <= s for n in less.as_list()]) from avltree import AVLTree check_tree_sanity(AVLTree)
def test_binary_search_tree_can_successfully_sort_values(): tree = BinarySearchTree() tree.add(4) tree.add(9) tree.add(2) tree.add(42) tree.add(3) tree.add(15) tree.add(1) tree.add(21) actual = tree.root.right.right.value expected = 42 assert actual == expected
def test_one_node_BST(): actual = BinarySearchTree('a').root expected = 'a' assert actual == expected
def test_create_empty_BST(): actual = BinarySearchTree().root expected = None assert actual == expected
if root is None: return [] if root.left is None and root.right is None and root.value == sum: path.append(root.value) results.append(path) sum -= root.value pathhelper(root.left, sum, results, path + [root.value]) pathhelper(root.right, sum, results, path + [root.value]) if __name__ == '__main__': tree = BinarySearchTree() tree.add(8) tree.add(12) tree.add(7) tree.add(5) print(hasPathSumpaths(tree.root, 20)) """ Questions for Shivraj: Binary tree lookup/search using inorder? What does use mean DFS pathSum Binary tree lookup/search using level order traversal hasPathSum iterative(not needed) isBST inorder traversal will print a sorted list least common ancestor loggin system """
def test_instantiate_single_root(): tree = BinarySearchTree() tree.add(1) assert tree.root.value == 1
''' Programmer: Stanley Wong Description: Binary Search Tree Driver ''' from treeNode import Node from tree import BinarySearchTree myTree = BinarySearchTree() myTree.add(10) myTree.add(7) myTree.add(5) myTree.add(3) myTree.add(4) myTree.add(1) myTree.add(2) myTree.add(8) myTree.add(9) myTree.add(13) myTree.add(12) myTree.add(16) myTree.add(20) myTree.add(12) myTree.add(18) myTree.add(22) myTree.add(19) print "\nOriginal List"
def __init__(self): BinarySearchTree.__init__(self)