def main():
#create BST:
print('create BST with elements: 10, 5, 2, 6, 1, 4, 20, 15, 25')
bst = BST(10)
insert_in_BST = [5, 2, 6, 1, 4, 20, 15, 25]
for item in insert_in_BST:
bst.insert(item)
# test find() -> find root with key = 2 and print key:
print('find root with key=2 and print key:')
print(bst.find(2).key)
# find min/max:
print('find node with min key and print key (should be 1):')
print(bst.findMin().key)
print('find node with max key and print key (should be 25):')
print(bst.findMax().key)
# traverse tree / delete nodes:
print('traverse tree in order and print all keys:')
bst.traverseInOrder()
print('delete node with key=5 and traverse tree again:')
bst.delete(5)
bst.traverseInOrder()
# get root and print it's key:
print('get root key (should be 10)')
print(bst.getRoot().key)
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):
input_file = argv[1]
# Instance of the binary search tree
tree = BST()
with open(input_file, 'r') as file_ob:
for line in file_ob:
line = line.split()
if line[0] == 'insert':
tree.insert(int(line[1]))
if line[0] == 'delete':
tree.delete(int(line[1]))
if line[0] == 'preorder':
tree.traverse('preorder', tree.getRoot())
print("")
if line[0] == 'inorder':
tree.traverse('inorder', tree.getRoot())
print("")
if line[0] == 'postorder':
tree.traverse('postorder', tree.getRoot())
print("")
# Close the file
file_ob.close()
def test_BST():
bst = BST()
# Test empty tree
assert (len(bst.BFS()) == 0)
# Test insert
bst.insert(2)
bst.insert(3)
bst.insert(1)
assert (len(bst.BFS()) == 3)
expected = [2, 1, 3]
actual = [node.value for node, l in bst.BFS()]
assert_(expected, actual)
# Test search
assert (bst.search(2) is True)
assert (bst.search(5) is False)
# Test-1 Pre Order Traversal
bst.insert(0)
pre_order_expected = [2, 1, 0, 3]
pre_order_actual = bst.pre_order_traversal()
assert_(pre_order_expected, pre_order_actual)
# Test-2 In-Order Traversal
in_order_expected = [0, 1, 2, 3]
in_order_actual = bst.in_order_traversal()
assert_(in_order_expected, in_order_actual)
# Test-3 Post-Order Traversal
post_order_expected = [0, 1, 3, 2]
post_order_actual = bst.post_order_traversal()
assert_(post_order_expected, post_order_actual)
# Test-4 Delete
bst.delete(3)
delete_expected_output = [0, 1, 2]
delete_actual_output = bst.post_order_traversal()
assert_(delete_expected_output, delete_actual_output)
# Test-5 Delete
bst.insert(5)
bst.insert(4)
bst.insert(8)
bst.insert(6)
bst.insert(9)
delete_expected_output = [0, 1, 2, 4, 6, 8, 9]
bst.delete(5)
delete_actual_output = bst.in_order_traversal()
assert_(delete_expected_output, delete_actual_output)
def test_delete_w_one_child(self):
bin = BST()
bin.insert(5)
bin.insert(2)
bin.insert(18)
bin.insert(-4)
bin.insert(3)
bin.insert(21)
bin.insert(19)
bin.insert(25)
bin.delete(bin.root.right)
self.assertEqual([x.val for x in bin.get_level(1)], [2, 21])
def test_delete_w_two_children(self):
bin = BST()
bin.insert(5)
bin.insert(2)
bin.insert(12)
bin.insert(-4)
bin.insert(3)
bin.insert(9)
bin.insert(21)
bin.insert(19)
bin.insert(25)
bin.delete(bin.root.right)
self.assertEqual([x.val for x in bin.get_level(1)], [2, 19])
self.assertEqual([x.val for x in bin.get_level(3)], [25])
def test_delete_w_no_children(self):
bin = BST()
bin.insert(7)
bin.insert(3)
bin.insert(8)
bin.insert(1)
bin.insert(5)
bin.insert(2)
bin.insert(4)
bin.insert(6)
bin.insert(10)
bin.insert(9)
bin.insert(20)
bin.delete(bin.root.right.right.right)
self.assertEqual([x.val for x in bin.get_level(3)], [2, 4, 6, 9])
def main(argv):
tree = BST(
) # Creating the instance of a binary search tree, and going to be
# referring to it as tree.
input_file = argv[
1] # This will be the input file with the tree instructions
# passed in as an argument when the program is compiled.
with open(input_file, 'r') as file_object:
# Looping over the input file (file is passed in as argv[1])
for line in file_object:
# splitting each line into a task and a number, so this would mean that
# the task will be refered to as line[0] and then the actual number
# is going to be referred to as line[1] after the split.
line = line.rstrip('\n')
line = line.split()
if line[0] == "insert":
# calling the insert function.
tree.insert((line[1]))
if line[0] == "inorder":
# for the tree traversals, these will only call the traverse function
# which will then decide which traversal to execute.
tree.traverse(line[0], tree.getRoot())
print "\n",
if line[0] == "preorder":
tree.traverse(line[0], tree.getRoot())
print "\n",
if line[0] == "postorder":
tree.traverse(line[0], tree.getRoot())
print "\n",
if line[0] == "delete":
tree.delete(line[1])
file_object.close() # closing the input file after we finish reading it.
def main(argv):
# Loop over input file (filename passed via argv).
# Split each line into a task and number (if one exists)
# hint: use the split method for strings https://docs.python.org/2/library/string.html#string.split
# Perform the function corresponding to the specified task
# i.e., insert, delete, inorder, preorder, postorder
# Close the file when you're done.
filename = argv[1]
file = open(filename, "r")
bst = BST()
for line in file:
line = line.strip('\n')
task = line.split(" ")
# If task is insert
if (task[0] == "insert"):
val = int(task[1])
bst.insert(val)
# If task is delete
elif (task[0] == "delete"):
val = int(task[1])
bst.delete(val)
# If task is inorder
elif (task[0] == "inorder"):
bst.traverse(task[0], bst.getRoot())
# If task is preorder
elif (task[0] == "preorder"):
bst.traverse(task[0], bst.getRoot())
# If task is postorder
elif (task[0] == "postorder"):
bst.traverse(task[0], bst.getRoot())
# Close file
file.close()
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 main(argv):
# Loop over input file (filename passed via argv).
# Split each line into a task and number (if one exists)
# hint: use the split method for strings https://docs.python.org/2/library/string.html#string.split
# Perform the function corresponding to the specified task
# i.e., insert, delete, inorder, preorder, postorder
# Close the file when you're done.
file = argv[1]
tasklist = []
tree = BST()
with open(file, 'r') as file_ob:
for line in file_ob:
tasks = line.strip() #strips whitespace
calls = tasks.split(
" ") #separates commands (some require 2 arguments)
tasklist.append(calls)
for task in tasklist:
#these types of commands are the traversals inorder, preorder, postorder
if task[0] == "inorder":
tree.traverse("inorder", tree.getRoot())
print("") # just to make my output a little more readable
elif task[0] == "preorder":
tree.traverse("preorder", tree.getRoot())
print("") # just to make my output a little more readable
elif task[0] == "postorder":
tree.traverse("postorder", tree.getRoot())
print("") # just to make my output a little more readable
elif len(task) == 2:
command = task[0] #here are the insert/delete commands
value = int(task[1])
if command == "insert":
tree.insert(value)
elif command == "delete":
tree.delete(value)
else:
print("this is not an appropriate BST method")
def delete(self, z):
if (z.p != self.nil):
parent = z.p
BST.delete(self, z)
splay(parent)
BST.delete(self, z)
def BSTFullTest():
"""
Various tests for the BST class, including insertion, deletion, inorder walks, etc.
For BST class testing.
"""
print "\nTesting BST: random tests"
for i in range(20):
tree = BST()
passed = BSTRandomTest(tree, 1000)
if passed:
print "Passed random test", i + 1
print "\nTesting BST: various operations"
tree = BST()
for i in range(20):
v = random.randint(-99, 99)
tree.insert(Node(v))
print "Height =", tree.height()
print "Minimum =", tree.minimum()
print "Maximum =", tree.maximum()
print "In-order Walk =", tree.inorderWalk()
print "Random tree ="
print tree
arr = [21, 45, 1, 34, 8, -1, 99, -54, 60, 2]
tree = BSTFromArray(arr)
print("Test tree:")
print(tree)
print("Root:")
print(tree._r)
print("In order walk:")
print(tree.inorderWalk())
print("Min, max:")
print(str(tree.minimum()), str(tree.maximum()))
print("Height = ", tree.height())
print("Successor of 34:")
n = tree.search(34)
s = tree.successor(n)
print(s)
print("Successor of 100:")
n = tree.search(100)
s = tree.successor(n)
print(s)
print("Predecessor of 34:")
n = tree.search(34)
s = tree.predecessor(n)
print(s)
print("Predecessor of -54:")
n = tree.search(-54)
s = tree.predecessor(n)
print(s)
print("Find and delete 34:")
n = tree.search(34)
print(n)
tree.delete(n)
print(tree.inorderWalk())
print("Find and delete 21:")
n = tree.search(21)
s = tree.successor(n)
print(n)
print(s)
tree.delete(n)
print(tree.inorderWalk())
print(tree._r)
print(tree._r.right)
print(tree._r.right.parent)
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'
print 'deleted ', bst.delete(5), '\n'
bst.printinorder()
print bst.getsize(),'\n'
print 'deleted ', bst.delete(9), '\n'
bst.printinorder()
print bst.getsize(),'\n'
print 'deleted ', bst.delete(7), '\n'
bst.printinorder()
print bst.getsize(),'\n'
print 'deleted ', bst.delete(10), '\n'
bst.printinorder()
print bst.getsize(),'\n'
def main():
#start Binary Search Tree
bst = BST()
timeforInsertBST = time.time()
print(
"First insecd crt 50000 random nodes into an empty tree and print the tree."
)
for i in range(50000):
n = random.randint(0, 1000000)
bst.insert(BSTNode(n, bst.nil, bst.nil, bst.nil))
print("time for BST to insert", time.time() - timeforInsertBST)
timeforSearchBST = time.time()
print("\nNow do 10000 searches. ")
count = 0
for i in range(10000):
n = random.randint(0, 1000000)
if bst.search(n) == bst.nil:
count = count + 1
print("time for BST to search =", time.time() - timeforSearchBST)
##print time.time()-start1, "time for BST search"
print(count)
timeForDeleteBST = time.time()
print("\nNow search for & delete some nodes.")
for i in range(1000):
n = random.randint(0, 1000000)
z = bst.search(n)
if z != bst.nil:
bst.delete(z)
print("time for BST delete =", time.time() - timeForDeleteBST)
##start splay tree
splayTree = SplayTree()
timeforInsertSplay = time.time()
print(
"\nFirst insert 50000 random nodes into an empty tree and print the tree."
)
n = random.randint(0, 1000)
for i in range(50000):
n = n + 1
splayTree.insert(
BSTNode(n, splayTree.nil, splayTree.nil, splayTree.nil))
print("time for splay to insert =", time.time() - timeforInsertSplay)
timeForSearchSplay = time.time()
print("\nNow do 10000 searches. ")
count2 = 0
n = random.randint(0, 1000)
for i in range(10000):
n = n + 1
if splayTree.search(n) == splayTree.nil:
count2 = count2 + 1
print("time for splay to search =", time.time() - timeForSearchSplay)
print(count2)
timeForDeleteSplay = time.time()
print("\nNow search for & delete some nodes.")
n = random.randint(0, 1000)
for i in range(1000):
n = n + 1
z = splayTree.search(n)
if z != splayTree.nil:
splayTree.delete(z)
print("time for splay delete =", time.time() - timeForDeleteSplay)
