class BSTtreeDict(BST):
'''A BST-based implementation of a sorted dictionary'''
def __init__(self):
self._items = BST()
def __getitem__(self,key):
'''Returns the value associated with key or returns None if key does not exist.'''
return self._items.find(key)
def __setitem__(self, key, value):
self._items.add((key, value))
def __contains__(self,key):
return self.__getitem__(key) != None
def __str__(self):
return str(self._items)
def __len__(self):
return len(self._items)
def __iter__(self):
return iter(self._items)
def pop(self,key):
return self._items.remove(key)
def medium_depth():
"""a bst with several levels of depth"""
x = [10, 5, 3, 7, 2, 4, 6, 8, 15, 12, 11, 13, 17, 16, 18]
bst = BST()
for i in x:
bst.insert(i)
return bst
def test_medium_tree():
"""returns medium tree"""
l = [10, 5, 15, 3, 6, 14, 16]
tree = BST()
for i in l:
tree.insert(i)
return tree
def setUp(self):
self.bst = BST()
self.node_5 = Node(-5)
self.node_4 = Node(-4)
self.node_3 = Node(-3)
self.node_2 = Node(-2)
self.node_1 = Node(-1)
self.node0 = Node(0)
self.node1 = Node(1)
self.node2 = Node(2)
self.node3 = Node(3)
self.node4 = Node(4)
self.node5 = Node(5)
self.mytree = BST()
self.mytree.insert(5)
self.mytree.insert(2)
self.mytree.insert(3)
self.mytree.insert(1)
self.mytree.insert(4)
self.mytree.insert(0)
self.mytree.insert(2.5)
self.mytree.insert(8)
self.mytree.insert(9)
self.mytree.insert(6)
self.mytree.insert(4.5)
def test_large_tree():
"""returns large tree"""
l = [10, 5, 15, 9, 3, 4567, 55, 6, 1, 12334, 14, 16, 77, 24, 9]
tree = BST()
for i in l:
tree.insert(i)
return tree
def test_delete_head_only():
"""Test deleteing a one node head."""
from bst import BST
b = BST([20])
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
def short_depth():
"""a small bst with a depth of 2"""
x = [10, 3, 15, 4]
bst = BST()
for i in x:
bst.insert(i)
return bst
def test_insert_same():
"""Test that a value cannot be added to tree if it already exisits."""
from bst import BST
new_bst = BST()
new_bst.insert(5)
with pytest.raises(ValueError):
new_bst.insert(5)
def test_contains():
bst = BST()
for i in range(1,11):
bst.insert(i)
assert bst.contains(1)
assert bst.contains(5)
assert not bst.contains(15)
def test_building_to_fanciest01():
"""Everything works up to inserting 200."""
from bst import BST
b = BST()
b.insert(100)
b.insert(70)
b.insert(80)
b.insert(53)
b.insert(60)
b.insert(200)
assert b.root.value == 80
assert b.root.left_depth == 2
assert b.root.right_depth == 2
assert b.root.left.value == 60
assert b.root.left.left_depth == 1
assert b.root.left.right_depth == 1
assert b.root.left.left.value == 53
assert b.root.left.left.left_depth == 0
assert b.root.left.left.right_depth == 0
assert b.root.left.right.value == 70
assert b.root.left.right.left_depth == 0
assert b.root.left.right.right_depth == 0
assert b.root.right.value == 100
assert b.root.right.left_depth == 0
assert b.root.right.right_depth == 1
assert b.root.right.right.value == 200
assert b.root.right.right.left_depth == 0
assert b.root.right.right.right_depth == 0
def test_insert_two_nodes_one_return_root(empty_tree):
"""Test insert places lesser node to node root left."""
from bst import BST
bst = BST()
bst.insert(50)
bst.insert(45)
assert bst.root.val == 50
def test_node_left_and_right_attributes_change():
"""Test that left and right node attributes are added with insert."""
b = BST([5])
b.insert(4)
b.insert(6)
assert b.root.left.val == 4
assert b.root.right.val == 6
def test_insert_value_into_emtpy_bst_creates_root_node_with_value_inerted():
"""Test that inserting value into empty bst creates root node."""
from bst import BST
t = BST()
t.insert(5)
assert t.root
assert t.root.value == 5
def test_insert_value_less_than_root_value_creates_left_node_child():
"""Test inserting value less than root value creates left child node of root."""
from bst import BST
t = BST([5])
t.insert(4)
assert t.root.left.value == 4
assert t.root.right is None
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 long_depth():
"""a bst with several levels of depth"""
x = [6, 5, 7, 7, 2, 4, 6, 8, 16, 12, 10, 13, 17, 17, 6]
bst = BST()
for i in x:
bst.insert(i)
return bst
def main():
tree = BST()
tree.read_File('input.txt')
tree.print_tree()
tree.delete(19)
print('')
tree.print_tree()
def test_count_root(self):
root = BSTNode(10, 10, None)
tree = BST(root)
node = BSTNode(15, 10, None)
tree.AddKeyValue(15, 10)
self.assertEqual(tree.Count(), 2)
def test_depth():
aBST = BST()
assert aBST.depth() == 0
for num, depth in zip([4, 2, 6, 3, 7, 8, 9, 10, 11],
[1, 2, 2, 3, 3, 4, 5, 6, 7]):
aBST.insert(num)
assert aBST.depth() == depth
def test_balance():
aBST = BST()
assert aBST.balance() == 0
for num, bal in zip([4, 2, 6, 3, 7, 8, 9, 10, 11],
[0, 1, 0, 1, 0, -1, -2, -3]):
aBST.insert(num)
assert aBST.balance() == bal
def test_valid():
print('{}'.format('-' * 20))
print('Testing BST.valid:\n')
bst = BST()
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
bst = get_bst()
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('change bst property (change 19 to 29):')
bst._root._left._right._data = 29
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('change bst property (change 38 to 48):')
bst._root._left._right._data = 19
bst._root._right._right._left._data = 48
print('bst = {}'.format(bst.inorder()))
print('bst.valid() = {}'.format(bst.is_valid()))
print()
print('End of BST.valid testing')
print('{}\n'.format('-' * 20))
return
def check_intersection(hull1, hull2):
bstX_h1 = BST()
bstY_h1 = BST()
maxX_h2 = float('-inf')
minX_h2 = float('inf')
maxY_h2 = float('-inf')
minY_h2 = float('inf')
ptArray = hull1.points
ptArray2 = hull2.points
for vertex in hull1.vertices:
# print (ptArray[vertex])
bstX_h1.insert(ptArray[vertex][0])
bstY_h1.insert(ptArray[vertex][1])
for vertex in hull2.vertices:
maxX_h2 = max(maxX_h2, ptArray2[vertex][0])
minX_h2 = min(minX_h2, ptArray2[vertex][0])
maxY_h2 = max(maxY_h2, ptArray2[vertex][1])
minY_h2 = min(minY_h2, ptArray2[vertex][1])
len_x = functools.reduce(lambda x, y: x + 1,
bstX_h1.range(minX_h2, maxX_h2), 0)
len_y = functools.reduce(lambda x, y: x + 1,
bstY_h1.range(minY_h2, maxY_h2), 0)
return len_x > 0 and len_y > 0
def test_delete_2_works_on_node_with_one_right_child_left_side():
"""Test the delete_2 method deletes a node with a right child."""
from bst import BST
tree = BST([10, 6, 8, 9, 12, 16, 14])
tree.delete_2(6)
in_order_gen = tree.in_order()
assert [n for n in in_order_gen] == [8, 9, 10, 12, 14, 16]
def test_insert_value_grater_than_root_creates_right_node_child():
"""Test inserting value grater than root value creates right childe node of root."""
from bst import BST
t = BST([5])
t.insert(7)
assert t.root.right.value == 7
assert t.root.left is None
def test_child_setting():
"""Test that inserting a value less than
head sets right child value to head."""
from bst import BST
new_bst = BST()
new_bst.insert(5)
new_bst.insert(3)
assert new_bst.head.get_left_child().data == 3
def test_insert(self):
bst = BST()
self.assertTrue(bst.insert(5))
self.assertTrue(bst.insert(10))
self.assertTrue(bst.insert(1))
self.assertFalse(bst.insert(5))
self.assertTrue(bst.root.left is not None)
self.assertTrue(bst.root.right is not None)
def test_ordered_with_floats():
"""Test floats are returned properly."""
a = BST([1.8, 1.4, 1.9, 1.2])
b = a.ordered()
assert next(b) == 1.2
assert next(b) == 1.4
assert next(b) == 1.8
assert next(b) == 1.9
def tree_sort(self):
tree = BST()
if self is []:
return []
for i in range(len(self)):
tree.insert(self[i])
items = tree.inorder2()
return items
def test_delete_case_1(self):
print("Running test_delete_case_1")
h = BST([50, 30, 70, 20, 40, 60, 80])
h.delete(20)
self.check_multiline(str(h),
[["50"], ["30", "70"], ["_", "40", "60", "80"],
["_", "_", "_", "_", "_", "_"],
["30", "40", "50", "60", "70", "80"]])
def test_bst_can_take_string_at_initialization():
"""Test that the BST can take a string."""
from bst import BST
b = BST('abc')
assert b.size() == 3
assert b.depth() == 2
assert b.left_depth == 0
assert b.right_depth == 2
def tiny_tree():
from bst import BST
new_bst = BST()
new_bst.insert(30)
new_bst.insert(50)
new_bst.insert(75)
return new_bst
def test_post_order_sample_tree():
"""Check for the correct output of posto-t on a sample tree."""
tree = BST(SAMPLE_TREE)
gen = tree.post_order()
output = []
for i in range(10):
output.append(next(gen))
assert output == [1, 11, 10, 16, 12, 27, 28, 42, 30, 20]
def test_breadth_first_sample_tree():
"""Check for the correct output of bft on a right-imbalanced tree."""
tree = BST(SAMPLE_TREE)
gen = tree.breadth_first()
output = []
for i in range(10):
output.append(next(gen))
assert output == [20, 12, 30, 10, 16, 28, 42, 1, 11, 27]
def test_post_order_right_imba():
"""Check for the correct output of posto-t on a right-imbalanced tree."""
tree = BST(RIGHT_IMBALANCED)
gen = tree.post_order()
output = []
for i in range(6):
output.append(next(gen))
assert output == [6, 5, 4, 3, 2, 1]
def test_breadth_first_right_imba():
"""Check for the correct output of bft on a right-imbalanced tree."""
tree = BST(RIGHT_IMBALANCED)
gen = tree.breadth_first()
output = []
for i in range(6):
output.append(next(gen))
assert output == [1, 2, 3, 4, 5, 6]
def test_breadth_first_left_imba():
"""Check for the correct output of bft on a left-imbalanced tree."""
tree = BST(LEFT_IMBALANCED)
gen = tree.breadth_first()
output = []
for i in range(6):
output.append(next(gen))
assert output == [6, 5, 4, 3, 2, 1]
def test_bst_can_take_tuple_at_initialization():
"""Test that the BST can take a tuple."""
from bst import BST
b = BST((1, 2, 3))
assert b.size() == 3
assert b.depth() == 2
assert b.left_depth == 0
assert b.right_depth == 2
def test_larger_child():
"""Test that inserting a value greater than
head sets the left child of head."""
from bst import BST
new_bst = BST()
new_bst.insert(5)
new_bst.insert(9)
assert new_bst.head.get_right_child().data == 9
def test_post_order_left_imba():
"""Check for the correct output of posto-t on a left-imbalanced tree."""
tree = BST(LEFT_IMBALANCED)
gen = tree.post_order()
output = []
for i in range(6):
output.append(next(gen))
assert output == [1, 2, 3, 4, 5, 6]
def test_pre_order_solo():
"""Test running pre-order on a tree with one Node."""
from bst import BST
b = BST([132])
pre_ord = b.pre_order()
pre_ord_list = []
for ii in pre_ord:
pre_ord_list.append(ii)
assert pre_ord_list == [132]
def test_post_order_empty():
"""Test an empty Node returns empty list."""
from bst import BST
b = BST()
post_ord = b.post_order()
post_ord_list = []
for ii in post_ord:
post_ord_list.append(ii)
assert post_ord_list == []
def test_post_order_solo():
"""Test running post-order on a tree with one Node."""
from bst import BST
b = BST([35])
post_ord = b.post_order()
post_ord_list = []
for ii in post_ord:
post_ord_list.append(ii)
assert post_ord_list == [35]
def test_breath_first_empty():
"""Test an empty Node returns empty list."""
from bst import BST
b = BST()
breath = b.breath_first()
breath_first_list = []
for ii in breath:
breath_first_list.append(ii)
assert breath_first_list == []
def test_breath_first_solo():
"""Test running breath on a tree with one Node."""
from bst import BST
b = BST([25])
breath = b.breath_first()
breath_first_list = []
for ii in breath:
breath_first_list.append(ii)
assert breath_first_list == [25]
def test_in_order_solo():
"""Test running in-order on a tree with one Node."""
from bst import BST
b = BST([20])
in_ord = b.in_order()
in_ord_list = []
for ii in in_ord:
in_ord_list.append(ii)
assert in_ord_list == [20]
def test_inorder():
nums = range(1, 200)
random.shuffle(nums)
bst = BST()
for n in nums:
bst.add(n)
nums.sort()
assert bst.inorder() == sorted(nums)
def grade(self, array):
bst = BST()
for i in array:
bst.add(i)
array = sorted(array)
ptr = 0
for i in bst:
self.assertEqual(i, array[ptr])
ptr += 1
def test_in_order_empty():
"""Test an empty Node returns empty list."""
from bst import BST
b = BST()
in_ord = b.in_order()
in_ord_list = []
for ii in in_ord:
in_ord_list.append(ii)
assert in_ord_list == []
def test_insert_2(self):
# Arrange + Act
b = BST(1)
b.insert(3)
b.insert(2)
# Assert
self._check_node(b, 1, None, 3)
self._check_node(b.right, 3, 2, None)
self._check_node(b.right.left, 2, None, None)
def test_insert_5(self):
# Arrange + Act
b = BST(3)
b.insert(1)
b.insert(2)
# Assert
self._check_node(b, 3, 1, None)
self._check_node(b.left, 1, None, 2)
self._check_node(b.left.right, 2, None, None)
def test_insert_4(self):
# Arrange + Act
b = BST(2)
b.insert(3)
b.insert(1)
# Assert
self._check_node(b, 2, 1, 3)
self._check_node(b.left, 1, None, None)
self._check_node(b.right, 3, None, None)
def test_preorder(self):
bst = BST()
bst.insert(5)
bst.insert(10)
bst.insert(1)
bst.insert(3)
bst.insert(59)
preorder = bst.get_preorder()
expected = [1, 3, 5, 10, 59]
self.assertEqual(preorder, expected)
def test_insert_6(self):
# Arrange + Act
b = BST(3)
b.insert(2)
b.insert(1)
# Assert
self._check_node(b, 3, 2, None)
self._check_node(b.left, 2, 1, None)
self._check_node(b.left.left, 1, None, None)
def test_inorder(self):
bst = BST()
bst.insert(5)
bst.insert(10)
bst.insert(1)
bst.insert(3)
bst.insert(59)
inorder = bst.get_inorder()
expected = [5, 1, 3, 10, 59]
self.assertEqual(inorder, expected)
def test_postorder(self):
bst = BST()
bst.insert(5)
bst.insert(10)
bst.insert(1)
bst.insert(3)
bst.insert(59)
postorder = bst.get_postorder()
expected = [3, 1, 59, 10, 5]
self.assertEqual(postorder, expected)
def test_size():
aBST = BST()
assert aBST.size == 0
for num, size in zip([6, 2, 8, 4, 1000, -111],
[1, 2, 3, 4, 5, 6]):
aBST.insert(num)
assert aBST.size == size
for x in range(2000):
aBST.insert(uuid4())
assert aBST.size == 2006
def test_depth_collatz():
bst = BST()
for i in range(1,11):
if not i % 2:
i /= 2
else:
i = i * 3 + 1
print('i = {}'.format(i))
bst.insert(i)
assert bst.depth(bst.root) == 5
def bstsort(l):
arbol = BST()
# Generamos nuestra estructura
# de datos auxiliar
while l:
# Vaciamos la lista en el arbol
item = l.pop()
arbol.add(item)
l.extend(arbol.inorder())
def filled_tree():
A = Node(6)
a = BST()
a.root = A
A.left = 4
A.right = 7
A.left.left = 3
A.left.right = 5
A.right.right = 8
a._size = 6
return a
def test_depth():
bst = BST()
bst.insert(5)
assert bst.depth(node=bst.root) == 1
bst.insert(3)
bst.insert(4)
bst.insert(6)
assert bst.depth(node=bst.root) == 3
