def testDelete(self):
# Test the no left sub child case
tree = BinarySearchTree([1, 2])
tree.delete(tree.root)
self.assertEquals(tree.root.key, 2)
self.assertEquals(tree.root.leftChild, None)
self.assertEquals(tree.root.rightChild, None)
# Test the no right sub child case
tree = BinarySearchTree([2, 1])
tree.delete(tree.root)
self.assertEquals(tree.root.key, 1)
self.assertEquals(tree.root.leftChild, None)
self.assertEquals(tree.root.rightChild, None)
# Test the right sub tree successor is right child case
tree = BinarySearchTree([1, 0, 2])
tree.delete(tree.root)
self.assertEquals(tree.root.key, 2)
self.assertEquals(tree.root.leftChild.key, 0)
self.assertEquals(tree.root.rightChild, None)
# Test the right sub tree successor is not right child case
tree = BinarySearchTree([0, -1, 3, 1])
tree.delete(tree.root)
self.assertEquals(tree.root.key, 1)
self.assertEquals(tree.root.leftChild.key, -1)
self.assertEquals(tree.root.rightChild.key, 3)
def setUp(self):
# The testing tree should look like this:
# 30s
# / \
# / \
# / \
# 10 43
# / \ / \
# 21 34 45
# / \ / \ / \
# 15 40 46
#
# All nodes should have a count == 1
# except for 46 with count == 4
self.empty_tree = bst.BinarySearchTree()
self.tree = bst.BinarySearchTree()
self.tree.insert(30)
self.tree.insert(43)
self.tree.insert(10)
self.tree.insert(34)
self.tree.insert(21)
self.tree.insert(40)
self.tree.insert(15)
self.tree.insert(45)
self.tree.insert(44)
self.tree.insert(46)
self.tree.insert(46)
self.tree.insert(46)
self.tree.insert(46)
def test_post_order_traversal(self):
data = ['S', 'E', 'X', 'A', 'R', 'C', 'H', 'M']
tree = BinarySearchTree(TreeNode(data[0]))
[tree.insert(TreeNode(i)) for i in data[1:]]
expected = ['C', 'A', 'M', 'H', 'R', 'E', 'X', 'S']
self.assertEqual(tree.postOrderTraverse(), expected)
self.assertEqual(tree.postOrderTraverseInLoop(), expected)
data = ['H', 'C', 'S', 'A', 'E', 'R', 'X']
expected = ['A', 'E', 'C', 'R', 'X', 'S', 'H']
tree = BinarySearchTree(TreeNode(data[0]))
[tree.insert(TreeNode(i)) for i in data[1:]]
self.assertEqual(tree.postOrderTraverse(), expected)
self.assertEqual(tree.postOrderTraverseInLoop(), expected)
def make_binary_tree(numbers=None):
if not numbers:
numbers = [5, 2, 7, 1, 3, 6, 8, 0, 9, 4]
tree = BinarySearchTree.BinarySearchTree()
for i in numbers:
tree.insert(i)
return tree
def __init__(self):
self.bookCatalog = ArrayList.ArrayList()
self.shoppingCart = ArrayQueue.ArrayQueue()
self.indexKey = ChainedHashTable.ChainedHashTable()
self.indexSortedPrefix = BinarySearchTree.BinarySearchTree()
self.bookSortedCatalog = ArrayList.ArrayList()
self.similaGraph = AdjacencyList.AdjacencyList(0)
def create_chain_bst(n):
curr = 1
mytree = BinarySearchTree()
while curr <= n: #For q1, h = n
mytree.insert(curr) #insert runtine is O(h)
curr += 1
return mytree
def test_get_length_of_a_binary_tree(self):
tree = BinarySearchTree(TreeNode(0))
self.assertEqual(len(tree), 1)
tree.insert(TreeNode(1))
tree.insert(TreeNode(2))
tree.insert(TreeNode(3))
self.assertEqual(len(tree), 4)
def menu_bt():
bt = BinarySearchTree.BinarySearchTree()
blist = ArrayList.ArrayList()
option = ""
while option != '0':
print("""
1 Add to Binary Tree
2 Remove from Binary Tree
3 Display values using BF traversal
4 Display values using in-order
5 Display values using pre-order
6 Display values using post-order
7 Print height of tree
0 Return to main menu
""")
option = input()
if option == "1":
bt.add(input("Enter the string index: "),input("Enter the value: "))
elif option == "2":
bt.remove(input("Enter index to be removed: "))
elif option == "3":
print(bt.bf_traverse())
elif option == "4":
print( bt.in_order(bt.r, []) )
elif option == "5":
print( bt.pre_order(bt.r, []) )
elif option == "6":
print( bt.post_order(bt.r, []) )
elif option == "7":
print(bt.height())
def testInsert(self):
tree = BinarySearchTree([])
tree.insert(0)
tree.insert(-5)
tree.insert(-2)
tree.insert(5)
tree.insert(10)
self.assertEquals(tree.root.parent, None)
self.assertEquals(tree.root.key, 0)
leftChild = tree.root.leftChild
self.assertEquals(leftChild.parent, tree.root)
self.assertEquals(leftChild.key, -5)
leftRightChild = leftChild.rightChild
self.assertEquals(leftRightChild.parent, leftChild)
self.assertEquals(leftRightChild.key, -2)
rightChild = tree.root.rightChild
self.assertEquals(rightChild.parent, tree.root)
self.assertEquals(rightChild.key, 5)
rightRightChild = rightChild.rightChild
self.assertEquals(rightRightChild.parent, rightChild)
self.assertEquals(rightRightChild.key, 10)
def test_remove_root_from_single_node_tree(self):
remove_test_tree = bst.BinarySearchTree()
remove_test_tree.insert(40)
remove_test_tree.remove(40)
root = remove_test_tree.get_root()
self.assertIsNone(root);
self.assertEqual(remove_test_tree.size(), 0)
def test_remove_node_not_in_tree(self):
remove_test_tree = bst.BinarySearchTree();
remove_test_tree.insert(20)
remove_test_tree.insert(46)
remove_test_tree.insert(16)
remove_test_tree.remove(17)
self.assertEqual(remove_test_tree.size(), 3)
def test_remove_node_with_no_children(self):
remove_test_tree = bst.BinarySearchTree();
remove_test_tree.insert(20)
remove_test_tree.insert(46)
remove_test_tree.insert(16)
remove_test_tree.remove(16)
self.assertEqual(remove_test_tree.size(), 2)
self.assertIsNone(remove_test_tree.find(16))
def test_rotate_roots_left_child_to_right(self):
self.bst = BinarySearchTree.BinarySearchTree()
self.bst.insert(2)
self.bst.insert(1)
node1 = self.bst.get_node(1)
node2 = self.bst.get_node(2)
self.bst.rotate(node1)
self.assertTrue(self.bst.root == node1 and node1.right == node2)
def test_prev_order_traversal(self):
data = ['S', 'E', 'X', 'A', 'R', 'C', 'H', 'M']
tree = BinarySearchTree(TreeNode(data[0]))
[tree.insert(TreeNode(i)) for i in data[1:]]
# map returns a iterator in Python3 instead of a list in Python2.
# for i in a:
# print(i)
expected = ['S', 'E', 'A', 'C', 'R', 'H', 'M', 'X']
self.assertEqual(tree.prevOrderTraverse(), expected)
self.assertEqual(tree.prevOrderTraverseInLoop(), expected)
data = ['H', 'C', 'S', 'A', 'E', 'R', 'X']
expected = ['H', 'C', 'A', 'E', 'S', 'R', 'X']
tree = BinarySearchTree(TreeNode(data[0]))
[tree.insert(TreeNode(i)) for i in data[1:]]
self.assertEqual(tree.prevOrderTraverse(), expected)
self.assertEqual(tree.prevOrderTraverseInLoop(), expected)
def test_remove_duplicate_node_in_tree(self):
remove_test_tree = bst.BinarySearchTree()
remove_test_tree.insert(40)
remove_test_tree.insert(46)
remove_test_tree.insert(46)
remove_test_tree.remove(46)
self.assertEqual(remove_test_tree.find(46).count, 1)
self.assertEqual(remove_test_tree.size(), 2)
def test_remove_node_with_right_child(self):
remove_test_tree = bst.BinarySearchTree();
remove_test_tree.insert(20)
remove_test_tree.insert(46)
remove_test_tree.insert(16)
remove_test_tree.insert(17)
remove_test_tree.remove(16)
self.assertEqual(remove_test_tree.size(), 3)
self.assertIsNone(remove_test_tree.find(16))
self.assertEqual(remove_test_tree.find(20).left.value, 17)
def setUp(self):
self.binaryTree = BinarySearchTree()
self.binaryTree.addValue(8)
self.binaryTree.addValue(3)
self.binaryTree.addValue(10)
self.binaryTree.addValue(6)
self.binaryTree.addValue(1)
self.binaryTree.addValue(4)
self.binaryTree.addValue(14)
self.binaryTree.addValue(7)
self.binaryTree.addValue(13)
def test_rotate_node_with_only_left_child(self):
self.bst = BinarySearchTree.BinarySearchTree()
for i in range(3, -1, -1):
self.bst.insert(i)
nodes = [self.bst.get_node(x) for x in range(4)]
self.bst.rotate(nodes[1])
self.assertTrue(nodes[3].left == nodes[1]
and nodes[1].parent == nodes[3]
and nodes[1].left == nodes[0]
and nodes[0].parent == nodes[1]
and nodes[1].right == nodes[2]
and nodes[2].parent == nodes[1])
def testSearch(self):
tree = BinarySearchTree([0, -5, -2, 5, 10])
self.assertEquals(tree.search(99), None)
node = tree.search(-2)
self.assertEquals(node.parent.key, -5)
self.assertEquals(node.leftChild, None)
self.assertEquals(node.rightChild, None)
node = tree.search(10)
self.assertEquals(node.parent.key, 5)
self.assertEquals(node.leftChild, None)
self.assertEquals(node.rightChild, None)
def test_correct_size (self):
print ("\nCorrect size test ---------------\n")
list = BinarySearchTree()
self.assertEqual(list.size(), 0)
list.insert(3, 'c')
list.insert(1, 'a')
list.insert(2, 'b')
list.insert(4, 'd')
list.insert(5, 'e')
print(list)
list.print()
self.assertEqual(list.size(), 5)
print ("\nEnd correct size test -------------")
def create_complete_bst(n):
def add_items(bst, low, high):
#recursive
if low >= (
high + 1
) // 2: ##insert n number of nodes, and each time you insert, it takes h = log(n)
bst.insert(low) ##time because it is a complete bst
else:
bst = add_items(bst, low * 2, high)
now = low
times = ((high + 1) // 2) // low
for i in range(times):
bst.insert(now)
now += low * 2
return bst
bst = BinarySearchTree()
add_items(bst, 1, n)
return bst
def test_BinarySearchTree(self):
"""
Testing insert, look_up, remove and traverse functions
:return: None
"""
# insert function
a = BinarySearchTree(9)
a.insert(4)
self.assertEqual(4, a.root.left.value)
a.insert(6)
self.assertEqual(6, a.root.left.right.value)
a.insert(20)
self.assertEqual(20, a.root.right.value)
a.insert(617)
self.assertEqual(617, a.root.right.right.value)
a.insert(15)
self.assertEqual(15, a.root.right.left.value)
a.insert(1)
self.assertEqual(1, a.root.left.left.value)
# lookup
self.assertEqual('20 is in leaf 1', a.look_up(20))
# remove
a.remove(1)
self.assertEqual(None, a.root.left.left)
a.insert(1)
a.remove(15)
self.assertEqual(None, a.root.right.left)
a.insert(15)
a.remove(617)
self.assertEqual(None, a.root.right.right)
a.insert(617)
a.remove(20)
self.assertEqual(617, a.root.right.value)
a.remove(6)
self.assertEqual(617, a.root.right.value)
def test_binarytree(self):
points = 0.5
q = BinarySearchTree.BinarySearchTree()
try:
self.assertIsNone(q.find(2))
self.assertAlmostEqual(q.remove(2), False)
except:
pass
finally:
points += 0.5
try:
q.add(3, "third")
q.add(2, "second")
q.add(1, "first")
self.assertAlmostEqual(q.size(), 3)
self.assertAlmostEqual(q.find(2.5), "third")
q.remove(3)
self.assertIsNone(q.find(3))
self.assertAlmostEqual(q.size(), 2)
q.add(3, "third")
q.add(5, "fifth")
q.add(4, "fourth")
self.assertAlmostEqual(q.size(), 5)
self.assertAlmostEqual(q.find(3.4), "fourth")
print("In order")
q.in_order()
print("Pre oder")
q.pre_order()
print("Pos order")
q.pos_order()
print("BF Traversal")
q.bf_traverse()
self.assertAlmostEqual(q.height(), 4)
points += 1
except:
print("BinarySearchTreeTest is not correct")
finally:
print(f"BinarySearchTreeTest: {points} Points")
def main():
inputFile = 'Test0.txt'
outputFile = 'Test0_output.txt'
tree = BinaryTree.BinaryTree(inputFile)
bst = BinarySearchTree.BinarySearchTree()
# Binary Tree tests
with open(outputFile, 'w') as f:
f.write(' '.join(
str(x) for x in tree.inOrderTraversal(tree.getRoot())))
f.write('\n')
tree.clearTraversalResult()
f.write(' '.join(
str(x) for x in tree.preOrderTraversal(tree.getRoot())))
f.write('\n')
tree.clearTraversalResult()
f.write(' '.join(
str(x) for x in tree.postOrderTraversal(tree.getRoot())))
f.write('\n')
tree.clearTraversalResult()
print(tree.isBST(tree.getRoot()))
# Binary Search Tree tests
root = bst.getRoot()
root.addKey(random.randint(1, 1000000))
for x in random.sample(range(2, 10000000), 1000000):
bst.addNode(root, x)
print(bst.isBST(bst.getRoot()))
sys.exit()
closest = current_node.data
if value < current_node.data:
return findclosestvalueinbsthelper(current_node.left, value, closest)
else:
return findclosestvalueinbsthelper(current_node.right, value, closest)
return closest
def findclosestvalueinbst(tree: BinarySearchTree, value: int) -> int:
return findclosestvalueinbsthelper(tree.head, value,
abs(tree.head.data - value))
if __name__ == "__main__":
tree = BinarySearchTree(10)
tree.insert(5)
tree.insert(15)
tree.insert(2)
tree.insert(5)
tree.insert(13)
tree.insert(22)
tree.insert(1)
tree.insert(14)
value = 12
print(findclosestvalueinbst(tree, value))
def bst_main():
T = create_list_consecutive_numbers(10000)
array = get_input("2sumtest1.txt")
bst = BST.BinarySearchTree(array)
print(sum2_bst(bst, T, array))
import BinarySearchTree import Node import Test4BST root = Node.Node(10, 4) G = BinarySearchTree.BinarySearchTree(root) N1 = Node.Node(12, 1) #N2 = Node.Node(13,2) #N3 = Node.Node(6,5) #N4 = Node.Node(4,3) G.put(N1, root) #G.put(N2,root) #G.put(N3,root) #G.put(N4,root) G.get(6, root) test = Test4BST.testBST(G, root) print test.check(root)
def initialize_from_parameters(self, k, l):
self.k = k
self.l = l
self.n = k + l
self.bases = BST.BinarySearchTree()
def testInOrderWalk(self):
tree = BinarySearchTree([5, 1, 3, 9, -1, -2])
self.assertEquals(tree.inOrderWalk(), [-2, -1, 1, 3, 5, 9])
def recover_bst_in_order(r):
global prev, first, second
if r:
recover_bst_in_order(r.left)
if not prev:
prev = r
else:
if r.data < prev.data:
if not first:
first = prev
# if first is second's direct prior in in-order traversal, second is r
# otherwise second will be overwritten later
second = r
prev = r
recover_bst_in_order(r.right)
def recover_bst(r):
recover_bst_in_order(r)
print first, second
first.data, second.data = second.data, first.data
return r
if __name__ == '__main__':
t = BinarySearchTree()
data = [1, 2, 6, 4, 5, 3, 7, 8]
t.create_tree(data)
recover_bst(t.root)
t.in_order_print(t.root)
