def test_IsEmpty(self):

        tree = BinarySearchTree()
        self.assertTrue(tree.isEmpty())

        tree.add("Hello World!")
        self.assertFalse(tree.isEmpty())
class BSTTableWrapper:
    def __init__(self):
        self.bst = BinarySearchTree()

    def tableInsert(self, newItem):
        return self.bst.searchTreeInsert(newItem)

    def tableDelete(self, searchKey):
        return self.bst.searchTreeDelete(searchKey)

    def tableRetrieve(self, searchKey):
        return self.bst.searchTreeRetrieve(searchKey)

    def tableIsEmpty(self):
        return self.bst.isEmpty()

    def tableTraverse(self):
        return self.bst.inorderTraverse()
Esempio n. 3
0
class BSTTable:     # Wrapper with table operations for BinarySearchTree
    def __init__(self):
        self.bst = BinarySearchTree()

    def __del__(self):
        self.bst = None

    def isEmpty(self):
        return self.bst.isEmpty()

    def getLength(self):
        return self.bst.getTreeLength()

    def tableInsert(self, order):
        return self.bst.searchTreeInsert(TreeItem(order, order.getTimestamp()))

    def tableDelete(self, timestamp):
        return self.bst.searchTreeDelete(timestamp)

    def traverseTable(self):
        return self.bst.inorderTraverse()
    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())
        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')

        elif escolha in 'cC':
            if not arvore.isEmpty():
                print('----------------------------------------')
                arvore.listar()
                array = arvore.getValues()
 def test_empty_tree(self):
     BST = BinarySearchTree()
     self.assertEqual(BST.isEmpty(), True)
 def test_nonempty_tree(self):
     BST = BinarySearchTree(5)
     self.assertEqual(BST.isEmpty(), False)