def test_delete(): bs_tree = BinarySearchTree() keys = [5, 2, -4, 3, 12, 9 ,21, 19, 25] for key in keys: node = Node() node.key = key bs_tree.insert(node) # delete leaf bs_tree.delete(bs_tree.search(-4)) assert(bs_tree.search(-4) is None) assert(bs_tree.search(2).left is None) # delete node with one child bs_tree.delete(bs_tree.search(2)) assert(bs_tree.search(2) is None) assert(bs_tree.root.left.key == 3) # delete node with two children bs_tree.delete(bs_tree.search(12)) assert(bs_tree.root.right.key == 19) assert(bs_tree.search(19).left.key == 9) assert(bs_tree.search(19).right.key == 21) # delete root bs_tree.delete(bs_tree.root) assert(bs_tree.root.key == 9) assert(bs_tree.root.left.key == 3) assert(bs_tree.root.right.key == 19)
def test_insert_whenInsertingLowerValue_insertsAsLeftChild(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(5, bst.root)
self.assertEqual(len(bst), 2)
self.assertEqual(bst.root.left.value, 5)
def test_root_remove(self):
tree = BinarySearchTree()
tree.insert(10)
self.assertTrue(tree.remove(10))
self.assertFalse(tree.search(10))
tree.insert(10)
tree.insert(20)
self.assertTrue(tree.remove(10))
self.assertFalse(tree.search(10))
self.assertTrue(tree.search(20))
self.assertTrue(tree.remove(20))
tree.insert(10)
tree.insert(20)
tree.insert(5)
tree.insert(25)
tree.insert(11)
self.assertTrue(tree.remove(10))
self.assertEqual(tree.root.value, 11)
self.assertTrue(tree.search(5))
self.assertTrue(tree.search(20))
self.assertTrue(tree.search(25))
self.assertFalse(tree.search(10))
class TestBinaryTree(unittest.TestCase):
def setUp(self):
self.binarySearchTree = BinarySearchTree()
def test_0(self):
print("{} Can create binary search tree object".format(inspect.stack()[0][3]))
self.assertTrue(type(self.binarySearchTree) is BinarySearchTree)
def test_1(self):
print("{} Newly created tree, root value should be None".format(inspect.stack()[0][3]))
self.assertEqual(self.binarySearchTree.root.value, None)
def test_2(self):
print("{} Insert value in new tree, root.value is inserted value".format(inspect.stack()[0][3]))
self.binarySearchTree.insert(5)
self.assertEqual(self.binarySearchTree.root.value, 5)
def test_3(self):
print("{} Insert value, search returns true for value inserted".format(inspect.stack()[0][3]))
self.binarySearchTree.insert(5)
self.assertTrue(self.binarySearchTree.search(5))
def test_4(self):
print("{} Insert value, search returns false for value not inserted".format(inspect.stack()[0][3]))
self.binarySearchTree.insert(5)
self.assertFalse(self.binarySearchTree.search(6))
def test_5(self):
print("{} Insert two values, search returns true for both values".format(inspect.stack()[0][3]))
self.binarySearchTree.insert(5)
self.binarySearchTree.insert(6)
self.assertTrue(self.binarySearchTree.search(5))
self.assertTrue(self.binarySearchTree.search(6))
def test_6(self):
print("{} Fill BST, see if is BST".format(inspect.stack()[0][3]))
for x in range(0, 50):
self.binarySearchTree.insert(random.randint(0,50))
self.assertTrue(self.isBST(self.binarySearchTree.root))
# Returns true if the given tree is a binary search tree
# Test courtesy of http://www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/
def isBST(self, node):
return (self.isBSTUtil(node, INT_MIN, INT_MAX))
# Returns true if the given tree is a BST and its values
# >= min and <= max
def isBSTUtil(self, node, mini, maxi):
# An empty tree is BST
if node.value is None:
return True
# False if this node violates min/max constraint
if node.value < mini or node.value > maxi:
return False
# Otherwise check the subtrees recursively
# tightening the min or max constraint
return (self.isBSTUtil(node.left, mini, node.value -1) and
self.isBSTUtil(node.right, node.value+1, maxi))
def test_delete_one_child(self):
tree = BinarySearchTree(10)
tree.insert(20)
tree.insert(17)
tree.insert(11)
tree.insert(19)
tree.deleteNode(tree, 19)
self.assertEqual(tree.toList(), [10,20, 17, 11])
def test_find_leaf(self):
keys = {1, 2, 3}
binary_search_tree = BinarySearchTree()
for key in keys:
binary_search_tree.insert(key, key)
result = binary_search_tree.find_leaf(binary_search_tree.root)
self.assert_node_has_no_children(result)
def test_delete_two_childs(self):
tree = BinarySearchTree(10)
tree.insert(20, 0, 100, 50, 30, 17)
print("\ntest tree")
tree.printHierarchy()
print("\nDepth")
print(tree.getDepth())
tree.deleteNode(tree,20)
print("\nremoved node with data == 20")
tree.printHierarchy()
def test_maximum(): bs_tree = BinarySearchTree() assert(bs_tree.minimum(bs_tree.root) is None) keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.maximum(bs_tree.root).key == 8) subtree = bs_tree.search(5) assert(bs_tree.maximum(subtree).key == 5)
def test_search(): bs_tree = BinarySearchTree() assert(bs_tree.search(2) is None) keys = [6, 5, 7, 2] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.search(6).key == 6) assert(bs_tree.search(7).key == 7) assert(bs_tree.search(8) is None)
def test_insert(): bs_tree = BinarySearchTree() keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.search(6).key == 6) assert(bs_tree.search(5).key == 5) assert(bs_tree.search(7).key == 7) assert(bs_tree.search(8).key == 8)
def test_add_right_child(self):
key1 = 1
key2 = 2
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value1)
binary_search_tree.insert(key2, value2)
self.assert_node_has_one_right_child(binary_search_tree.root)
def test_add_one_number(self):
key = "Apeldoorn"
value = 1
variable = self.create_node(key, value)
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key, value)
self.assert_root_has_correct_key_and_value(binary_search_tree.root,
variable)
self.assert_node_has_no_children(binary_search_tree.root)
def test_predecessor(): bs_tree = BinarySearchTree() keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.predecessor(bs_tree.root).key == 5) subtree = bs_tree.search(7) assert(bs_tree.predecessor(subtree).key == 6) subtree = bs_tree.search(2) assert(bs_tree.predecessor(subtree) is None)
def test_add_left_child(self):
key1 = 2
key2 = 1
key3 = 0
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value2)
binary_search_tree.insert(key2, value1)
binary_search_tree.insert(key3, value1)
self.assert_node_has_one_left_child(binary_search_tree.root)
self.assert_node_has_one_left_child(binary_search_tree.root.left)
def test_find_min(self):
key1 = 2
key2 = 1
key3 = 0
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value2)
binary_search_tree.insert(key2, value1)
binary_search_tree.insert(key3, value1)
lowest_key = key3
result = binary_search_tree.find_min()
self.assert_lowest_found(lowest_key, result)
def test_find(self):
key1 = 2
key2 = 1
key3 = 0
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value2)
binary_search_tree.insert(key2, value1)
binary_search_tree.insert(key3, value1)
result = binary_search_tree.find(key1)
self.assert_found(key1, result)
def benchmarking():
eBookEntry.__hash__ = monkey_hash
# eBookEntry.set_sort_type(eBookEntry.Sort.AUTHOR)
eBookEntry.set_sort_type(eBookEntry.Sort.ID)
my_books = eBookEntryReader("catalog-short4.txt")
my_hash_table = HashQP()
bst = BinarySearchTree()
avl = AVLTree()
random_ids = random.choices([book.ID for book in my_books], k=10000)
qp_res = []
avl_res = []
bst_res = []
for book in my_books:
my_hash_table.insert(book)
bst.insert(book)
avl.insert(book)
qp_time1 = time.time()
for i in random_ids:
# print(my_hash_table.find(i))
book = my_hash_table.find(i)
qp_res.append(book)
qp_time2 = time.time()
print('QP time: ', qp_time2 - qp_time1)
avl_time1 = time.time()
for i in random_ids:
# print(avl.find(i))
book = avl.find(i)
avl_res.append(book)
avl_time2 = time.time()
print('AVL time: ', avl_time2 - avl_time1)
bst_time1 = time.time()
for i in random_ids:
# print(bst.find(i))
book = bst.find(i)
bst_res.append(book)
# check if all items are same
bst_time2 = time.time()
print('BST time: ', bst_time2 - bst_time1)
# test to see if all the finds were the same
print(bst_res == avl_res)
print(bst_res == qp_res)
def test_create_niveau(self):
content = [["Plaats", "School", "Niveau", "Leerling", "Score", "Label"],
["Apeldoorn", "HAN", "HBO", "563631", "15", "test1"],
["Arnhem", "HAN", "HBO", "563631", "15", "test1"]]
niveau = Level()
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(content[1][0], 0)
binary_search_tree.insert(content[2][0], 1)
expected_niveau = "Plaats"
niveau.create_level(content, content[0][0])
self.assertEqual(expected_niveau, niveau.name)
self.assertEqual(binary_search_tree.find('Apeldoorn').key, niveau.variables.find('Apeldoorn').key)
self.assertEqual(binary_search_tree.find('Arnhem').key, niveau.variables.find('Arnhem').key)
def test_findMax(self):
key1 = 2
key2 = 1
key3 = 0
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value2)
binary_search_tree.insert(key2, value1)
binary_search_tree.insert(key3, value1)
highest_key = key1
result = binary_search_tree.find_max()
self.assertHighestFound(highest_key, result)
def minimal_tree(tree, array):
"""
Time: O(n)
Space: O(n)
where n is the size of the array
"""
if len(array) < 1:
return
mid = len(array) / 2
if tree is None:
tree = BinarySearchTree(array[mid])
else:
tree.insert(array[mid])
minimal_tree(tree, array[:mid])
minimal_tree(tree, array[mid + 1:])
return tree
def insert(self, key):
node = TreapNode()
new_node = BinarySearchTree.insert(self, key, node)
# tee: heap järjestyksen tarkistaminen ja muuttaminen
while (new_node != self.root and
new_node.priority < new_node.parent.priority):
self.rotate(new_node)
def insert(self, key):
node = TreapNode()
new_node = BinarySearchTree.insert(self, key, node)
# tee: heap järjestyksen tarkistaminen ja muuttaminen
while (new_node != self.root
and new_node.priority < new_node.parent.priority):
self.rotate(new_node)
def test_findParent_whenLookingAtLevel1_returnsRoot(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
self.assertEqual(bst.findParent(9, bst.root).value, 10)
def test_findParent_whenLookingAtRoot_returnsNone(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
self.assertIsNone(bst.findParent(10, bst.root))
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.my_bst = BinarySearchTree()
self.tree_values = [25, 50, 12, 35, 5, 60, 17, 1]
for value in self.tree_values:
self.my_bst.insert(value)
def test_exceptions(self):
self.assertRaises(AttributeError, self.my_bst.insert, 50)
self.assertRaises(AttributeError, self.my_bst.insert, 12)
self.assertRaises(AttributeError, self.my_bst.insert, 35)
self.assertRaises(AttributeError, self.my_bst.insert, 1)
def test_tree_operations(self):
self.assertEquals(self.my_bst.find(13), False)
self.assertEquals(self.my_bst.find(27), False)
for val in self.tree_values:
self.assertTrue(self.my_bst.find(val))
self.assertIsNone(self.my_bst.delete(12))
def test_findParent_whenLookingAtLevel2_returnsRightParentFromLevel1(self):
bst = BinarySearchTree()
bst.insert(19, bst.root)
bst.insert(15, bst.root)
bst.insert(21, bst.root)
bst.insert(11, bst.root)
bst.insert(18, bst.root)
self.assertEqual(bst.findParent(18, bst.root).value, 15)
def test_search_whenElemNotPresent_returnsFalse(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
#bst.inorderPrint(bst.root)
self.assertFalse(bst.search(99, bst.root))
def test_search_whenElemPresent_returnsTrue(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
#bst.inorderPrint(bst.root)
res = bst.search(15, bst.root)
self.assertTrue(res)
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.my_bst = BinarySearchTree()
self.tree_values = [25, 50, 12, 35, 5, 60, 17, 1]
for value in self.tree_values:
self.my_bst.insert(value)
def test_exceptions(self):
self.assertRaises(AttributeError, self.my_bst.insert, 50)
self.assertRaises(AttributeError, self.my_bst.insert, 12)
self.assertRaises(AttributeError, self.my_bst.insert, 35)
self.assertRaises(AttributeError, self.my_bst.insert, 1)
def test_tree_operations(self):
self.assertEquals(self.my_bst.find(13), False)
self.assertEquals(self.my_bst.find(27), False)
for val in self.tree_values:
self.assertTrue(self.my_bst.find(val))
self.assertIsNone(self.my_bst.delete(12))
class SymbolTable:
def __init__(self):
self.__binarySearchTree = BinarySearchTree()
def insert(self, value):
return self.__binarySearchTree.insert(value)
def find(self, value):
return self.__binarySearchTree.find(value)
def __str__(self):
s = 'Symbol Table:\n'
for i in range(len(self.__binarySearchTree.nodes)):
if self.__binarySearchTree.nodes[i] is not None:
s += str(i + 1) + ' ' + self.__binarySearchTree.nodes[i] + '\n'
return s
def test_insert_whenInsertingHigherValue_insertsAsRightChild(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
bst.insert(17, bst.root)
#bst.inorderPrint(bst.root)
self.assertEqual(len(bst), 4)
self.assertEqual(bst.root.value, 10)
self.assertEqual(bst.root.left.value, 9)
self.assertEqual(bst.root.right.value, 15)
self.assertEqual(bst.root.right.right.value, 17)
from BinarySearchTree import BinarySearchTree
newBST = BinarySearchTree()
newBST.insert(12)
newBST.insert(32)
newBST.insert(42)
newBST.insert(90)
newBST.insert(1)
newBST.insert(-2)
print("=====")
newBST.traverseInOrder()
print("=====")
newBST.remove(42)
newBST.traverseInOrder()
print("=====")
print(newBST.getMax())
print("=====")
print(newBST.getMin())
print("=====")
newBST.remove(12)
from BinarySearchTree import BinarySearchTree; bst = BinarySearchTree(); bst.insert(10); bst.insert(-5); bst.insert(3); bst.insert(345); bst.insert(678); bst.traverseInOrder(); bst.remove(678); bst.traverseInOrder();
# recurse to right for max node
node = findKthMaxRecursive(root.rightChild, k)
if (counter is not k) and (root.val is not current_max):
# Increment counter if kth element is not found
counter += 1
current_max = root.val
node = root
elif current_max is None:
# Increment counter if kth element is not found
# and there is no current_max set
counter += 1
current_max = root.val
node = root
# Base condition reached as kth largest is found
if (counter == k):
return node # return kth node
else:
# Traverse left child if kth element is not reached
# traverse left tree for kth node
return findKthMaxRecursive(root.leftChild, k)
BST = BinarySearchTree(6)
BST.insert(4)
BST.insert(9)
BST.insert(5)
BST.insert(2)
BST.insert(8)
print(findKthMax(BST.root, 4))
def insert(self, key):
new_node = BinarySearchTree.insert(self, key)
self.splay(new_node)
return new_node
from BinarySearchTree import BinarySearchTree
from Node import Node
binarySearchTree = BinarySearchTree()
binarySearchTree.insert(binarySearchTree.getRoot(), Node(50))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(30))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(20))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(40))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(70))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(60))
binarySearchTree.insert(binarySearchTree.getRoot(), Node(80))
# Tree Height
print("Height : ", binarySearchTree.getTreeHeight(binarySearchTree.getRoot()))
# Inorder Traversal
print("Inorder Traversal")
binarySearchTree.inorder(binarySearchTree.getRoot())
# Level Order Traversal
print("Level Order Traversal")
treeHeight = binarySearchTree.getTreeHeight(binarySearchTree.getRoot())
for i in range(1, treeHeight + 1):
binarySearchTree.levelOrder(binarySearchTree.getRoot(), i)
# Level Order Zig-Zag
print("Level Order Traversal Zig-Zag")
leftToRight = True
for i in range(1, treeHeight + 1):
binarySearchTree.levelOrderZigZag(binarySearchTree.getRoot(), i,
def check_balanced_recur(node, count, min_max):
# pre order traversal
if node is None:
return
if node.left is None and node.right is None:
if count < min_max[0]:
min_max[0] = count
if count > min_max[1]:
min_max[1] = count
check_balanced_recur(node.left, count + 1, min_max)
check_balanced_recur(node.right, count + 1, min_max)
if __name__ == '__main__':
bst1 = BinarySearchTree(27)
bst1.insert(9)
bst1.insert(3)
bst1.insert(1)
bst1.insert(53)
root1 = bst1.get_root()
print check_balanced(root1) # false
bst2 = BinarySearchTree(27)
bst2.insert(9)
bst2.insert(3)
bst2.insert(1)
bst2.insert(53)
bst2.insert(30)
root2 = bst2.get_root()
print check_balanced(root2) # True
def testTreeFind(self): bst = BinarySearchTree() self.assertFalse(bst.find(5)) bst.insert(5) self.assertTrue(bst.find(5))
from BinarySearchTree import BinarySearchTree tree = BinarySearchTree() tree.insert(32) tree.insert(55) tree.insert(79) tree.insert(10) tree.insert(1) tree.insert(0) tree.insert(19) tree.insert(16) tree.insert(23) #tree.inOrderTraversal(); tree.inOrderTraversalWithStack();
from BinarySearchTree import BinarySearchTree bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(8) bst.insert(1) bst.insert(4) bst.insert(2) bst.insert(7) bst.insert(6) bst.insert(9) bst.insert(10) print "------preOrder----------" bst.preOrder(bst.root) print "------inOrder----------" bst.inOrder(bst.root) print "------postOrder----------" bst.postOrder(bst.root) print "----------------" print bst.depth
# -*- coding: utf-8 -*- """ App: """ from BinarySearchTree import BinarySearchTree as BST bst = BST() bst.insert(12) bst.insert(10) bst.insert(-2) bst.insert(1) bst.traverseInOrder() bst.remove(10) bst.traverseInOrder() print bst.getMin() print bst.getMax()
def insert(self, key):
new_node = BinarySearchTree.insert(self, key)
self.splay(new_node)
return new_node
temp.extend(left)
temp.extend(right)
weaved.append(temp)
return
# both left and right are not empty
# recurse with head of the first list added to the prefix.
# remove the head will damage the first, so we'll need to put it back where we found it afterwards
head = left.pop(0)
prefix.append(head)
weave_lists(left, right, weaved, prefix)
prefix.pop()
left.insert(0, head)
# do same thing with second, damaging then restoring the list
head = right.pop(0)
prefix.append(head)
weave_lists(left, right, weaved, prefix)
prefix.pop()
right.insert(0, head)
if __name__ == '__main__':
bst = BinarySearchTree(2)
bst.insert(1)
bst.insert(3)
root = bst.get_root()
print bst_sequences(root)
# weaved = []
# weave_lists([1,2], [3,4], weaved, [])
# print weaved
#!/usr/bin/env python from BinarySearchTree import BinarySearchTree my_tree = BinarySearchTree() n = [25, 50, 12, 5, 35] for i in n: my_tree.insert(i) c = my_tree._root c = c.next while c != None: print(c) c = c._left_child
def main():
#open the list of names file and read the student info then put it into a list
inputfile = str(input("Please enter a list of names file "))
inputfilehandle = open(inputfile, 'r')
inputfileread = inputfilehandle.readlines()
# BST = BinarySearchTree()
BST = BinarySearchTree()
#loops through and adds Student record to BinarySearchTree
#create a start time for the creater
starttime = time.time()
#find out how many records your inserting into
insertrecordcounter = 0
for line in inputfileread:
ssline = line.strip(" ").split('\t')
#changes the variable to an int
sname = int(ssline[0])
BST.insert(Student(sname))
insertrecordcounter += 1
inputfilehandle.close()
endtime = time.time()
print(BST)
#create a start time for the creater
# asks for a second file, and reads it
inputfile2 = str(input("Please enter a list of names file "))
sfilehandle = open(inputfile2, 'r')
Idsearch = sfilehandle.readlines()
#create a start time for the creater
starttime2 = time.time()
findrecordcounter = 0
# search for an ID match in the search file and BinarySearchTree
for ID in range(len(Idsearch)):
findrecordcounter += 1
num = Idsearch[ID]
# change it to an integar
IDcomparison = int(num)
studentID = Student(IDcomparison)
#finds the cross-over
IDchecker = BST.find(studentID)
#checks to see if the ID was found or not and prints it
if IDchecker is not None:
print("Found student record " + str(IDchecker))
else:
print("Student ID " + str(IDcomparison) + " not found")
#create a start time for the creater
sfilehandle.close()
endtime2 = time.time()
print("Time to insert " + str(insertrecordcounter) +
" records into an AVL Tree: " + format(endtime - starttime, "6.4f") +
" seconds")
print("Time to find " + str(findrecordcounter) +
" records into an AVL Tree: " +
format(endtime2 - starttime2, "6.4f") + " seconds")
def testTreeInit(self): bst = BinarySearchTree() self.assertTrue(bst.insert(5))
