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')
