def test(self): t1, t2 = BinarySearchTree(), BinarySearchTree() t1.insert(0) r = t1.root r.left = Node(1) r.right = Node(3) r.left.left = Node(4) r.left.right = Node(5) r.right.left = Node(6) r.right.right = Node(7) t2.insert(5) t2.insert(6) t2.insert(4) t2.insert(7) t2.insert(8) self.assertEqual(check_subtree(t1.root, t2.root), False) self.assertEqual(check_subtree_efficient(t1.root, t2.root), False) r.left.left.right = t2.root # Now t2 is a subtree of t1. self.assertEqual(check_subtree(t1.root, t2.root), True) self.assertEqual(check_subtree_efficient(t1.root, t2.root), True) self.assertEqual(check_subtree(t1.root.left.left, t2.root), True) self.assertEqual(check_subtree_efficient(t1.root.left.left, t2.root), True) r.left.left.right = Node(10) r.right.left.right = t2.root self.assertEqual(check_subtree(t1.root, t2.root), True) self.assertEqual(check_subtree_efficient(t1.root, t2.root), True)
def test(self): # Using the BST class, but it is not always a BST. t = BinarySearchTree() t.insert(0) self.assertEqual(check_bst(t), True) r = t.root r.left = Node(1) self.assertEqual(check_bst(t), False) r.left = Node(0) self.assertEqual(check_bst(t), True) r.right = Node(0) self.assertEqual(check_bst(t), False) r.left = Node(-1) r.right = Node(2) self.assertEqual(check_bst(t), True) r.left.left = Node(-3) r.left.right = Node(-2) self.assertEqual(check_bst(t), False) r.left.right = Node(3) self.assertEqual(check_bst(t), False) r.left.right = Node(-0.5) self.assertEqual(check_bst(t), True) r.right.left = Node(-10) self.assertEqual(check_bst(t), False) r.right.left = Node(1.5) self.assertEqual(check_bst(t), True) r.right.right = Node(2) self.assertEqual(check_bst(t), False) r.right.right = Node(4) self.assertEqual(check_bst(t), True) r.right.left = Node(2) self.assertEqual(check_bst(t), True) r.right.left = Node(3) self.assertEqual(check_bst(t), False)
def test_insert(): bst = BinarySearchTree() rbt = RedBlackTree() bst.insert(5) rbt.insert(5) assert bst.find(5) and rbt.find(5)
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_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_postorder(): bst = BinarySearchTree() rbt = RedBlackTree() data = gen_random_u_array(10) for d in data: bst.insert(d) rbt.insert(d) assert np.array_equal(bst.postorder(), rbt.postorder()) is False
def test_maximum(): bst = BinarySearchTree() rbt = RedBlackTree() data = gen_random_u_array(10) for d in data: bst.insert(d) rbt.insert(d) assert bst.maximum().key is rbt.maximum().key
def test_insertion_bst(): data = gen_random_u_array() sorted_data = SortedList(data) bst = BinarySearchTree() for d in data: bst.insert(d) assert np.array_equal(bst.inorder(), sorted_data)
def test_tree_height(): bst = BinarySearchTree() rbt = RedBlackTree() data = gen_random_u_array() for d in data: bst.insert(d) rbt.insert(d) assert bst.tree_height() is not rbt.tree_height()
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_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_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(self): t = BinarySearchTree() t.insert(1) root = t.root root.left = Node(2) root.right = Node(3) self.assertEqual(first_common_ancestor(t, root.left, root.right), root) self.assertIsNone(first_common_ancestor(t, root.left, Node(4)), None) root.left.left = Node(1) root.left.right = Node(2) self.assertEqual(first_common_ancestor(t, root.left.left, root.left.right), root.left) self.assertEqual(first_common_ancestor(t, root.left.left, root), root) self.assertEqual(first_common_ancestor(t, root.left.left, root.right), root)
def test_efficient(self): t = BinarySearchTree() t.insert(0) t.insert(0) t.insert(0) self.assertEqual(count_paths_efficient(t.root, 0), 6) t.root.item = 1 self.assertEqual(count_paths_efficient(t.root, 1), 3) self.assertEqual(count_paths_efficient(t.root, 0), 3) t.root = Node(2) t.insert(2) t.insert(2) self.assertEqual(count_paths(t.root, 4), 2)
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 extended_tree(): values = [61, 89, 66, 43, 51, 16, 55, 11, 79, 77, 82, 32, 100, 90] tree = BinarySearchTree() for v in values: tree.insert(v) return tree
def example_tree(): values = [61, 89, 66, 43, 51, 16, 55, 11, 79, 77, 82, 32] tree = BinarySearchTree() for v in values: tree.insert(v) return tree
import random from tree import BinarySearchTree random.seed(77) values = random.sample(range(1, 1000), 42) bst = BinarySearchTree() for v in values: bst.insert(v) bst.inorder_traversal() items = [1, 3, 981, 510, 1000] for item in items: r = bst.search(item) if r is None: print(item, "não encontrado") else: print(r.root.data, 'encontrado')
def convertBST3(self, root: TreeNode) -> TreeNode: if not root: return root accumulate_sum = 0 stack = [] cur = root while stack or cur: if cur: stack.append(cur) cur = cur.right else: pop_node = stack.pop() pop_node.val += accumulate_sum accumulate_sum = pop_node.val cur = pop_node.left return root s = Solution() convert = [s.convertBST, s.convertBST2, s.convertBST3] for c in convert: bst = BinarySearchTree() bst.insert(5) bst.insert(2) bst.insert(13) res = c(bst.root) print(TreeNode.levelOrder(res))
from tree import BinarySearchTree BST = BinarySearchTree(15) BST.insert(9) BST.insert(6) BST.insert(12) BST.insert(4) BST.insert(2) BST.insert(5) BST.insert(8) BST.insert(10) BST.insert(14) BST.insert(30) BST.insert(19) BST.insert(17) BST.insert(18) BST.insert(20) BST.insert(35) BST.insert(32) BST.insert(36) print("===Preorder===") BST.preorder() print("\n\n---------remove30-----------\n\n") BST.remove(30) BST.remove(17) print("===Preorder===") BST.preorder() print("\n===size, depth===\n")
def random_tree(size=42): values = random.sample(range(1, 1000), 42) tree = BinarySearchTree() for v in values: tree.insert(v) return tree
def test(self): t = BinarySearchTree() self.assertEqual(check_balanced_tree(t), False) t.insert(1) self.assertEqual(check_balanced_tree(t), True) t.insert(2) self.assertEqual(check_balanced_tree(t), True) t.insert(0) self.assertEqual(check_balanced_tree(t), True) t.insert(4) t.insert(6) self.assertEqual(check_balanced_tree(t), False) t.insert(3) self.assertEqual(check_balanced_tree(t), False) t.insert(-4) t.insert(-6) self.assertEqual(check_balanced_tree(t), False) t.insert(-3) t.insert(0.5) t.insert(1.5) self.assertEqual(check_balanced_tree(t), True)
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(self): t = BinarySearchTree() t.insert(2) t.insert(1) t.insert(3) self.assertEqual(arrays_making_bst(t.root), [[2, 1, 3], [2, 3, 1]])