def test_student_eq(self):
"""Tests to see if the student has a eq method implemented"""
student1 = Student(10, "student")
student2 = Student(10, "another_student")
self.assertEqual(student1, student2)
student1 = Student(10, "student")
student2 = Student(15, "student")
self.assertNotEqual(student1, student2)
def test_student_str(self):
"""Tests to see if the student has a str method implemented"""
str_method = getattr(Student, "__str__", None)
# check that it exists
self.assertIsNotNone(str_method)
# check that it's callable
self.assertTrue(callable(str_method))
# check that it's different from default behavior
test_student = Student(10, "test_student")
self.assertNotEqual(str(test_student), repr(test_student))
def test_get_first(self):
"""Tests the get_first method"""
# test_values = [15, 0, -5, 5, 20, 25, 17]
test_values = [Student(15, "Root"), Student(0, "Root->L"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
new_tree = build_BST(test_values)
# Starting Tree:
# 15
# 0 20
# -5 5 17 25
#
# Test 1
# get root value of tree
self.assertEqual(new_tree.get_first(), Student(15, "Root"))
def test_add_node_student(self):
"""Tests that nodes containing student data are added to the binary tree in the correct position"""
test_students = [Student(15, "Root"), Student(0, "Root->Left"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
# Expected Tree (Grades):
# 15
# 0 20
# -5 5 17 25
student_tree = build_BST(test_students)
self.assertEqual(student_tree.root.val, test_students[0])
self.assertEqual(student_tree.root.left.val, test_students[1])
self.assertEqual(student_tree.root.right.val, test_students[4])
self.assertEqual(student_tree.root.left.left.val, test_students[2])
self.assertEqual(student_tree.root.left.right.val, test_students[3])
self.assertEqual(student_tree.root.right.right.val, test_students[5])
self.assertEqual(student_tree.root.right.left.val, test_students[6])
def test_student_gt(self):
"""Tests to see if the student has a gt method implemented"""
student1 = Student(10, "lesser_student")
student2 = Student(12, "greater_student")
self.assertGreater(student2, student1)
def test_student_lt(self):
"""Tests to see if the student has a lt method implemented"""
student1 = Student(10, "lesser_student")
student2 = Student(12, "greater_student")
self.assertLess(student1, student2)
def test_remove_first(self):
"""Tests the remove_first method"""
# test_values = [15, 0, -5, 5, 20, 25, 17]
test_values = [Student(15, "Root"), Student(0, "Root->L"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
new_tree = build_BST(test_values)
# Starting Tree:
# 15
# 0 20
# -5 5 17 25
#
# Test 1
# delete root, replace with left-most node of right child
new_tree.remove_first()
test_values.remove(Student(15, "Root"))
# Expected Tree:
# 17
# 0 20
# -5 5 25
self.assertEqual(new_tree.root.val.grade, 17)
self.assertEqual(new_tree.root.right.val.grade, 20)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 2
# delete root, replace with left-most node of right child
new_tree.remove_first()
test_values.remove(Student(17, "Root->R->L"))
# Expected Tree:
# 20
# 0 25
# -5 5
self.assertEqual(new_tree.root.val.grade, 20)
self.assertEqual(new_tree.root.right.val.grade, 25)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 3
# delete root, replace with left-most node of right child
new_tree.remove_first()
test_values.remove(Student(20, "Root->R"))
# Expected Tree:
# 25
# 0
# -5 5
self.assertEqual(new_tree.root.val.grade, 25)
self.assertIsNone(new_tree.root.right)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 4
# Continue removing until tree is empty
# remove 25
new_tree.remove_first()
# Expected Tree:
# 0
# -5 5
# Test 5
# remove 0
new_tree.remove_first()
# Expected Tree:
# 5
# -5
# Test 6
# remove 5
new_tree.remove_first()
# Expected Tree:
# -5
# Test 7
# remove -5
new_tree.remove_first()
# Expected Tree:
# new_tree.root = None
self.assertIsNone(new_tree.root)
def test_remove(self):
"""Tests that nodes can be removed from the binary search tree"""
# test_values = [15, 0, -5, 5, 20, 25, 17]
test_values = [Student(15, "Root"), Student(0, "Root->L"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
new_tree = build_BST(test_values)
# Starting Tree:
# 15
# 0 20
# -5 5 17 25
#
# Test 1
# delete root, replace with left-most node of right child
new_tree.remove(Student(15, "Root"))
test_values.remove(Student(15, "Root"))
# Expected Tree:
# 17
# 0 20
# -5 5 25
self.assertEqual(new_tree.root.val.grade, 17)
self.assertEqual(new_tree.root.right.val.grade, 20)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 2
# delete root, replace with left-most node of right child
new_tree.remove(Student(17, "Root->R->L"))
test_values.remove(Student(17, "Root->R->L"))
# Expected Tree:
# 20
# 0 25
# -5 5
self.assertEqual(new_tree.root.val.grade, 20)
self.assertEqual(new_tree.root.right.val.grade, 25)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 3
# delete root, replace with left-most node of right child
new_tree.remove(Student(20, "Root->R"))
test_values.remove(Student(20, "Root->R"))
# Expected Tree:
# 25
# 0
# -5 5
self.assertEqual(new_tree.root.val.grade, 25)
self.assertIsNone(new_tree.root.right)
self.assertEqual(new_tree.root.left.val.grade, 0)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 4
# delete 5
new_tree.remove(Student(5, "Root->L->R"))
test_values.remove(Student(5, "Root->L->R"))
# Expected Tree:
# 25
# 0
# -5
self.assertEqual(new_tree.root.val.grade, 25)
self.assertIsNone(new_tree.root.right)
self.assertEqual(new_tree.root.left.val.grade, 0)
self.assertIsNone(new_tree.root.left.right)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 5
# delete single child node
new_tree.remove(Student(0, "Root->L"))
test_values.remove(Student(0, "Root->L"))
# Expected Tree:
# 25
# -5
self.assertEqual(new_tree.root.val.grade, 25)
self.assertIsNone(new_tree.root.right)
self.assertEqual(new_tree.root.left.val.grade, -5)
self.assertIsNone(new_tree.root.left.right)
self.assertIsNone(new_tree.root.left.left)
# ensure the remaining values are in the tree
self.assertEqual(test_contains(new_tree, test_values), True)
# Test 6
# delete root when replaced with node that has right child
test_values = [Student(15, "Root"), Student(0, "Root->L"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L"), Student(19, "Root->R->L->R")]
new_tree = build_BST(test_values)
# Starting Tree:
# 15
# 0 20
# -5 5 17 25
# 19
new_tree.remove(Student(15, "Root"))
test_values.remove(Student(15, "Root"))
# Expected Tree:
# 17
# 0 20
# -5 5 19 25
#
self.assertEqual(new_tree.root.val.grade, 17)
self.assertEqual(new_tree.root.right.val.grade, 20)
self.assertEqual(new_tree.root.right.left.val.grade, 19)
self.assertEqual(test_contains(new_tree, test_values), True)
def test_left_child(self):
"""Tests the left_child implementation of the student tree"""
test_students = [Student(15, "Root"), Student(0, "Root->Left"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
# Expected Tree (Grades):
# 15
# 0 20
# -5 5 17 25
student_tree = build_BST(test_students)
# start node = root
self.assertEqual(Student(-5, "Root->L->L"), student_tree.left_child(student_tree.root).val)
# start node = root.left
self.assertEqual(Student(-5, "Root->L->L"), student_tree.left_child(student_tree.root.left).val)
# start node = root.right
self.assertEqual(Student(17, "Root->R->L"), student_tree.left_child(student_tree.root.right).val)
# start node = root.right.right
self.assertEqual(Student(25, "Root->R->R"), student_tree.left_child(student_tree.root.right.right).val)
def test_post_order_traversal(self):
"""Tests student post-order-traversal implementation"""
test_students = [Student(15, "Root"), Student(0, "Root->Left"), Student(-5, "Root->L->L"),
Student(5, "Root->L->R"), Student(20, "Root->R"), Student(25, "Root->R->R"),
Student(17, "Root->R->L")]
# Expected Tree (Grades):
# 15
# 0 20
# -5 5 17 25
student_tree = build_BST(test_students)
# -5 -> 5 -> 0 -> 17 -> 25 -> 20 -> 15
validated_traversal = [Student(-5, "Root->L->L"), Student(5, "Root->L->R"), Student(0, "Root->Left"),
Student(17, "Root->R->L"), Student(25, "Root->R->R"), Student(20, "Root->R"),
Student(15, "Root")]
student_traversal = student_tree.post_order_traversal()
for i in range(0, len(validated_traversal)):
self.assertEqual(validated_traversal[i], student_traversal[i])
from bst import Student, BST
if __name__ == '__main__':
bst1 = BST()
bst1.add(5)
bst1.add(9)
bst1.add(1)
print(bst1.in_order_traversal())
bst2 = BST()
bst2.add(Student(88, "Sasha"))
bst2.add(Student(94, "Rachel"))
bst2.add(Student(93, "Phil"))
bst2.add(Student(85, "Mike"))
in_order = bst2.in_order_traversal()
for i in in_order:
print(i)
