def test_search(self):
bin = BST()
for i in range(50):
bin.insert(i)
self.assertEqual(bin.find(8).val, 8)
self.assertEqual(bin.find(49).val, 49)
self.assertEqual(bin.find(60), None)
def main():
#create BST:
print('create BST with elements: 10, 5, 2, 6, 1, 4, 20, 15, 25')
bst = BST(10)
insert_in_BST = [5, 2, 6, 1, 4, 20, 15, 25]
for item in insert_in_BST:
bst.insert(item)
# test find() -> find root with key = 2 and print key:
print('find root with key=2 and print key:')
print(bst.find(2).key)
# find min/max:
print('find node with min key and print key (should be 1):')
print(bst.findMin().key)
print('find node with max key and print key (should be 25):')
print(bst.findMax().key)
# traverse tree / delete nodes:
print('traverse tree in order and print all keys:')
bst.traverseInOrder()
print('delete node with key=5 and traverse tree again:')
bst.delete(5)
bst.traverseInOrder()
# get root and print it's key:
print('get root key (should be 10)')
print(bst.getRoot().key)
class TranversalBST(object):
def __init__(self):
self.bst = BST(None)
self.nodes = []
def insert(self, value):
if not self.bst.value:
self.bst.value = value
else:
self.bst.insert(value)
def contains(self, value):
return bool(self.bst.find(value))
def get(self, index):
for i, value in enumerate(self.inorder()):
if i == index:
return value
def inorder(self):
current = self.bst
self.nodes = []
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
stack.append(current)
current = current.left
else:
current = stack.pop()
self.nodes.append(current.value)
current = current.right
return self.nodes
def preorder(self):
self.nodes = []
stack = [self.bst]
while len(stack) > 0:
curr = stack.pop()
if curr is not None:
self.nodes.append(curr.value)
stack.append(curr.right)
stack.append(curr.left)
return self.nodes
def preorder2(self):
self.nodes = []
current = self.bst
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
self.nodes.append(current.value)
stack.append(current)
current = current.left
else:
current = stack.pop()
current = current.right
return self.nodes
class TestBST(unittest.TestCase):
def setUp(self):
self.bst = BST()
############### tests en boîte noire ###############
# cas où BST = None et node n'existe pas (B1N1)
def test_delete_node_when_node_is_none_and_BST_is_none(self):
self.bst.root = None
self.assertEqual(self.bst.delete_node(node(100)), None)
# impossible de tester ce cas
# cas où BST = None et node existe (B1N2)
def test_delete_node_when_node_is_not_none_and_BST_is_none(self):
self.bst.root = None
self.bst.insert(6) # ici BST n'est plus "None" (vide)
self.assertEqual(self.bst.delete_node(node(6)), None)
# cas où BST existe et node n'existe pas (B2N1)
def test_delete_node_when_node_is_not_none_but_value_is_not_in_BST(self):
self.bst.insert(2)
self.assertEqual(self.bst.delete_node(node(100)), None)
# cas où BST existe et node exist (B2N2)
def test_delete_node_when_node_is_not_none(self):
self.bst.insert(2)
self.bst.delete_node(node(2))
self.assertEqual(self.bst.find(2), None)
self.assertEqual(self.bst.root, None)
############### tests boite blanche ###############
#note: nbChild indique le nombre d'enfant que le node contient
# cas où le noeud n'existe pas (node == None)
def test_delete_node_when_node_is_none_it_should_return_none(self):
self.assertEqual(self.bst.delete_node(None), None)
# cas où le search retourne False (self.search(node.value) == False)
def test_delete_node_when_node_is_not_in_BST_it_should_return_none(self):
self.bst.insert(2)
self.assertEqual(self.bst.delete_node(node(100)), None)
# cas où nbChild = 0 et le node à delete est la racine
def test_delete_node_when_the_node_to_delete_has_no_children_and_is_root(
self):
self.bst.insert(4)
self.bst.delete_node(node(4))
self.assertEqual(self.bst.root, None)
# cas où nbChild = 0 et le node est un enfant gauche de la racine
def test_delete_node_when_the_node_to_delete_has_no_children_and_is_left_leaf(
self):
self.bst.insert(4)
self.bst.insert(1)
node = self.bst.find(1)
self.bst.delete_node(node)
self.assertEqual(node.parent.left, None)
# cas où nbChild = 0 et le node est un enfant à droite de la racine
def test_delete_node_when_the_node_to_delete_has_no_children_and_is_right_leaf(
self):
self.bst.insert(4)
self.bst.insert(10)
node = self.bst.find(10)
self.bst.delete_node(node)
self.assertEqual(node.parent.right, None)
# cas où nbChild = 1, son fils est à sa gauche et le noeud est la racine
def test_delete_node_when_the_node_to_delete_has_one_left_child_and_is_root(
self):
self.bst.insert(5)
self.bst.insert(1)
nodeToDelete = self.bst.find(5)
self.bst.delete_node(nodeToDelete)
self.assertEqual(self.bst.root.value, nodeToDelete.left.value)
# cas où nbChild = 1, son fils est à sa gauche, le noeud n'est pas la racine et le noeud est à droite de son parent
def test_delete_node_when_the_node_to_delete_has_one_left_child_and_is_not_root(
self):
self.bst.insert(5)
self.bst.insert(8)
self.bst.insert(7)
nodeToDelete = self.bst.find(8)
self.bst.delete_node(nodeToDelete)
self.assertEqual(self.bst.root.right.value, nodeToDelete.left.value)
# cas où nbChild = 1, son fils est à sa droite, le noeud n'est pas la racine et le noeud est à gauche de son parent
def test_delete_node_when_the_node_to_delete_has_one_right_child_and_is_not_root(
self):
self.bst.insert(5)
self.bst.insert(3)
self.bst.insert(4)
nodeToDelete = self.bst.find(3)
self.bst.delete_node(nodeToDelete)
self.assertEqual(self.bst.root.left.value, nodeToDelete.right.value)
# cas où nbChild = 2, on vérifie si l'enfant de droite devient la racine
def test_delete_node_when_the_node_to_delete_has_two_children(self):
self.bst.insert(5)
self.bst.insert(6)
self.bst.insert(3)
nodeToDelete = self.bst.find(5)
rightNode = nodeToDelete.right
self.bst.delete_node(nodeToDelete)
self.assertEqual(self.bst.root.value, rightNode.value)
# cas où nbChild = 2, on vérifie si le noeud le plus petit de la partie droite de l'arbre devient la racine
def test_delete_node_when_the_node_to_delete_has_two_children_and_root_is_the_smallest_child_from_the_right_branch(
self):
self.bst.insert(5)
self.bst.insert(3)
self.bst.insert(8)
self.bst.insert(7)
self.bst.insert(10)
nodeToDelete = self.bst.find(5)
self.bst.delete_node(nodeToDelete)
self.assertEqual(self.bst.root.value, 7)
class TranversalBST(object):
def __init__(self):
self.bst = BST(None)
self.nodes = []
def insert(self, value):
if not self.bst.value:
self.bst.value = value
else:
self.bst.insert(value)
def contains(self, value):
return bool(self.bst.find(value))
def get(self, index):
for i, value in enumerate(self.inorder()):
if i == index:
return value
def inorder(self):
current = self.bst
self.nodes = []
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
stack.append(current)
current = current.left
else:
current = stack.pop()
self.nodes.append(current.value)
current = current.right
return self.nodes
def preorder(self):
self.nodes = []
stack = [self.bst]
while len(stack) > 0:
curr = stack.pop()
if curr is not None:
self.nodes.append(curr.value)
stack.append(curr.right)
stack.append(curr.left)
return self.nodes
def preorder2(self):
self.nodes = []
current = self.bst
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
self.nodes.append(current.value)
stack.append(current)
current = current.left
else:
current = stack.pop()
current = current.right
return self.nodes
def preorder3(self):
self.nodes = []
node = self.bst
if not node: return None
stack = []
stack.append(node)
while stack:
node = stack.pop()
self.nodes.append(node.value)
if node.right: stack.append(node.right) # RIGHT FIRST!
if node.left: stack.append(node.left)
return self.nodes
def BFT(self):
self.nodes = []
node = self.bst
if not node: return None
queue = deque()
queue.append(node)
while queue:
node = queue.popleft()
self.nodes.append(node.value)
if node.left: queue.append(node.left) # LEFT FIRST!
if node.right: queue.append(node.right)
return self.nodes
# Test size
print("Size is: " + str(b.size))
if b.size != len(L):
print("... which is incorrect.")
sys.exit()
# Test height
print("Height is: " + str(b.height))
if b.height != 2:
print("... which is incorrect.")
sys.exit()
# Test find return value for all ints in the BST
for i in range(len(L)):
if (b.find(L[i])).getVal() != L[i]:
print("Incorrect return value when finding " + str(L[i]))
sys.exit()
print("Find Int OK.")
# Test find return value for int not in BST.
if b.find(2) != b.end():
print("Incorrect return value when finding " + str(2))
sys.exit()
print("Does Not Find Int OK.")
# Sort the list, to compare with inorder iteration on the BST
L.sort()
# Test BST iterator; should iterate inorder
print("traversal using iterator:")
class TranversalBST(object):
def __init__(self):
self.bst = BST(None)
self.nodes = []
def insert(self, value):
if not self.bst.value:
self.bst.value = value
else:
self.bst.insert(value)
def contains(self, value):
return bool(self.bst.find(value))
def get(self, index):
for i, value in enumerate(self.inorder()):
if i == index:
return value
def inorder(self):
current = self.bst
self.nodes = []
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
stack.append(current)
current = current.left
else:
current = stack.pop()
self.nodes.append(current.value)
current = current.right
return self.nodes
def preorder(self):
self.nodes = []
stack = [self.bst]
while len(stack) > 0:
curr = stack.pop()
if curr is not None:
self.nodes.append(curr.value)
stack.append(curr.right)
stack.append(curr.left)
return self.nodes
def preorder2(self):
self.nodes = []
current = self.bst
stack = []
while len(stack) > 0 or current is not None:
if current is not None:
self.nodes.append(current.value)
stack.append(current)
current = current.left
else:
current = stack.pop()
current = current.right
return self.nodes
def preorder3(self):
self.nodes = []
node = self.bst
if not node: return None
stack = []
stack.append(node)
while stack:
node = stack.pop()
self.nodes.append(node.value)
if node.right: stack.append(node.right) # RIGHT FIRST!
if node.left: stack.append(node.left)
return self.nodes
def BFT(self):
self.nodes = []
node = self.bst
if not node: return None
queue = deque()
queue.append(node)
while queue:
node = queue.popleft()
self.nodes.append(node.value)
if node.left: queue.append(node.left) # LEFT FIRST!
if node.right: queue.append(node.right)
return self.nodes
