def main():
# Read each test case
bst = BST()
for ele in [2, 7, 4, 8, 5]:
bst.add(ele)
print(bst.count_in_range(3, 5))
class TestBST(TestCase):
def setUp(self):
self.list1 = [3, 2, 1, 5, 6, 7]
# Creating the BST1
self.BST1 = BST(dtype=int, key=4)
for val in self.list1:
self.BST1 = self.BST1.insert(val)
def test_insert(self):
self.assertEqual(self.BST1.key, 4)
self.assertEqual(self.BST1.left.key, 3)
self.assertEqual(self.BST1.right.key, 5)
self.BST1 = self.BST1.insert(9)
self.assertEqual(self.BST1.right.right.right.right.key, 9)
def test_preOrderTraversal(self):
preOrderValues = [4, 3, 2, 1, 5, 6, 7]
self.assertEqual(self.BST1.PreOT(),
', '.join(str(i) for i in preOrderValues))
def test_inOrderTraversal(self):
inOrderValues = [1, 2, 3, 4, 5, 6, 7]
self.assertEqual(self.BST1.IOT(),
', '.join([str(i) for i in inOrderValues]))
def test_postOrderTraversal(self):
postOrderValues = [1, 2, 3, 7, 6, 5, 4]
self.assertEqual(self.BST1.PostOT(),
', '.join([str(i) for i in postOrderValues]))
def tearDown(self):
del self.list1
def runBST(arr):
start = millis()
bst = BST()
bst.insertList(arr)
print("BST to list: \n" + str(bst.toList()))
end = millis()
print("time spent: " + str(round(end - start, 4)) + " ms\n")
class TranversalBST(object):
def __init__(self):
self.bst = BST(None)
self.nodes = []
def insert(self, value):
if not self.bst.value:
self.bst.value = value
else:
self.bst.insert(value)
def contains(self, value):
return bool(self.bst.find(value))
def get(self, index):
for i, value in enumerate(self.inorder()):
if i == index:
return value
def inorder(self):
current = self.bst
self.nodes = []
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
stack.append(current)
current = current.left
else:
current = stack.pop()
self.nodes.append(current.value)
current = current.right
return self.nodes
def preorder(self):
self.nodes = []
stack = [self.bst]
while len(stack) > 0:
curr = stack.pop()
if curr is not None:
self.nodes.append(curr.value)
stack.append(curr.right)
stack.append(curr.left)
return self.nodes
def preorder2(self):
self.nodes = []
current = self.bst
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
self.nodes.append(current.value)
stack.append(current)
current = current.left
else:
current = stack.pop()
current = current.right
return self.nodes
def setUp(self):
self.list1 = [3, 2, 1, 5, 6, 7]
# Creating the BST1
self.BST1 = BST(dtype=int, key=4)
for val in self.list1:
self.BST1 = self.BST1.insert(val)
def populate(length):
out = []
bst = BST()
for i in range(0, length):
n = random.randint(0, length)
out.append(n)
bst.append(n)
return (out, bst)
def testHeightV2(self):
node_2 = Node(2, None, None)
node_7 = Node(7, None, None)
node_4 = Node(4, node_2, node_7)
node_6 = Node(6, None, None)
node_5 = Node(5, node_4, node_6)
bst = BST(node_5)
self.assertEquals(2, bst.get_height(node_5))
def test_inorder_traversal(self):
bst = BST()
listi = [x for x in range(50)]
random.shuffle(listi)
for j in listi:
bst.insert(j)
inorderTreeWalk(bst.root)
self.assertEqual(len(listi), bst.size)
def testRemoveLeafNode2(self):
node_1 = Node(1, None, None)
node_2 = Node(2, node_1, None)
node_3 = Node(4, node_2, None)
node_4 = Node(6, None, None)
node_5 = Node(5, node_3, node_4)
bst = BST(node_5)
bst.removeNode(None, node_5, 1)
self.assertEquals(node_2.left, None)
def testRemoveNodeHasOneChildren(self):
node_1 = Node(1, None, None)
node_2 = Node(2, node_1, None)
node_3 = Node(4, node_2, None)
node_4 = Node(6, None, None)
node_5 = Node(5, node_3, node_4)
bst = BST(node_5)
bst.removeNode(None, node_5, 2)
self.assertEquals(node_3.left.data, 1)
class SymbolTable:
def __init__(self):
self.tree = BST()
def add(self, symbol):
return self.tree.insert(symbol)
def print(self):
return self.tree.print()
def test_get():
root = Node('b', 5)
root.left = Node('a', 3)
root.right = Node('c', 2)
bst = BST(root)
assert bst.get('a') == 3
assert bst.get('c') == 2
assert bst.get('d') is None
def test_Search_Iter(self):
bst = BST()
listi = [x for x in range(50)]
random.shuffle(listi)
for j in listi:
bst.insert(j)
node = treeSearch(bst.root, 32)
self.assertIsNotNone(node)
self.assertEqual(32, node.value)
def __init__(self, tree_type, directory_entered):
self.tree_type = tree_type
self.files_list = list()
self.stopwordsBST = BST()
self.stopwordsTST = TST()
self.stopwordsTrie = TrieST()
self.stopwordsSCHashST = SCHashST()
self.words_tree = TST()
self.stopwords_init()
self._build(directory_entered)
def BSTFromArray(arr):
"""
Creates a BST from the keys in a given array.
type arr: List[]
rtype: BST
"""
tree = BST()
for k in arr:
tree.insert(Node(k))
return tree
def testDelete():
t = BST()
t.put(2)
t.put(1)
t.put(3)
t.delete(1)
assert not t.contains(1)
def main(argv):
#create a new tree
tree = BST()
#open file argument
file = open(argv[1], "r")
# goes for amount of of lines in f
for line in file:
text = line.split()
#test cases for what the first element in the list is
if text[0] == "insert":
#saves the second element, since it exists
data = text[1]
tree.insert(data)
elif text[0] == "delete":
#saves element, then calls delete
data = text[1]
tree.delete(data)
elif text[0] == "preorder" or text[0] == "postorder" or text[0] == "inorder":
#tests for if a traverse then calls the function
tree.traverse(text[0], tree.getRoot())
else:
print("incorrect format")
return 0
def main(argv):
myBST = BST()
# Loop over input file (filename passed via argv).
input_file = argv[1]
with open(input_file, 'r') as file_ob:
# Split each line into a task and number (if one exists)
#hint: use the split method for strings
# Perform the function corresponding to the specified task
# i.e., insert, delete, inorder, preorder, postorder
# Close the file when you're done.
for line in file_ob:
if ' ' in line:
command, num = line.split()
if command == "insert":
myBST.insert(num)
if command == "delete":
myBST.deleteBook(num)
#print command
#print num
else:
line = line.split()
myBST.traverse(line[0], myBST.getRoot())
print ''
if 'str' in line:
break
pass
def test_rank():
bst = BST()
bst.put('a', 1)
bst.put('b', 1)
bst.put('c', 1)
bst.put('d', 1)
bst.put('e', 1)
assert bst.rank('c') == 2
assert bst.rank('b') == 1
assert bst.rank('d') == 3
assert bst.rank('e') == 4
def testRemoveNodeHasTwoChildrenLeftSubTree(self):
node_1 = Node(1, None, None)
node_6 = Node(3, None, None)
node_2 = Node(2, node_1, node_6)
node_3 = Node(4, node_2, None)
node_4 = Node(6, None, None)
node_5 = Node(5, node_3, node_4)
bst = BST(node_5)
bst.removeNode(None, node_5, 2)
self.assertEquals(node_3.left.data, 3)
self.assertEqual(node_3.left.left.data, 1)
def test_Search(self):
bst = BST()
listi = [x for x in range(50)]
random.shuffle(listi)
for j in listi:
bst.insert(j)
searchValue = 40
inorderTreeWalk(bst.root)
node = treeSearch(bst.root, searchValue)
self.assertIsNotNone(node)
self.assertEqual(searchValue, node.value)
def heightrandom():
for i in range(2, 10, 2):
L = [100 * random() for x in range((2**i) - 1)]
BSTTree = BST()
TreapTree = Treap()
for x in L:
BSTTree.insert(x)
TreapTree.insert(x)
print("Complete Tree would have height of", i - 1)
print("Height of BST is: ", BSTTree.height())
print("Height of Treap is: ", TreapTree.height())
def test_range_count():
bst = BST()
bst.put('a', 1)
bst.put('b', 1)
bst.put('c', 1)
bst.put('d', 1)
bst.put('e', 1)
assert bst.range_count('b', 'e') == 4
def test_MinMax_Recursive(self):
bst = BST()
listi = [x for x in range(50)]
random.shuffle(listi)
for j in listi:
bst.insert(j)
node = treeMinRecursive(bst.root)
node2 = treeMaxRecursive(bst.root)
self.assertIsNotNone(node)
self.assertEqual(0, node.value)
self.assertIsNotNone(node2)
self.assertEqual(49, node2.value)
def test_range_search():
bst = BST()
bst.put('a', 1)
bst.put('b', 1)
bst.put('c', 1)
bst.put('d', 1)
bst.put('e', 1)
assert bst.range_search('b', 'd') == ['b', 'c', 'd']
def main():
tree = BST([16, 9, 18, 3, 14, 19, 1, 5])
assert (find_ancestors(tree, 5)) == [3, 9, 16]
assert (find_ancestors(tree, 14)) == [9, 16]
assert (find_ancestors(tree, 16)) == []
assert (find_ancestors(tree, 18)) == [16]
assert (find_ancestors(tree, 19)) == [18, 16]
assert (find_ancestors(tree, 20)) == []
assert (find_ancestors(tree, '.')) == []
tree2 = BST(['F', 'D', 'I', 'B', 'E', 'L', 'A'])
assert (find_ancestors(tree2, 'B')) == ['D', 'F']
assert (find_ancestors(tree2, 3)) == []
class SymbolTable:
def __init__(self):
self.bst = BST()
self.pos = 0
def add(self, identifier):
param = [self.pos, str(identifier)]
self.bst.insert(param)
self.pos = self.pos + 1
def search(self, identifier):
return self.bst.search(str(identifier))
def print(self):
self.bst.print()
def test_rb_tree():
bst = BST()
bst.put('a', 1)
bst.put('b', 1)
bst.put('c', 1)
bst.put('d', 1)
bst.put('e', 1)
assert bst.root.key == 'd'
assert bst.root.left.key == 'b'
a = bst.inorder()
assert a == ['a', 'b', 'c', 'd', 'e']
def handle_BST(self):
print "How many nodes would you like to include in the binary search tree?"
num_nodes = raw_input(">")
print "Please enter the root node"
root_node_data = raw_input(">")
root_node = Node(data=root_node_data,
left=None,
right=None,
is_root=True)
bst = BST(root_node)
for i in range(int(num_nodes) - 1):
print "Please enter node val"
val = raw_input(">")
bst.insert(bst.root, val)
print "Your final binary search tree is, in the form [Current, Left Node, Right Node]\n", bst.printAllNodes(
)
class ST:
def __init__(self):
self.tree = BST()
def add(self, symbol):
id = self.tree.insert(self.tree.root, symbol)
return id
def print(self):
self.tree.printBST()
#
# st = ST()
# st.add("x")
# st.print()
def demo():
B = Node(50)
tree = BST()
tree.insert(tree.root, Node(50))
tree.insert(tree.root, Node(48))
tree.insert(tree.root, Node(52))
tree.print_BST(tree.root)
def __init__(self, master):
self.silentremove("tree.png")
self.silentremove("tree")
self.tree = BST()
self.display = None
self.img = tkinter.Label(master)
self.btn_add = tkinter.Button(master, text="add")
self.btn_del = tkinter.Button(master, text="del")
self.entry_node = tkinter.Entry(master)
self.btn_add.bind("<Button-1>", self.add_element)
self.btn_del.bind("<Button-1>", self.del_element)
self.btn_add.pack(side="bottom")
self.btn_del.pack(side="bottom")
self.entry_node.pack(side="bottom")
self.img.pack(fill="both")
class Window(object):
def silentremove(self, filename):
try:
os.remove(filename)
except OSError as e: # this would be "except OSError, e:" before Python 2.6
if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory
raise
def __init__(self, master):
self.silentremove("tree.png")
self.silentremove("tree")
self.tree = BST()
self.display = None
self.img = tkinter.Label(master)
self.btn_add = tkinter.Button(master, text="add")
self.btn_del = tkinter.Button(master, text="del")
self.entry_node = tkinter.Entry(master)
self.btn_add.bind("<Button-1>", self.add_element)
self.btn_del.bind("<Button-1>", self.del_element)
self.btn_add.pack(side="bottom")
self.btn_del.pack(side="bottom")
self.entry_node.pack(side="bottom")
self.img.pack(fill="both")
def del_element(self, event):
self.tree.delete(int(self.entry_node.get()))
self.tree.draw().render("tree")
self.display = ImageTk.PhotoImage(image=Image.open("tree.png"))
self.img.pack_forget()
self.img = tkinter.Label(image=self.display)
self.img.pack()
def add_element(self, event):
self.tree.insert(int(self.entry_node.get()))
self.tree.draw().render("tree")
self.display = ImageTk.PhotoImage(image=Image.open("tree.png"))
self.img.pack_forget()
self.img = tkinter.Label(image=self.display)
self.img.pack()
def delete(self, z):
if (z.p != self.nil):
parent = z.p
BST.delete(self, z)
splay(parent)
BST.delete(self, z)
def insert_without_splay(self, z):
BST.insert(self, z)
def insert(self, z):
BST.insert(self, z)
self.splay(z)
def search(self, k):
x = BST.search(self, k)
self.splay(x)
return x
from BST import BST
bst = BST(7, 'ok')
bst.insert(3, 'dooke')
bst.insert(10, 'poke')
bst.insert(5, 'poop')
bst.insert(1, 'dope')
bst.insert(8, 'lol')
bst.insert(9, 'haagu')
bst.insert(12,'paadu')
bst.printinorder()
print '\n'
'''try:
print bst.getvalue(12)
print bst.getvalue(9)
print bst.getvalue(8)
print bst.getvalue(1)
print bst.getvalue(5)
print bst.getvalue(10)
print bst.getvalue(3)
print bst.getvalue(7)
print bst.getvalue(14)
except RuntimeError as e:
print e'''
key = 19
if key in bst:
print "I am in bst"
else:
print 'No i am not'
class TranversalBST(object):
def __init__(self):
self.bst = BST(None)
self.nodes = []
def insert(self, value):
if not self.bst.value:
self.bst.value = value
else:
self.bst.insert(value)
def contains(self, value):
return bool(self.bst.find(value))
def get(self, index):
for i, value in enumerate(self.inorder()):
if i == index:
return value
def inorder(self):
current = self.bst
self.nodes = []
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
stack.append(current)
current = current.left
else:
current = stack.pop()
self.nodes.append(current.value)
current = current.right
return self.nodes
def preorder(self):
self.nodes = []
stack = [self.bst]
while len(stack) > 0:
curr = stack.pop()
if curr is not None:
self.nodes.append(curr.value)
stack.append(curr.right)
stack.append(curr.left)
return self.nodes
def preorder2(self):
self.nodes = []
current = self.bst
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
self.nodes.append(current.value)
stack.append(current)
current = current.left
else:
current = stack.pop()
current = current.right
return self.nodes
def preorder3(self):
self.nodes = []
node = self.bst
if not node: return None
stack = []
stack.append(node)
while stack:
node = stack.pop()
self.nodes.append(node.value)
if node.right: stack.append(node.right) # RIGHT FIRST!
if node.left: stack.append(node.left)
return self.nodes
def BFT(self):
self.nodes = []
node = self.bst
if not node: return None
queue = deque()
queue.append(node)
while queue:
node = queue.popleft()
self.nodes.append(node.value)
if node.left: queue.append(node.left) # LEFT FIRST!
if node.right: queue.append(node.right)
return self.nodes
def __init__(self):
self.bst = BST(None)
self.nodes = []
__author__ = 'Hazem Safwat'
from BST import BST
import random
from tabulate import tabulate
table = [[]]
for i in range(51): #creating 50 different trees
size = random.randint(50,100)
items = random.sample(range(1,12000) , size) #random items in tree has a size = size
tree = BST(items[0]) #Root of the tree
for j in range(1,size): #inserting items in the tree
tree.insert(items[j])
counter = BST.stepCounter(tree)
table.append([i , size , counter , 2*counter])
print(tabulate(table[1:51] , headers= ["no." , "number of items" ,"number of calls" ,"number of steps" ]))
#!/usr/env/bin python3
# File that uses BST
from BST import BST
bst = BST(25)
bst.insert(12)
bst.insert(50)
bst.insert(6)
bst.insert(45)
bst.insert(1)
print("Does tree contain 1 {0}".format(bst.contains(1)))
print("Does tree contain 5 {0}".format(bst.contains(5)))
print("Does tree contain 12 {0}".format(bst.contains(12)))
print("Does tree contain 51 {0}".format(bst.contains(51)))
class Test:
__a=0
def __init__(self):
self.b=0
self.__a=self.__a+1
#Test.__a=Test.__a+1
def get_a(self):
return self.__a
test1=Test()
test2=Test()
print 'test1'
print 'a:%d'%(test1.get_a())
test1.a=10
print 'test2'
print 'a:%d'%(test1.a)
from BST import BST
import random
bst=BST()
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.insert(int(random.random()*100))
bst.mid_travel()
