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)
