def test_put(self):
tree = BinarySearchTree()
keys = random.sample(range(1000000), 10000)
for key in keys:
tree.put(key, "value{}".format(key))
for key in keys:
self.assertTrue(tree.get(key) == "value{}".format(key))
def delete(self, remove):
parent = None
if remove.parent != None:
parent = remove.parent
self.splay(remove)
BinarySearchTree.delete(self, remove)
if parent:
self.splay(parent)
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 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 setUp(self):
self.bst = BinarySearchTree()
self.bst.put('H', 5)
self.bst.put('B', 4)
self.bst.put('K', 9)
self.bst.put('C', 2)
self.bst.put('I', -1)
self.bst.put('M', 11)
def test_get(self):
tree = BinarySearchTree()
self.assertIsNone(tree.get(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for _ in range(100):
index = random.randint(0, len(keys) - 1)
self.assertEqual("value{}".format(keys[index]), tree.get("key{}".format(keys[index])))
for i in range(1001, 1100):
self.assertIsNone(tree.get("key{}".format(i)))
# tree is list
tree = BinarySearchTree()
for i in range(1000):
tree.put(i, i * 100)
for i in range(1000):
self.assertEqual(i * 100, tree.get(i))
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_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 print_binary_tree(input_structure):
clear_screen()
# asks which trait to sort tree by
print("What would you like the tree to be sorted by?\n")
print("1.ID\n"
"2.Name\n"
"3.Age\n"
"4.Personality Rating\n")
choice = input('Choice: ')
# checks to make sure the user entered a valid option
while not choice in ['1','2','3','4']:
print("You didn't enter a valid choice. Please try again.")
choice = input('Choice: ')
# creates BinarySearchTree and adds the chairs to the tree
my_tree = BinarySearchTree()
for chair in input_structure.chair_list():
my_tree.put(chair.person.data(['id','name','age','personality'][int(choice) - 1]), chair)
my_tree.print()
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_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_deleteLeafNode():
BST = BinarySearchTree()
BST.put(10, "ten")
BST.put(15, "fifteen")
BST.put(5, "five")
BST.put(3, "three")
BST.put(7, "seven")
BST.put(12, "twelve")
BST.put(17, "seventeen")
BST.delete(3)
assert BST.inOrder(BST.root) == \
"5 7 10 12 15 17"
BST.delete(17)
assert BST.inOrder(BST.root) == \
"5 7 10 12 15"
str1 = "".join(str(e) for e in order1)
str2 = "".join(str(e) for e in order2)
return str2 in str1
def preorder(node, order):
if node is None:
order.append("X")
return
order.append(node.value)
preorder(node.left, order)
preorder(node.right, order)
if __name__ == '__main__':
bst1 = BinarySearchTree(50)
bst1.insert(20)
bst1.insert(60)
bst1.insert(10)
bst1.insert(25)
bst1.insert(70)
bst1.insert(5)
bst1.insert(15)
bst1.insert(65)
bst1.insert(80)
root1 = bst1.get_root()
bst2 = BinarySearchTree(60)
bst2.insert(70)
bst2.insert(65)
bst2.insert(80)
# filename : TreeProblem.py
from BinarySearchTree import BinarySearchTree
from BinaryTree import BinaryTree
from util import Queue
import random
# ---------------------- problem : 1 ------------------------------------------
"""
* Given Sorted Array with unique integers make a Binary Serach Tree out of it with minimal Height.
"""
binaryTree = BinarySearchTree()
def minimal_height_binary_serach_tree_from_sorted_array(
arr, binaryTree, start, end):
# recursive approch.
if start > end:
return None
else:
mid = int((start + end) / 2)
print(f"mid : {mid} start : {start} end : {end}")
binaryTree.insertKey(arr[mid])
minimal_height_binary_serach_tree_from_sorted_array(
arr, binaryTree, start, mid - 1)
minimal_height_binary_serach_tree_from_sorted_array(
arr, binaryTree, mid + 1, end)
#--------------------------------------------------------------------------------------------------------------------
def max(self, x):
max_node = BinarySearchTree.max(self, x)
self.splay(max_node)
return max_node
def insert(self, key):
new_node = BinarySearchTree.insert(self, key)
self.splay(new_node)
return new_node
def testTreeInit(self): bst = BinarySearchTree() self.assertTrue(bst.insert(5))
def isSubtree(t1, t2):
queue = []
queue.append(t1)
while len(queue):
node = queue.pop(0)
if node.data == t2.data:
if isIdenticalTrees(node, t2):
return True
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return False
t1 = BinarySearchTree()
t1.insertRecursive(4)
t1.insertRecursive(2)
t1.insertRecursive(3)
t1.insertRecursive(1)
t1.insertRecursive(6)
t1.insertRecursive(5)
t1.insertRecursive(7)
t1.insertRecursive(8)
bst = BinarySearchTree()
bst.insertRecursive(6)
bst.insertRecursive(5)
bst.insertRecursive(7)
bst.insertRecursive(8)
def test_find_non_empty_tree(self):
BST = BinarySearchTree(51)
self.assertNotEqual(BST.find(51), None)
def test_find_empty_tree(self):
BST = BinarySearchTree()
self.assertEqual(BST.find(11), None)
def test_insert_from_nonempty_tree(self):
BST = BinarySearchTree(88)
self.assertEqual(BST.size(), 1)
def test_nonempty_tree(self):
BST = BinarySearchTree(28)
self.assertEqual(BST.size(), 1)
def test_nonempty_tree(self):
BST = BinarySearchTree(5)
self.assertEqual(BST.isEmpty(), False)
from BinarySearchTree import BinarySearchTree
tree = BinarySearchTree()
assert tree.is_empty() is True
tree.add(1)
assert tree.is_empty() is False
assert tree.size() == 1
tree.remove(1)
assert tree.height() == 0
tree.add('M')
assert tree.height() == 1
tree.add('J')
assert tree.height() == 2
tree.add('S')
assert tree.height() == 2
tree.add('B')
assert tree.height() == 3
tree.add('N')
assert tree.height() == 3
tree.add('Z')
assert tree.height() == 3
tree.add('A')
assert tree.height() == 4
tree.remove('M')
tree.remove('J')
tree.remove('S')
tree.remove('B')
tree.remove('N')
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();
class BinarySearchTreeTest(TestCase):
def setUp(self):
self.bst = BinarySearchTree()
self.bst.put('H', 5)
self.bst.put('B', 4)
self.bst.put('K', 9)
self.bst.put('C', 2)
self.bst.put('I', -1)
self.bst.put('M', 11)
def test_get(self):
self.assertEqual(self.bst.get('C'), 2)
self.assertEqual(self.bst.get('M'), 11)
self.assertEqual(self.bst.get('Z'), None)
def test_size(self):
self.assertEqual(self.bst.size(), 6)
def test_min(self):
self.assertEqual(self.bst.min(), 'B')
def test_max(self):
self.assertEqual(self.bst.max(), 'M')
def test_floor(self):
self.assertEqual(self.bst.floor('D'), 'C')
self.assertEqual(self.bst.floor('M'), 'M')
self.assertEqual(self.bst.floor('A'), None)
def test_select(self):
self.assertEqual(self.bst.select(0), 'B')
self.assertEqual(self.bst.select(1), 'C')
self.assertEqual(self.bst.select(5), 'M')
self.assertEqual(self.bst.select(6), None)
def test_rank(self):
self.assertEqual(self.bst.rank('B'), 0)
self.assertEqual(self.bst.rank('C'), 1)
self.assertEqual(self.bst.rank('D'), 2)
self.assertEqual(self.bst.rank('H'), 2)
self.assertEqual(self.bst.rank('M'), 5)
self.assertEqual(self.bst.rank('Z'), 6)
def test_delete_min(self):
self.bst.delete_min()
self.assertEqual(self.bst.size(), 5)
self.assertEqual(self.bst.min(), 'C')
def test_delete(self):
self.bst.delete('H')
self.assertEqual(self.bst.size(), 5)
self.assertEqual(self.bst.get('H'), None)
def test_keys(self):
keys = self.bst.keys('C', 'J')
self.assertEqual(keys, ['C', 'H', 'I'])
def test_toList_empty_tree(self):
BST = BinarySearchTree()
self.assertEqual(BST.toList(), [])
#!/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 test_empty_tree(self):
BST = BinarySearchTree()
self.assertEqual(BST.isEmpty(), True)
def testTreeFind(self): bst = BinarySearchTree() self.assertFalse(bst.find(5)) bst.insert(5) self.assertTrue(bst.find(5))
def test_toList_non_empty_tree(self):
BST = BinarySearchTree(72)
self.assertEqual(BST.toList(), [72])
def min(self, x):
min_node = BinarySearchTree.min(self, x)
self.splay(min_node)
return min_node
def test_toList_tree_with_children(self):
BST = BinarySearchTree(72)
BST.insert(10)
BST.insert(99)
self.assertEqual(BST.toList(), [10, 72, 99])
def succ(self, x):
succ_node = BinarySearchTree.succ(self, x)
self.splay(succ_node)
return succ_node
k_list = []
stack = []
while r or stack:
if r:
stack.append(r)
r = r.right
else:
r=stack.pop()
k_list.append(r)
if len(k_list) == k:
break
r = r.left
return k_list
if __name__=='__main__':
t=BinarySearchTree()
''' The tree is :
20
/ \
10 40
/ \ / \
3 17 35 73
/ \ / \ \
1 7 15 18 89
\ / /
2 5 11
/ \ \
4 6 12
'''
a=[20,10,40,3,17,35,73,1,7,15,18,89,2,5,11,4,6,12]
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))
# -*- 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 test_deleteNodeWithTwoChildren():
BST = BinarySearchTree()
BST.put(10, "ten")
BST.put(15, "fifteen")
BST.put(5, "five")
BST.put(3, "three")
BST.put(7, "seven")
BST.put(12, "twelve")
BST.put(17, "seventeen")
BST.delete(15)
assert BST.inOrder(BST.root) == \
"3 5 7 10 12 17"
BST.delete(5)
assert BST.inOrder(BST.root) == \
"3 7 10 12 17"
def test_delete(self):
tree = BinarySearchTree()
self.assertIsNone(tree.delete(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for key in keys:
v = tree.delete("key{}".format(key))
self.assertEqual("value{}".format(key), v)
tree = BinarySearchTree()
for i in range(512):
tree.put(i, i * 100)
for i in range(512):
self.assertEqual(i * 100, tree.delete(i))
tree = BinarySearchTree()
for i in range(128):
tree.put(i, i * 100)
for i in reversed(range(128)):
self.assertEqual(i * 100, tree.delete(i))
for j in range(i):
self.assertEqual(j * 100, tree.get(j))
self.assertIsNone(tree.delete(0))
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 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)
from BinarySearchTree import BinarySearchTree mytree = BinarySearchTree() mytree[3] = "red" mytree[4] = "blue" mytree[6] = "yellow" mytree[2] = "at" print(mytree[6]) print(mytree[2])
from TreeNode import TreeNode from BinarySearchTree import BinarySearchTree bst = BinarySearchTree() bst.put(10, 'A') bst.put(1, 'B') bst.put(11, 'C') bst[20] = 'D' print(bst.get(10)) print(bst[11]) print(bst.get(-1)) print(10 in bst)
def test_Size(self):
tree = BinarySearchTree()
self.assertEqual(tree.size(), 0)
tree.add("Hello World!")
self.assertEqual(tree.size(), 1)
def tree():
tree = BinarySearchTree()
tree.insert(5)
tree.insert(10)
tree.insert(1)
return tree
def _removeLeaf(self, path):
"""Last node of path is a leaf that should be removed."""
problem = len(path) >= 2 and path[-2].isBlack()
_BinarySearchTree._contractAbove(self,path) # path is updated automatically
while problem:
problem = False # typically, we fix it. We'll reset to True when necessary
if path[-1].isRed():
path[-1].setBlack() # problem solved
elif len(path) >= 2:
# bottom node is a "double-black" that must be remedied
if _DEBUG>1: print "double-black node must be resolved:",path[-1]
parent = path[-2]
sibling = parent.getOtherChild(path[-1])
if len(path) >= 3:
grandparent = path[-3]
else:
grandparent = None
if sibling.isRed():
# our parent is a 3-node that we prefer to realign
if _DEBUG>1: print "realigning red sibling"
sibling.setBlack(True)
parent.setBlack(False)
self._rotate(sibling,parent,grandparent)
path.insert(-2,sibling) # reflects the rotation of sibling above parent
grandparent = sibling
sibling = parent.getOtherChild(path[-1]) # will surely be black this time
# now sibling is black
nephewA,nephewB = _identifyNephews(sibling,parent) # closer,farther
if _DEBUG>1: print "nephews:",nephewA,"-",nephewB
if nephewA.isBlack() and nephewB.isBlack():
# we and sibling are 2-nodes. Recolor sibling to enact merge
if _DEBUG>1: print "sibling also 2-node; recoloring"
sibling.setBlack(False)
if parent.isRed():
parent.setBlack()
else:
if _DEBUG>1: print "will continue with",path[-1]
path.pop()
problem = True # must continue from parent level
else:
# should be able to maneuver to borrow from sibling
if not nephewA.isRed():
# rotate other nephew and sibling
if _DEBUG>1: print "realigning nephews"
self._rotate(nephewB,sibling,parent)
nephewB.setBlack(True)
sibling.setBlack(False)
sibling = nephewB
nephewA,nephewB = _identifyNephews(sibling,parent)
if _DEBUG>1: print "nephews:",nephewA,"-",nephewB
# at this point, nephewA is guaranteed to be red. Let's borrow from it
self._rotate(nephewA,sibling,parent)
self._rotate(nephewA,parent,grandparent)
nephewA.setBlack(parent.isBlack()) # they've been promoted
parent.setBlack()
# cross your fingers; should be done!
if _DEBUG>0 and self._validate() == -1:
print 'Error after deletion.'
#!/usr/bin/python
from BinarySearchTree import BinarySearchTree
bst = BinarySearchTree()
bst.put(10,'a')
bst.put(9,'b')
bst.put(2,'c')
bst.put(12,'d')
bst.put(14,'e')
bst.put(11,'e')
bst.put(16,'e')
bst[20] = 'f'
print bst.length()
print bst.get(12)
print bst.get(20)
bst.delete(12)
bst.delete(2)
print
for i in bst:
print i
def setUp(self):
self.binarySearchTree = BinarySearchTree()
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
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();
def test_get(self):
tree = BinarySearchTree()
self.assertIsNone(tree.get(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for _ in range(100):
index = random.randint(0, len(keys) - 1)
self.assertEqual("value{}".format(keys[index]),
tree.get("key{}".format(keys[index])))
for i in range(1001, 1100):
self.assertIsNone(tree.get("key{}".format(i)))
# tree is list
tree = BinarySearchTree()
for i in range(1000):
tree.put(i, i * 100)
for i in range(1000):
self.assertEqual(i * 100, tree.get(i))
