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)