class Splay_Tree_Test_Has_Key_with_Single_Node_Tree(unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=10, obj='Object value')
def test_has_key_empty_tree(self):
self.assertEqual(
10 in self._splaytree, True,
'Tree has_key operation must return True for existing key')
def tearDown(self):
self._splaytree = None
def setUp(self):
self._splay_tree = SplayTree()
self._splay_tree.insert(key=5, obj=5)
self._splay_tree.insert(key=8, obj=8)
self._splay_tree.insert(key=7, obj=7)
self._splay_tree.insert(key=9, obj=9)
self._splay_tree.insert(key=10, obj=10)
self._splay_tree.insert(key=2, obj=2)
self._splay_tree.insert(key=1, obj=1)
self._splay_tree.insert(key=3, obj=3)
self._splay_tree.insert(key=4, obj=4)
self._splay_tree.insert(key=6, obj=6)
class Splay_Tree_Test_Empty_Tree(unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
def test_node_count_of_empty_tree(self):
self.assertEqual(self._splaytree.node_count, 0,
'Empty tree node count must be 0')
def test_find_key_empty_tree(self):
self.assertEqual(self._splaytree.find(20), None,
'Empty tree find operation must return None')
def test_delete_element_empty_tree(self):
self._splaytree.remove(20)
def tearDown(self):
self._splaytree = None
class Splay_Tree__Test_Inorder_Traversal_with_Stack_On_Single_Node_Tree(
unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=10, obj=10)
def test_inorder_traversal_with_single_node_tree(self):
in_order_elements = []
for key, element in self._splaytree.inorder_traversal_with_stack():
in_order_elements.append(element)
self.assertEqual(
1, len(in_order_elements),
'In order traversal on single node tree must yield one elements')
self.assertEqual(
in_order_elements, [10],
'In order traversal did not yield expected elements in order')
def tearDown(self):
self._splaytree = None
class Splay_Tree_Test_Preorder_Traversal_with_Single_Node_Tree(
unittest.TestCase):
def setUp(self):
self._splay_tree = SplayTree()
self._splay_tree.insert(key=10, obj=10)
def test_preorder_traversal_with_single_node_tree(self):
pre_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=True,
want_in_order=False,
want_post_order=False):
pre_order_elements.append(element)
self.assertEqual(
1, len(pre_order_elements),
'Pre order traversal on single node tree must yield no elements')
self.assertEqual(
pre_order_elements, [10],
'Pre order traversal did not yield expected elements in order')
def tearDown(self):
self._splay_tree = None
class Splay_Tree_Test_Tree_Structure_After_Insert_With_Inorder_Traversal(
unittest.TestCase):
'''
The purpose of this test is to make sure that the splay op does not ruin the tree. So after each insert we check the
tree structure.
'''
def setUp(self):
self._splaytree = SplayTree()
def test_tree_structure_after_each_insert_with_inorder_traversal(self):
expected_inorder_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
inorder_from_tree = []
for i in range(1, 11): # 1 to 10
self._splaytree.insert(i, i)
for key, element in self._splaytree.traversal(want_in_order=True):
inorder_from_tree.append(element)
self.assertEqual(inorder_from_tree,
expected_inorder_list[:len(inorder_from_tree)],
'Tree ruined during insert splays')
inorder_from_tree = []
def tearDown(self):
self._splaytree = None
class Splay_Tree__Test_Inorder_Traversal_Using_Stack_with_empty_Tree(
unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
def test_inorder_traversal_with_empty_tree(self):
in_order_elements = []
for key, element in self._splaytree.inorder_traversal_with_stack():
in_order_elements.append(element)
self.assertEqual(
0, len(in_order_elements),
'In order traversal on empty tree must yield no elements')
def tearDown(self):
self._splaytree = None
class SplayedHashBucket(collections.MutableMapping):
'''
A hash bucket is used to hold objects that hash to the same value in a hash table.
This is hash bucket using a splay tree. This masquerades as a python dict in code
where it is used. Since splat tree is used lookups on avg take Olog(n)
Note: HASHBUCKET ITERATION YIELDS KEYS. not the key value pairs in the bucket.
'''
def __init__(self):
self._st = SplayTree()
def __len__(self):
return self._st.node_count
def get(self, key, default = None):
'''
Get object associated with a key and on key miss return specified default. This is
there in Python dict and this class masquerades as dict, we implement it.
'''
try:
value = self[key]
return value
except KeyError:
return default
def __getitem__(self, key):
value = self._st.find(key)
if value == None:
raise KeyError('Key Error: %s ' % repr(key))
return value
def __delitem__(self, key):
if key in self._st:
self._st.remove(key)
else:
raise KeyError('Key Error: %s ' % repr(key))
def __setitem__(self, key, obj):
if key in self._st:
self._st.replace(key, obj)
else:
self._st.insert(key, obj)
def __iter__(self):
for key, value in self._st.inorder_traversal_with_stack():
yield key
class Splay_Tree_Test_Postorder_Traversal_with_empty_Tree(unittest.TestCase):
def setUp(self):
self._splay_tree = SplayTree()
def test_postorder_traversal_with_empty_tree(self):
post_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=False,
want_in_order=False,
want_post_order=True):
post_order_elements.append(element)
self.assertEqual(
0, len(post_order_elements),
'Post order traversal on empty tree must yield no elements')
def tearDown(self):
self._splay_tree = None
class Splay_Tree_Test_Tree_With_1_Element(unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=10, obj=10)
def test_node_count_of_tree_with_1_node(self):
self.assertEqual(self._splaytree.node_count, 1,
'Tree node count must be 1')
def test_find_key_of_tree_with_1_node(self):
self.assertEqual(self._splaytree.find(10), 10,
'Find operation failed on tree with 1 node')
def test_delete_element_of_tree_with_1_node(self):
self._splaytree.remove(10)
self.assertEqual(self._splaytree.node_count, 0,
'Empty tree node count must be 0')
self.assertEqual(self._splaytree.find(20), None,
'Empty tree find operation must return None')
def tearDown(self):
self._splaytree = None
class Splay_Tree__Test_Inorder_Traversal_with_Stack_on_10_Node_Tree(
unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=5, obj=5)
self._splaytree.insert(key=8, obj=8)
self._splaytree.insert(key=7, obj=7)
self._splaytree.insert(key=9, obj=9)
self._splaytree.insert(key=10, obj=10)
self._splaytree.insert(key=2, obj=2)
self._splaytree.insert(key=1, obj=1)
self._splaytree.insert(key=3, obj=3)
self._splaytree.insert(key=4, obj=4)
self._splaytree.insert(key=6, obj=6)
def test_inorder_traversal_with_10_node_tree(self):
in_order_elements = []
for key, element in self._splaytree.inorder_traversal_with_stack():
in_order_elements.append(element)
self.assertEqual(
10, len(in_order_elements),
'In order traversal on 10 node tree must yield 10 elements')
self.assertEqual(
in_order_elements, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
'In order traversal did not yield expected elements in order')
def tearDown(self):
self._splaytree = None
def setUp(self):
self._splay_tree = SplayTree()
self._splay_tree.insert(key=10, obj=10)
class Splay_Tree_Test_All_Traversals_Consecutively_For_Tree_Integirty_With_10_Node_Tree(
unittest.TestCase):
def setUp(self):
self._splay_tree = SplayTree()
self._splay_tree.insert(key=5, obj=5)
self._splay_tree.insert(key=8, obj=8)
self._splay_tree.insert(key=7, obj=7)
self._splay_tree.insert(key=9, obj=9)
self._splay_tree.insert(key=10, obj=10)
self._splay_tree.insert(key=2, obj=2)
self._splay_tree.insert(key=1, obj=1)
self._splay_tree.insert(key=3, obj=3)
self._splay_tree.insert(key=4, obj=4)
self._splay_tree.insert(key=6, obj=6)
def test_traversal_consecutively_with_10_node_tree(self):
#inorder
in_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=False,
want_in_order=True,
want_post_order=False):
in_order_elements.append(element)
self.assertEqual(
10, len(in_order_elements),
'In order traversal on 10 node tree must yield 10 elements')
self.assertEqual(
in_order_elements, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
'In order traversal did not yield expected elements in order')
#postorder
post_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=False,
want_in_order=False,
want_post_order=True):
post_order_elements.append(element)
self.assertEqual(
10, len(post_order_elements),
'Post order traversal on 10 node tree must yield 10 elements')
self.assertEqual(
post_order_elements, [2, 1, 3, 5, 4, 9, 8, 7, 10, 6],
'Post order traversal did not yield expected elements in order')
pre_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=True,
want_in_order=False,
want_post_order=False):
pre_order_elements.append(element)
self.assertEqual(
10, len(pre_order_elements),
'Pre order traversal on 10 node tree must yield 10 elements')
self.assertEqual(
pre_order_elements, [6, 4, 3, 1, 2, 5, 10, 7, 8, 9],
'Pre order traversal did not yield expected elements in order')
def tearDown(self):
self._splay_tree = None
for key, value in tree.traversal(want_post_order=True):
traversed.append((key, value))
print('Tree postorder traversal (key, value) pairs:')
print(traversed)
def print_tree_inorder(tree):
traversed = []
for key, value in tree.traversal(want_in_order=True):
traversed.append((key, value))
print('Tree inorder traversal (key, value) pairs:')
print(traversed)
if __name__ == '__main__':
bst = SplayTree()
print('Node count is %s' % str(bst.node_count))
print('Adding key value pairs (1, 1), (2, 2), .... (6, 6)')
kvpairs = [(5, 5), (2, 2), (7, 7), (1, 1), (3, 3), (9, 9), (8, 8), (4, 4),
(6, 6)]
for kvpair in kvpairs:
bst.insert(key=kvpair[0], obj=kvpair[1])
print_tree_inorder(bst)
print_tree_preorder(bst)
print_tree_postorder(bst)
#remove
element_to_remove = 9
print('removing element %s' % str(element_to_remove))
class Splay_Tree_Test_Tree_Delete_Element_With_10_Elements(unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=5, obj=5)
self._splaytree.insert(key=8, obj=8)
self._splaytree.insert(key=7, obj=7)
self._splaytree.insert(key=9, obj=9)
self._splaytree.insert(key=10, obj=10)
self._splaytree.insert(key=2, obj=2)
self._splaytree.insert(key=1, obj=1)
self._splaytree.insert(key=3, obj=3)
self._splaytree.insert(key=4, obj=4)
self._splaytree.insert(key=6, obj=6)
self._splay_tree_node_count = 10
def test_delete_element_of_tree_non_existing_element(self):
self._splaytree.remove(11)
self.assertEqual(self._splaytree.node_count,
self._splay_tree_node_count,
'Tree node count must be 10')
def test_delete_element_of_tree_with_10_node(self):
elements_to_delete = [10, 1, 7, 3, 5, 8, 2, 6, 9]
for element in elements_to_delete:
self._splaytree.remove(element)
self.assertEqual(self._splaytree.find(element), None,
'Element found in BST after deleting it!')
self._splay_tree_node_count = self._splay_tree_node_count - 1
self.assertEqual(self._splaytree.node_count,
self._splay_tree_node_count,
'Tree node count must tally after deletion')
def tearDown(self):
self._splaytree = None
class Splay_Tree_Test_Tree_Count_Find_Element_With_10_Elements(
unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=5, obj=5)
self._splaytree.insert(key=8, obj=8)
self._splaytree.insert(key=7, obj=7)
self._splaytree.insert(key=9, obj=9)
self._splaytree.insert(key=10, obj=10)
self._splaytree.insert(key=2, obj=2)
self._splaytree.insert(key=1, obj=1)
self._splaytree.insert(key=3, obj=3)
self._splaytree.insert(key=4, obj=4)
self._splaytree.insert(key=6, obj=6)
self._splay_tree_node_count = 10
def test_node_count_of_tree_with_10_node(self):
self.assertEqual(self._splaytree.node_count,
self._splay_tree_node_count,
'Tree node count must be 10')
def test_find_element_of_tree_with_10_node(self):
for i in range(1, 11): # 1 to 10
tree_element = self._splaytree.find(i)
self.assertNotEqual(
tree_element, None,
'BST findElement did not return existing element')
self.assertEqual(tree_element, i,
'Find operation failed on tree with 1 node')
def tearDown(self):
self._splaytree = None
class Splay_Tree_Test_Tree_Structure_After_Find_With_Inorder_Traversal(
unittest.TestCase):
'''
The purpose of this test is to make sure that the splay op does not ruin the tree. So after each insert we check the
tree structure.
'''
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=5, obj=5)
self._splaytree.insert(key=8, obj=8)
self._splaytree.insert(key=7, obj=7)
self._splaytree.insert(key=9, obj=9)
self._splaytree.insert(key=10, obj=10)
self._splaytree.insert(key=2, obj=2)
self._splaytree.insert(key=1, obj=1)
self._splaytree.insert(key=3, obj=3)
self._splaytree.insert(key=4, obj=4)
self._splaytree.insert(key=6, obj=6)
def test_tree_structure_after_each_find_with_inorder_traversal(self):
expected_inorder_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
inorder_from_tree = []
for i in range(1, 11): # 1 to 10
self.assertEqual(self._splaytree.find(i), i,
'Element not found in Splay Tree!')
for key, element in self._splaytree.traversal(want_in_order=True):
inorder_from_tree.append(element)
self.assertEqual(inorder_from_tree, expected_inorder_list,
'Tree ruined during insert splays')
inorder_from_tree = []
def tearDown(self):
self._splaytree = None
class Splay_Tree_Test_Preorder_Traversal_with_10_Node_Tree(unittest.TestCase):
def setUp(self):
self._splay_tree = SplayTree()
self._splay_tree.insert(key=5, obj=5)
self._splay_tree.insert(key=8, obj=8)
self._splay_tree.insert(key=7, obj=7)
self._splay_tree.insert(key=9, obj=9)
self._splay_tree.insert(key=10, obj=10)
self._splay_tree.insert(key=2, obj=2)
self._splay_tree.insert(key=1, obj=1)
self._splay_tree.insert(key=3, obj=3)
self._splay_tree.insert(key=4, obj=4)
self._splay_tree.insert(key=6, obj=6)
def test_preorder_traversal_with_10_node_tree(self):
pre_order_elements = []
for key, element in self._splay_tree.traversal(want_pre_order=True,
want_in_order=False,
want_post_order=False):
pre_order_elements.append(element)
self.assertEqual(
10, len(pre_order_elements),
'Pre order traversal on 10 node tree must yield 10 elements')
self.assertEqual(
pre_order_elements, [6, 4, 3, 1, 2, 5, 10, 7, 8, 9],
'Pre order traversal did not yield expected elements in order')
def tearDown(self):
self._splay_tree = None
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=10, obj='Object value')
class Splay_Tree_Test_Has_Key_With_10_Elements(unittest.TestCase):
def setUp(self):
self._splaytree = SplayTree()
self._splaytree.insert(key=5, obj=5)
self._splaytree.insert(key=8, obj=8)
self._splaytree.insert(key=7, obj=7)
self._splaytree.insert(key=9, obj=9)
self._splaytree.insert(key=10, obj=10)
self._splaytree.insert(key=2, obj=2)
self._splaytree.insert(key=1, obj=1)
self._splaytree.insert(key=3, obj=3)
self._splaytree.insert(key=4, obj=4)
self._splaytree.insert(key=6, obj=6)
self._splay_tree_node_count = 10
def test_has_key_with_10_node(self):
for i in range(1, 11): # 1 to 10
self.assertEqual(
i in self._splaytree, True,
'has_key operation must return True for existing key.')
def tearDown(self):
self._splaytree = None
def setUp(self):
self._splay_tree = SplayTree()
def __init__(self):
self._st = SplayTree()
