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]])
