def test_find_missing_Value(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
self.assertEqual(bst.find(401), None)
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.bst = None
def _initialize(self):
self._cleanup()
self.bst = BinarySearchTree()
lst = [5, 8, 2, 1, 3, 9, 7, 4, 6, 0]
for i in lst:
self.bst.insert(i)
def _cleanup(self):
if self.bst:
del(self.bst)
self.bst = None
def test_insert(self):
self._initialize()
self.assertEqual(len(self.bst), 10)
def test_delete(self):
self._initialize()
self.bst.delete(5)
self.assertEqual(len(self.bst), 9)
def test_iteration(self):
self._initialize()
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in self.bst.root:
self.assertTrue(i == lst[i])
def tearDown(self):
self._cleanup()
def test_find_nontrivial_tree(self):
bst = BinarySearchTree()
data = [20, 50, 1, 150, 42]
for d in data:
bst.insert(d)
data.sort()
self.assertEqual(bst.toList(), data)
def test_find_nontrivial_tree(self):
bst = BinarySearchTree()
data = [20, 50, 1, 150, 42]
for d in data:
bst.insert(d)
for d in data:
self.assertEqual(bst.find(d).getData(), d)
class TreeTraversal(object):
def __init__(self, elements=None):
if not elements or not len(elements) > 1:
raise ValueError('Please provide data to traverse.')
self.tree = BinarySearchTree(BST_Node(elements.pop(0)))
print(self.tree.head)
for element in elements:
self.tree.insert(element)
# Left - Root - Right
def inorder(self, node=None):
if node:
self.inorder(node.get_next('left'))
print(node.data)
self.inorder(node.get_next('right'))
# Root - Left - Right
def preorder(self, node=None):
if node:
print(node.data)
self.inorder(node.get_next('left'))
self.inorder(node.get_next('right'))
# Left - Right - Root
def postorder(self, node=None):
if node:
self.inorder(node.get_next('left'))
self.inorder(node.get_next('right'))
print(node.data)
def breadthfirst(self):
raise NotImplementedError
def test_find_present_value(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
self.assertEqual(bst.find(data[0]).data, data[0])
def test_preorder_type(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
output = bst.preorder()
self.assertTrue(isinstance(output, list))
def test_preorder_output(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
output = bst.preorder()
self.assertEqual(output[0], data[0])
def grade(self, array):
bst = BinarySearchTree()
for i in array:
bst.add(i)
array = sorted(array)
ptr = 0
for i in bst:
self.assertEqual(i, array[ptr])
ptr += 1
def __init__(self, elements=None):
if not elements or not len(elements) > 1:
raise ValueError('Please provide data to traverse.')
self.tree = BinarySearchTree(BST_Node(elements.pop(0)))
print(self.tree.head)
for element in elements:
self.tree.insert(element)
def test_inorder(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 4000), k=126)
for x in data:
bst.add(x)
data.sort()
tree_data = list(bst.inorder())
self.assertEqual(data, tree_data)
def testtree():
T=BinarySearchTree()
n=int(raw_input())
for i in range(n):
T.insertElement(int(raw_input("Enter element "+str(i+1)+" : ")))
l=int(raw_input("Enter Lower Value: "))
h=int(raw_input("Enter Higher Value: "))
print T.SumofValues(T.root,l,h)
print "The tree is:"
T.inorderTraverse(T.root)
def test03_to_List(self):
binarytree = BinarySearchTree()
binarytree.setData(10)
binarytree.insert(17)
binarytree.insert(16)
binarytree.insert(14)
self.assertEqual(binarytree.toList(), [10, 14, 16, 17])
def test_tree_height(self):
bst = BinarySearchTree()
self.assertEqual(bst.height(), -1)
for i in range(511):
bst.add(i)
self.assertEqual(bst.height(), 510)
bst.rebalance_tree()
self.assertEqual(bst.height(), 8)
def test_delete_root_node(self):
bst = BinarySearchTree(10)
bst.insert(20)
bst.insert(30)
bst.insert(5)
bst.insert(9)
self.assertEqual(bst.size(), 5)
bst = bst.delete(10)
self.assertEqual(bst.size(), 4)
def test_delete(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
bst = BinarySearchTree()
for item in items:
bst.insert(item)
# Delete the specific nodes
bst.delete(7)
assert bst.contains(7) is False
bst.delete(2)
assert bst.contains(2) is False
assert bst.root.left.data == 1
assert bst.root.left.left.data is None
def test_delete(self):
items = [4, 2, 6, 1, 3, 5, 7]
bst = BinarySearchTree(items)
bst.delete(1)
assert bst.size == 6
assert bst.root.left.left == None
bst.delete(2)
assert bst.size == 5
assert bst.root.left.data == 3
bst2 = BinarySearchTree(items)
bst2.delete(4)
assert bst2.size == 6
assert bst2.root.data == 3
assert bst2.root.left.right == None
def test_size(self):
tree = BinarySearchTree()
assert tree.size == 0
tree.insert('B')
assert tree.size == 1
tree.insert('A')
assert tree.size == 2
tree.insert('C')
assert tree.size == 3
def testBST():
bst1 = BinarySearchTree()
n=int(raw_input("Enter number of elements: "))
for i in range(n):
bst1.insertElement(int(raw_input()))
print "INORDER:"
bst1.inorderTraverse(bst1.root)
print
print "PREORDER:"
bst1.preorderTraverse(bst1.root)
print
print "POSTORDER:"
bst1.postorderTraverse(bst1.root)
def testtree():
T=BinarySearchTree()
n=int(raw_input("Enter number of elements: "))
for i in range(n):
T.insertElement(int(raw_input("Enter element "+str(i+1)+" : ")))
x=int(raw_input("Enter the element you want to delete: "))
T.deleteElement(x)
print "The tree is:"
T.inorderTraverse(T.root)
class TestBST(unittest.TestCase):
"""Runs the simple examples from the activate state recipe."""
names = "bob joe Jane jack Mary sue Ed Zoey ann".split()
def setUp(self):
self.bst = BinarySearchTree(self.names, str.upper)
def test_insert(self):
self.assertEquals(self.bst.minimum(), "ann")
def test_minimum(self):
self.assertEquals(self.bst.maximum(), "Zoey")
def test_values(self):
expected_list = ["ann", "bob", "Ed", "jack", "Jane", "joe", "Mary", "sue", "Zoey"]
for expected, result in zip(expected_list, self.bst.values()):
self.assertEquals(expected, result)
def test_values_reversed(self):
expected_list = ["Zoey", "sue", "Mary", "joe", "Jane", "jack", "Ed", "bob", "ann"]
for expected, result in zip(expected_list, self.bst.values(True)):
self.assertEquals(expected, result)
# myList.display()
# myList.reverse()
# print()
# myList.display()
# print()
# myList.delete_first()
# myList.display()
# print()
# myList.delete(8)
# myList.display()
# print()
# print(myList.size)
# Binary Search Tree
print('*****Binary search tree testing*****')
my_tree = BinarySearchTree()
root = None
root = my_tree.insert(root, 3)
my_tree.insert(root, 7)
my_tree.insert(root, 1)
my_tree.insert(root, 5)
my_tree.insert(root, 10)
print('in order')
my_tree.display_in_order(root)
print('pre order')
my_tree.display_pre_order(root)
print('post order')
my_tree.display_post_order(root)
val = 7
print('contains', val, my_tree.contains(root, val))
val = 2
def __init__(self):
BinarySearchTree.__init__(self)
def setUp(self):
self.bst = BinarySearchTree(self.names, str.upper)
def _initialize(self):
self._cleanup()
self.bst = BinarySearchTree()
lst = [5, 8, 2, 1, 3, 9, 7, 4, 6, 0]
for i in lst:
self.bst.insert(i)
