def test_find(self):
tree = Tree(lt)
for (k, v) in [(0, "0"), (2, "2"), (2, "3"), (1, "1")]:
tree.insert(k, v)
assert tree.find(0) == (0, "0")
assert tree.find(1) == (1, "1")
assert tree.find(2) == (2, "3")
def test_del_root_in_single_node_tree():
"""Test deletion of root in tree of one node."""
from bst import Tree
new_bst = Tree()
new_bst.insert(10)
new_bst.delete(10)
assert new_bst.root is None
def main():
tree = BST()
lst = [50, 25, 75, 12, 35, 55, 80]
for _ in lst:
tree.insert(_, "hello")
postorder(tree.root)
def main():
tree = BST()
N = 11
_set = set([random.randint(1, N * N) for _ in range(N)])
for x in _set:
tree.insert(x, "")
print "original tree"
tree.pretty_print()
inorder = [node.key for node in tree.inorder_nodes()]
preorder = [node.key for node in tree.preorder_nodes()]
# now build a new tree from these traversals
root = binary_tree_from_traversals(preorder, inorder)
new_tree = BST()
new_tree.root = root
print "reconstructed tree"
new_tree.pretty_print()
# verify the correctness
for orig_node, cloned_node in zip(tree.levelorder_nodes(),
new_tree.levelorder_nodes()):
assert orig_node is not cloned_node
assert orig_node.key == cloned_node.key
def brute_sweep_intersections(segments):
start = time()
counter = 0
status = {
"upper": 0,
"lower": 1,
}
points = []
event_queue = Tree(event_lt)
status_queue = {}
for segment in segments:
event_queue.insert(upper_end(*segment), (status["upper"], segment))
event_queue.insert(lower_end(*segment), (status["lower"], segment))
while not event_queue.empty():
(_, (label, segment)) = event_queue.pop()
if label == status["upper"]:
for other in list(status_queue.keys()):
counter += 1
point = point_of_intersection(segment, other)
if point is not None:
points.append(point)
status_queue[segment] = None
else:
del status_queue[segment]
print(results(True, counter, not len(points) == len(set(points)), start))
return (segments, points)
def test_insert_mulitple_nodes_return_correct_size():
"""Test for multiple node insertion."""
from bst import Tree
test_tree = Tree()
test_values = random.sample(range(100), 10)
for i in test_values:
test_tree.insert(i)
assert test_tree.size() == len(test_values)
def test_search_one_node():
"""Test search for one node from inserted list of nodes."""
from bst import Tree
test_tree = Tree()
test_node_list = [1, 2, 3, 4, 5]
for i in test_node_list:
test_tree.insert(i)
assert test_tree.search(test_node_list[2]).data == 3
def test_search_mulitple_nodes():
"""Test multiple node searches."""
from bst import Tree
test_tree = Tree()
test_values = random.sample(range(100), 10)
for i in test_values:
test_tree.insert(i)
for j in test_values:
assert test_tree.search(j).data == j
def test():
from bst import Tree
x = [10, 33, 1, 5, 65, 3, 25, 167, 34, 6, 15, 28]
bst = Tree(x[0])
for val in x[1:]:
bst.insert(bst.root, val)
i = BSTIterator(bst.root)
while i.hasNext():
print(i.next())
def insert_balanced(num):
num_of_runs = num
from bst import Tree
tree = Tree(50)
while num_of_runs > 0:
left_num = LESSER[num_of_runs]
right_num = GREATER[num_of_runs]
tree.insert(left_num)
tree.insert(right_num)
num_of_runs -= 1
return tree
def balanced_7_nodes():
"""Create balanced tree with 3 nodes."""
from bst import Tree
t = Tree()
t.insert(10)
t.insert(5)
t.insert(15)
t.insert(20)
t.insert(13)
t.insert(3)
t.insert(7)
return t
def main():
tree = BST()
N = 11
_set = set([random.randint(1, N * N) for _ in range(N)])
# _set = [50, 6, 33, 20, 35, 36]
for x in _set:
tree.insert(x, "")
# just set the root to 0 so the full tree is not BST
tree.root.key = 0
tree.pretty_print()
print "largest bst with nodes: %d" % largest_bst(tree.root)
def main():
tree = BST()
N = 6
_set = set([random.randint(1, N * N) for _ in range(N)])
for x in _set:
tree.insert(x, "")
tree.pretty_print()
mirror_image(tree.root)
print ""
print "after inverting"
print ""
tree.pretty_print()
def main():
tree = BST()
N = 10
_set = set([random.randint(1, N * N) for _ in range(N)])
for x in _set:
tree.insert(x, "")
tree.pretty_print()
postorder = [node.key for node in tree.postorder_nodes()]
print postorder
postorder_iterator = PostorderIterator(tree.root)
idx = 0
while postorder_iterator.has_next():
postorder_iterator.next() is postorder[idx]
idx += 1
def main():
tree = BST()
N = 10
_set = set([random.randint(1, N * N) for _ in range(N)])
for x in _set:
tree.insert(x, "hello")
inorder_result = []
inorder(tree.root, inorder_result)
iterator_result = []
iterator = InorderIterator(tree.root)
while iterator.has_next():
iterator_result.append(iterator.next().key)
assert inorder_result == iterator_result
def main():
tree = BST()
N = 10
_set = set([random.randint(1, N * N) for _ in range(N)])
for x in _set:
tree.insert(x, "")
new_root = clone(tree.root)
new_tree = BST()
new_tree.root = new_root
for orig_node, cloned_node in zip(tree.levelorder_nodes(),
new_tree.levelorder_nodes()):
assert orig_node is not cloned_node
assert orig_node.key == cloned_node.key
assert orig_node.data == cloned_node.data
def get_avg_height(N: int, t: int, print_statements=False) -> float:
height_sum = 0
for i in range(t):
rand = [random.randrange(1, 501) for x in range(N)]
tree = Tree()
for x in rand:
tree.insert(x)
height_sum += tree.height()
if print_statements:
print("The height of the tree with {} nodes is {}".format(
N, tree.height()))
avg = height_sum / t
if print_statements:
print("The average height is", avg)
return avg
def main():
t1 = BST()
N = 5
arr1 = list(set([random.randint(1, 10) for _ in range(N)]))
arr2 = list(set([random.randint(1, 10) for _ in range(N)]))
print arr1
print arr2
for e in arr1:
t1.insert(e, "")
t2 = BST()
for e in arr2:
t2.insert(e, "")
merged_tree = merge(t1, t2)
inorder_merged = []
inorder(merged_tree.root, inorder_merged)
merged_tree.levelorder()
assert sorted(arr1 + arr2) == [x.key for x in inorder_merged]
def test_get_depth_small_tree():
"""Test multiple nodes has depth of 3."""
from bst import Tree
test_tree = Tree()
test_tree.insert(5)
test_tree.insert(2)
test_tree.insert(3)
test_tree.insert(1)
test_tree.insert(7)
assert test_tree.get_depth(test_tree.root) == 3
def main():
_50 = Node(50, "hello")
_25 = Node(25, "hello")
_75 = Node(75, "hello")
_12 = Node(12, "hello")
_34 = Node(34, "hello")
_60 = Node(60, "hello")
_80 = Node(80, "hello")
_55 = Node(55, "hello")
_22 = Node(22, "hello")
_50.left = _25
_50.right = _75
_25.left = _12
_25.right = _34
_75.left = _60
_75.right = _80
_12.right = _55
assert False is is_bst(_50)
_12.right = _22
assert True is is_bst(_50)
tree = BST()
N = 10
for _ in range(N):
tree.insert(random.randint(1, 100), "hello")
assert True is is_bst(tree.root)
# skewed tree
tree = BST()
for n in range(N):
tree.insert(n, "hello")
assert True is is_bst(tree.root)
# skewed tree
tree = BST()
for n in range(N, 0, -1):
tree.insert(n, "hello")
assert True is is_bst(tree.root)
def test_get_depth_one_node():
"""Test one node has depth of one."""
from bst import Tree
test_tree = Tree()
test_tree.insert(5)
assert test_tree.get_depth(test_tree.root) == 1
def fill_tree(l):
out = Tree()
for n in l:
out.insert(n)
return out
def main():
""" Example usage """
# Insert nodes in tree
tree = Tree(Node(9)) # root node
tree.insert(Node(6))
tree.insert(Node(22))
tree.insert(Node(1))
tree.insert(Node(4))
tree.insert(Node(2))
tree.insert(Node(18))
"""
Tree after above insertion:
9
/ \
6 22
/ /
1 18
\
4
/
2
"""
# Traverse tree
print('Pre-order traversal:'),
print(', '.join(str(node.val) for node in tree.preorder_traverse()))
print('\nIn-order traversal:'),
print(', '.join(str(node.val) for node in tree.inorder_traverse()))
print('\nPost-order traversal:'),
print(', '.join(str(node.val) for node in tree.postorder_traverse()))
# Find smallest
print('\nSmallest:'),
print(tree.find_min().val)
# Find biggest
print('\nBiggest:'),
print(tree.find_max().val)
# Find all smaller than 7
smaller_than = 7
print('\nSmaller than {0}:'.format(smaller_than)),
print(', '.join(str(node.val) for node in tree.find_smaller(smaller_than)))
# Find all bigger than 5
bigger_than = 5
print('\nBigger than {0}:'.format(bigger_than)),
print(', '.join(str(node.val) for node in tree.find_bigger(bigger_than)))
# Check if tree contains 4
contains = 4
print('\nNode {0} exists in tree == {1}'.format(contains, tree.contains(contains)))
# Delete leaf node 18
delete = 18
print('\nNode {0} was deleted == {1}'.format(delete, tree.delete(delete)))
def test_contains_false(even, odd):
from bst import Tree
tree = Tree(216)
tree.insert(even)
assert not tree.contains(odd)
def one_t():
"""Create tree with one node."""
from bst import Tree
t = Tree()
t.insert(10)
return t
def test_insert_one_node_return_size_one():
"""Test for one node insertion."""
from bst import Tree
test_tree = Tree()
test_tree.insert(1)
assert test_tree.size() == 1
class TreeTestCase(unittest2.TestCase):
def setUp(self):
self.tree = Tree(Node(9))
def tearDown(self):
self.tree = None
def test_find_node(self):
self.assertTrue(self.tree.find_node(9), self.tree.root)
self.assertFalse(self.tree.find_node(1), self.tree.root)
self.assertFalse(self.tree.find_node(15), self.tree.root)
def test_contains(self):
self.assertFalse(self.tree.contains(1))
self.assertFalse(self.tree.contains(15))
def test_insert(self):
self.tree.insert(Node(6))
self.assertTrue(self.tree.contains(6))
def test_delete(self):
self.tree.insert(Node(13))
self.tree.insert(Node(7))
self.assertTrue(self.tree.delete(13)) # leaf
self.assertTrue(self.tree.delete(7))
self.assertFalse(self.tree.delete(13))
self.tree.insert(Node(13))
self.tree.insert(Node(12))
self.assertFalse(self.tree.delete(13))
def test_find_smaller(self):
self.tree.insert(Node(4))
self.tree.insert(Node(2))
self.tree.insert(Node(6))
self.tree.insert(Node(15))
self.assertEqual([node.val for node in self.tree.find_smaller(9)], [4, 2, 6])
def test_find_bigger(self):
self.tree.insert(Node(22))
self.tree.insert(Node(18))
self.tree.insert(Node(25))
self.assertEqual([node.val for node in self.tree.find_bigger(9)], [22, 25, 18])
def test_find_min(self):
self.tree.insert(Node(2))
self.tree.insert(Node(18))
self.tree.insert(Node(4))
self.assertEqual(self.tree.find_min().val, 2)
def test_find_max(self):
self.tree.insert(Node(2))
self.tree.insert(Node(18))
self.tree.insert(Node(4))
self.tree.insert(Node(13))
self.assertEqual(self.tree.find_max().val, 18)
def test_preorder_traverse(self):
self.tree.insert(Node(6))
self.tree.insert(Node(22))
self.tree.insert(Node(1))
self.tree.insert(Node(4))
self.tree.insert(Node(2))
self.tree.insert(Node(18))
self.assertEqual([node.val for node in self.tree.preorder_traverse()], [9, 6, 1, 4, 2, 22, 18])
def test_inorder_traverse(self):
self.tree.insert(Node(6))
self.tree.insert(Node(22))
self.tree.insert(Node(1))
self.tree.insert(Node(4))
self.tree.insert(Node(2))
self.tree.insert(Node(18))
self.assertEqual([node.val for node in self.tree.inorder_traverse()], [1, 2, 4, 6, 9, 18, 22])
def test_postorder_traverse(self):
self.tree.insert(Node(6))
self.tree.insert(Node(22))
self.tree.insert(Node(1))
self.tree.insert(Node(4))
self.tree.insert(Node(2))
self.tree.insert(Node(18))
self.assertSequenceEqual([node.val for node in self.tree.postorder_traverse()], [2, 4, 1, 6, 18, 22, 9])
def test_if_non_int_or_float_passed_raises_error():
"""Test if typeerror is raised when str passed to insert method."""
from bst import Tree
new_tree = Tree()
with pytest.raises(TypeError):
new_tree.insert('word')
def seed_none(self, xs):
tree = Tree(lt)
for x in xs:
tree.insert(x, None)
return tree
def sweep_intersections(segments):
start = time()
counter = 0
status = {
"upper": 0,
"intersection": 1,
"lower": 2,
}
points = []
memo = {}
event_queue = Tree(event_lt)
status_queue = Tree(status_lt)
for segment in segments:
event_queue.insert(upper_end(*segment), (status["upper"], segment))
event_queue.insert(lower_end(*segment), (status["lower"], segment))
while not event_queue.empty():
(event, (label, payload)) = event_queue.pop()
(_, y) = event
if label == status["upper"]:
memo[payload] = event
status_queue.insert((event, payload), None)
(left, right) = status_queue.neighbors((event, payload))
if left is not None:
((_, left_segment), _) = left
counter += 1
update_points(
event_queue,
y,
left_segment,
payload,
status["intersection"],
)
if right is not None:
((_, right_segment), _) = right
counter += 1
update_points(
event_queue,
y,
payload,
right_segment,
status["intersection"],
)
elif label == status["lower"]:
(left, right) = status_queue.neighbors((memo[payload], payload))
status_queue.delete((memo[payload], payload))
if (left is not None) and (right is not None):
((_, left_segment), _) = left
((_, right_segment), _) = right
counter += 1
update_points(
event_queue,
y,
left_segment,
right_segment,
status["intersection"],
)
else:
points.append(event)
(right, left) = payload
status_queue.delete((memo[left], left))
status_queue.delete((memo[right], right))
memo[left] = event
memo[right] = event
status_queue.insert((memo[left], left), None)
status_queue.insert((memo[right], right), None)
(far_left, _) = status_queue.neighbors((memo[left], left))
(_, far_right) = status_queue.neighbors((memo[right], right))
if far_left is not None:
((_, far_left_segment), _) = far_left
counter += 1
update_points(
event_queue,
y,
far_left_segment,
left,
status["intersection"],
)
if far_right is not None:
((_, far_right_segment), _) = far_right
counter += 1
update_points(
event_queue,
y,
right,
far_right_segment,
status["intersection"],
)
print(results(False, counter, not len(points) == len(set(points)), start))
return (segments, points)
def test_contains_true(even):
from bst import Tree
tree = Tree(4)
tree.insert(even)
assert tree.contains(even)
