def test_IsEmpty(self): tree = BinarySearchTree() self.assertTrue(tree.isEmpty()) tree.add("Hello World!") self.assertFalse(tree.isEmpty())
def testRuntimeErrorRemovingLevelOrder(self): bst = BinarySearchTree("levelorder") bst.add(1) bst.add(2) bst.add(3) iter(bst) bst.remove(2) self.assertRaises(RuntimeError, next, bst)
def test_Add(self): # Add element which does not yet exist tree = BinarySearchTree() self.assertTrue(tree.add('A')) # Add duplicate element self.assertFalse(tree.add('A')) # Add a second element which is not a duplicate self.assertTrue(tree.add('B'))
def testContains(self): # Set up tree tree = BinarySearchTree() tree.add('B') tree.add('A') tree.add('C') # Try looking for an element which doesn't exist self.assertFalse(tree.contains('D')) # Try looking for an element which exists in the root self.assertTrue(tree.contains('B')) # Try looking for an element which exists as the left child of the root self.assertTrue(tree.contains('A')) # Try looking for an element which exists as the right child of the root self.assertTrue(tree.contains('C'))
def testRemove(self): # Try removing an element which doesn't exist tree = BinarySearchTree() tree.add('A') self.assertEqual(len(tree), 1) tree.remove('B') self.assertEqual(len(tree), 1) # Try removing an element which does exist tree.add('B') self.assertEqual(len(tree), 2) tree.remove('B') self.assertEqual(len(tree), 1) self.assertEqual(tree.height(), 1) # Try removing the root tree.remove('A') self.assertEqual(len(tree), 0) self.assertEqual(tree.height(), 0)
def validateTreeTraversal(self, trav_order, input): out = [] expected = [] testTree = None tree = BinarySearchTree() # Construct Binary Tree and test tree for value in input: testTree = addTestTreeNode(testTree, value) tree.add(value) # Get traversal output for iter in tree.traverse(trav_order): out.append(iter) # Generate the expected output for the particular traversal if trav_order == TreeTraversalOrder.PRE_ORDER: expected = preOrderTestTreeNode(testTree) elif trav_order == TreeTraversalOrder.IN_ORDER: expected = inOrderTestTreeNode(testTree) elif trav_order == TreeTraversalOrder.POST_ORDER: expected = postOrderTestTreeNode(testTree) elif trav_order == TreeTraversalOrder.LEVEL_ORDER: expected = levelOrderTestTreeNode(testTree) else: raise Exception('Invalid TreeTraversalOrder') # The output and the expected size better be the same size # print("in ", input) # print("out ", out) # print("exp ", expected) if len(out) != len(expected): return False # Compare output to expected if expected != out: return False return True
def test_Remove(self): # Try removing an element which doesn't exist tree = BinarySearchTree() tree.add('A') self.assertEqual(tree.size(), 1) self.assertFalse(tree.remove('B')) self.assertEqual(tree.size(), 1) # Try removing an element which does exist tree.add('B') self.assertEqual(tree.size(), 2) self.assertTrue(tree.remove('B')) self.assertEqual(tree.size(), 1) self.assertEqual(tree.height(), 1) # Try removing the root self.assertTrue(tree.remove('A')) self.assertEqual(tree.size(), 0) self.assertEqual(tree.height(), 0)
def randomRemoveTests(self): for i in range(self.LOOPS): size = i tree = BinarySearchTree() lst = self.genRandList(size) for idx, value in enumerate(lst): tree.add(value) self.assertEqual(len(tree), idx + 1) random.shuffle(lst) for j in range(size): value = lst[j] self.assertTrue(tree.contains(value)) # Remove all the elements we just placed in the tree for j in range(size): value = lst[j] tree.remove(value) self.assertFalse(tree.contains(value)) self.assertEqual(len(tree), size - j - 1) self.assertFalse(tree)
def randomRemoveTests(self): for i in range(0, self.LOOPS): sz = i tree = BinarySearchTree() lst = self.genRandList(sz) for value in lst: tree.add(value) random.shuffle(lst) # Remove all the elements we just placed in the tree for j in range(0, sz): value = lst[j] self.assertTrue(tree.remove(value)) self.assertFalse(tree.contains(value)) self.assertEqual(tree.size(), sz - j - 1) self.assertTrue(tree.isEmpty())
def validateTreeTraversal(self, traverse, input): out = [] expected = [] testTree = None tree = BinarySearchTree(traverse=traverse) # Construct Binary tree and test tree for value in input: testTree = TestTreeNode.add(testTree, value) tree.add(value) # Generate the expected output for the particular traversal if traverse == "preorder": TestTreeNode.preOrder(expected, testTree) elif traverse == "inorder": TestTreeNode.inOrder(expected, testTree) elif traverse == "postorder": TestTreeNode.postOrder(expected, testTree) elif traverse == "levelorder": TestTreeNode.levelOrder(expected, testTree) # Get traversal output iter(tree) while True: curr = next(tree, None) if curr is not None: out.append(curr) else: break # The output and the expected size should be the same if len(out) != len(expected): return False # Compare output to expected for i in range(len(out)): if expected[i] != out[i]: return False return True
def testRuntimeErrorPostOrder(self): bst = BinarySearchTree("postorder") bst.add(1) bst.add(2) bst.add(3) iter(bst) bst.add(0) self.assertRaises(RuntimeError, next, bst)
def testHeight(self): tree = BinarySearchTree() # Tree should look like: # M # J S # B N Z # A # No tree self.assertEqual(tree.height(), 0) # Layer One tree.add("M") self.assertEqual(tree.height(), 1) # Layer Two tree.add("J") self.assertEqual(tree.height(), 2) tree.add("S") self.assertEqual(tree.height(), 2) # Layer Three tree.add("B") self.assertEqual(tree.height(), 3) tree.add("N") self.assertEqual(tree.height(), 3) tree.add("Z") self.assertEqual(tree.height(), 3) # Layer 4 tree.add("A") self.assertEqual(tree.height(), 4)
while True: try: print('(d) Digitar um texto') print('(e) Exibir palavras do texto Ascendente/Descendente') print('(c) Exibir frequência de ocorrência das palavras') print('(s) Sair') escolha = input('Escolha uma das opções acima: ') if escolha in 'dD': frase = str(input('Digite algo: ')) arvore.deleteTree() lista_frase = frase.split() for palavras in lista_frase: arvore.add(palavras) print('Árvore montada com sucesso!') elif escolha in 'eE': if not arvore.isEmpty(): print('----------------------') print('Em ordem Ascendente:') arvore.inorder() print('Em ordem Descendente:') arvore.inorder_descendente() print('----------------------') else: raise BinarySearchTreeException('Árvore vazia')
from BinarySearchTree import BinarySearchTree tree = BinarySearchTree() tree.add(4) tree.add(2) tree.add(1) tree.add(3) tree.add(8) tree.add(6) tree.add(5) tree.add(7) tree.in_order_travers() print("search result = ", tree.find(6)) print("remove result = ", tree.remove(6)) tree.in_order_travers()
def test_Size(self): tree = BinarySearchTree() self.assertEqual(tree.size(), 0) tree.add("Hello World!") self.assertEqual(tree.size(), 1)
from BinarySearchTree import BinarySearchTree arvore = BinarySearchTree() string = 'estrutura estrutura de dados é outro nível de programação' array = string.split() print(array) for i in array: arvore.add(i) ar = arvore.inorder() print(arvore.frequencia('estrutura'))
def testSize(self): tree = BinarySearchTree() # Tree should look like: # M # J S # B N Z # A # No tree self.assertEqual(len(tree), 0) # Layer One tree.add("M") self.assertEqual(len(tree), 1) # Layer Two tree.add("J") self.assertEqual(len(tree), 2) tree.add("S") self.assertEqual(len(tree), 3) # Layer Three tree.add("B") self.assertEqual(len(tree), 4) tree.add("N") self.assertEqual(len(tree), 5) tree.add("Z") self.assertEqual(len(tree), 6) # Layer 4 tree.add("A") self.assertEqual(len(tree), 7)
from BinarySearchTree import BinarySearchTree tree = BinarySearchTree() assert tree.is_empty() is True tree.add(1) assert tree.is_empty() is False assert tree.size() == 1 tree.remove(1) assert tree.height() == 0 tree.add('M') assert tree.height() == 1 tree.add('J') assert tree.height() == 2 tree.add('S') assert tree.height() == 2 tree.add('B') assert tree.height() == 3 tree.add('N') assert tree.height() == 3 tree.add('Z') assert tree.height() == 3 tree.add('A') assert tree.height() == 4 tree.remove('M') tree.remove('J') tree.remove('S') tree.remove('B') tree.remove('N')