def test_parent_pointer_after_delete():
tree = BinarySearchTree()
tree.add(1)
tree.add(3)
tree.add(6)
tree.delete(3)
assert(tree.get(6).parent.value == 1)
def test_bst(self):
assert BinarySearchTree.from_array([]) is None
nums = [1, 2, 3, 4, 5, 6, 7]
bst = BinarySearchTree.from_array(nums)
for x in nums:
assert x in bst
assert nums == list(iter(bst))
assert bst.height() == 3
assert bst.is_balanced()
rand = sum([bst.random_node() for _ in range(100)])
#assert 350 < rand < 450
bst = bst.remove(5)
assert len(bst) == 6
for x in nums:
assert x in bst or x == 5
bst = bst.remove(3)
assert len(bst) == 5
for x in nums:
assert x in bst or x == 5 or x == 3
bst = bst.remove(4)
assert len(bst) == 4
for x in nums:
assert x in bst or x == 5 or x == 3 or x == 4
bst.add(0)
assert len(bst) == 5
assert list(bst.pre_order()) == [2, 1, 0, 6, 7]
assert list(bst.post_order()) == [0, 1, 7, 6, 2]
for x in list(bst.pre_order()):
bst = bst.remove(x)
unbalanced = BinarySearchTree(0)
for x in nums:
unbalanced.add(x)
assert not unbalanced.is_balanced()
def test_multiple_adds():
tree = BinarySearchTree()
tree.add(3)
tree.add(1)
tree.add(9)
tree.add(6)
assert(len(tree) == 4)
def test_delete_without_children():
tree = BinarySearchTree()
tree.add(1)
tree.add(3)
tree.add(6)
tree.delete(6)
assert(tree.get(3).childcount() == 0)
def test_delete_root():
tree = BinarySearchTree()
tree.add(1)
tree.add(3)
tree.add(6)
tree.add(2)
tree.delete(1)
assert(tree.root.value == 3)
def test_delete_two_children():
tree = BinarySearchTree()
tree.add(1)
tree.add(3)
tree.add(6)
tree.add(2)
tree.delete(3)
assert(tree.contains(3) is False)
assert(len(tree) == 3)
def test_delete_successor_with_children():
tree = BinarySearchTree()
tree.add(1)
tree.add(5)
tree.add(4)
tree.add(10)
tree.add(9)
tree.add(7)
tree.add(8)
tree.delete(5)
assert(tree.get(9).get_only_child().value == 8)
def test_has_children(self):
# 6
# / \
# 4 10
# \
# 16
bst = BinarySearchTree()
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
node = bst.root_node # we have 6
self.assertEqual(node.value, node_val1)
self.assertTrue(node.has_left_child())
self.assertEqual(node.left_child.value, node_val2)
self.assertTrue(node.has_right_child())
self.assertEqual(node.right_child.value, node_val3)
node = node.left_child # we have 4 now
self.assertFalse(node.has_left_child())
self.assertFalse(node.has_right_child())
def test_print_node(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
#self.assertEqual(bst.__str__(), "4 6 10")
self.assertEqual(bst.root_node.__str__(), "4 6 10")
self.assertEqual(bst.root_node.right_child.__str__(), "10 16")
self.assertEqual(bst.root_node.right_child.right_child.__str__(), "16")
def test_iterator(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
ite = BinarySearchIterator(bst)
self.assertEquals(ite.tree, bst)
self.assertEquals(ite.next(), 4)
self.assertEquals(ite.next(), 6)
self.assertEquals(ite.next(), 10)
self.assertEquals(ite.next(), 16)
self.assertRaises(StopIteration, ite.next)
def test_has_children(self):
# 6
# / \
# 4 10
# \
# 16
bst = BinarySearchTree()
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
node = bst.root_node # we have 6
self.assertEqual(node.value, node_val1)
self.assertTrue(node.has_left_child())
self.assertEqual(node.left_child.value, node_val2)
self.assertTrue(node.has_right_child())
self.assertEqual(node.right_child.value, node_val3)
node = node.left_child # we have 4 now
self.assertFalse(node.has_left_child())
self.assertFalse(node.has_right_child())
def test_is_search_node(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
# 6
# / \
# 4 10
# \
# 16
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertTrue(BinarySearchTree.is_search_node(bst.root_node))
self.assertTrue(
BinarySearchTree.is_search_node(bst.root_node.left_child))
self.assertTrue(
BinarySearchTree.is_search_node(bst.root_node.right_child))
self.assertTrue(BinarySearchTree.is_search_node(None))
def test_tree_intersection():
tree_one = BinarySearchTree()
tree_one.add(12)
tree_one.add(5)
tree_one.add(3)
tree_one.add(15)
tree_two = BinarySearchTree()
tree_two.add(1)
tree_two.add(5)
tree_two.add(12)
tree_two.add(55)
assert tree_intersection(tree_one, tree_two) == [12, 5]
def test_iterator(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
ite = BinarySearchIterator(bst)
self.assertEquals(ite.tree, bst)
self.assertEquals(ite.next(), 4)
self.assertEquals(ite.next(), 6)
self.assertEquals(ite.next(), 10)
self.assertEquals(ite.next(), 16)
self.assertRaises(StopIteration, ite.next)
def test_multiple_matching_values_in_one_tree():
tree_one = BinarySearchTree()
tree_one.add(4)
tree_one.add(4)
tree_one.add(4)
tree_one.add(4)
tree_two = BinarySearchTree()
tree_two.add(12)
tree_two.add(5)
tree_two.add(3)
tree_two.add(15)
assert tree_intersection(tree_one, tree_two) == []
def test_print_node(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
#self.assertEqual(bst.__str__(), "4 6 10")
self.assertEqual(bst.root_node.__str__(), "4 6 10")
self.assertEqual(bst.root_node.right_child.__str__(), "10 16")
self.assertEqual(bst.root_node.right_child.right_child.__str__(), "16")
def test_binary_tree():
tree_one = BinarySearchTree()
tree_one.add(12)
tree_one.add(5)
tree_one.add(3)
tree_one.add(15)
tree_two = BinarySearchTree()
tree_two.add(1)
tree_two.add(5)
tree_two.add(12)
tree_two.add(55)
assert tree_one._root.value == 12
assert tree_two._root.value == 1
assert tree_one._root.left.value == 5
def testAdd(self):
bsTree = BinarySearchTree()
self.assertEqual(bsTree.size(), 0)
bsTree.add(15, 15)
self.assertEqual(bsTree.size(), 1)
bsTree.add(10, 10)
# Size of bsTree must be 2
self.assertEqual(bsTree.size(), 2)
self.assertEqual(bsTree.search(10), 10)
self.assertEqual(bsTree.search(15), 15)
self.assertEqual(bsTree.search(25), False)
def test_is_search_tree(self):
# No assertion here, I just want a beautifully designed tree.
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
self.assertTrue(BinarySearchTree.is_search_tree(bst.root_node))
# 6
# / \
# 8 10
# \
# 16
bst.root_node.left_child.value = 8
self.assertEqual(bst.root_node.left_child.value, 8)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
# 12
# / \
# 4 10
# \
# 16
bst.root_node.left_child.value = 4
self.assertEqual(bst.root_node.left_child.value, 4)
bst.root_node.value = 12
self.assertEqual(bst.root_node.value, 12)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
# 6
# / \
# 4 20
# \
# 16
bst.root_node.left_child.value = 6
self.assertEqual(bst.root_node.left_child.value, 6)
bst.root_node.right_child.value = 20
self.assertEqual(bst.root_node.right_child.value, 20)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
def test_is_search_tree(self):
# No assertion here, I just want a beautifully designed tree.
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
self.assertTrue(BinarySearchTree.is_search_tree(bst.root_node))
# 6
# / \
# 8 10
# \
# 16
bst.root_node.left_child.value = 8
self.assertEqual(bst.root_node.left_child.value, 8)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
# 12
# / \
# 4 10
# \
# 16
bst.root_node.left_child.value = 4
self.assertEqual(bst.root_node.left_child.value, 4)
bst.root_node.value = 12
self.assertEqual(bst.root_node.value, 12)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
# 6
# / \
# 4 20
# \
# 16
bst.root_node.left_child.value = 6
self.assertEqual(bst.root_node.left_child.value, 6)
bst.root_node.right_child.value = 20
self.assertEqual(bst.root_node.right_child.value, 20)
self.assertFalse(BinarySearchTree.is_search_tree(bst.root_node))
def test_add(self):
# BST instance
bsTree = BinarySearchTree()
self.assertEqual(bsTree.size(), 0) # bsTree must be empty
# Add a key-value pair
bsTree.add(15, "Value for 15")
# Size of bsTree must be 1
self.assertEqual(bsTree.size(), 1)
# Add another key-value pair
bsTree.add(10, "Value for 10")
# Size of bsTree must be 2
self.assertEqual(bsTree.size(), 2)
# The added keys must exist.
self.assertEqual(bsTree.search(10), "Value for 10")
self.assertEqual(bsTree.search(15), "Value for 15")
class MySet:
"""
利用二分搜索树实现集合
"""
def __init__(self):
self.bst = BinarySearchTree()
def add(self, e):
self.bst.add(e)
def remove(self, e):
self.bst.remove(e)
def contains(self, e):
return self.bst.contains(e)
def getsize(self):
return self.bst.size
def isEmpty(self):
return True if self.bst.size == 0 else False
def main():
a = BinarySearchTree()
a.add(2, '')
a.add(1, '')
a.add(4, '')
a.add(5, '')
b = BinarySearchTree()
b.add(5, '')
b.add(2, '')
b.add(3, '')
print diff(a, b)
def main():
name = sys.argv[1];
for i in xrange(1, 11):
fname = '../data/%d_catalog.txt' % i
#read the catalog and load to a list
phonebook = []
append = phonebook.append
with open(fname, 'r') as f:
for l in f:
if l:
append(Entry.fromline(l))
#print 'phonebook contains %d entries' % len(phonebook)
name_idx = BinarySearchTree()
for i, e in enumerate(phonebook):
name_idx.add(e.name, i)
start = time.time()
idxs = name_idx.get(name)
bstelapsed = (time.time() - start) * 1000
# let's sort the entries by name
phonebook.sort(key=lambda e: e.name)
# let' search for a non existing name using naive search
start = time.time()
idx = search.naive(phonebook, name)
nelapsed = (time.time() - start) * 1000
# the same using binary search
bstart = time.time()
idx = search.binary_search(phonebook, name)
bselapsed = (time.time() - bstart) * 1000
print '%d - naive: %g - binary: %g - bst: %g'\
% (len(phonebook), nelapsed, bselapsed, bstelapsed)
def test_add(self):
"""
tests for add
"""
# Create an instance of BinarySearchTree
binary = BinarySearchTree()
# bsTree must be empty
self.assertEqual(binary.size(), 0)
# Add a key-value pair
binary.add(15, "Value for 15")
# Size of bsTree must be 1
self.assertEqual(binary.size(), 1)
# Add another key-value pair
binary.add(10, "Value for 10")
# Size of bsTree must be 2
self.assertEqual(binary.size(), 2)
# The added keys must exist.
self.assertEqual(binary.search(10), "Value for 10")
self.assertEqual(binary.search(15), "Value for 15")
def test_add(self):
bst = BinarySearchTree()
self.assertEqual(bst.size, 0)
node_val1 = 6
bst.add(node_val1)
self.assertEqual(bst.size, 1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
def test_add(self):
bst = BinarySearchTree()
self.assertEqual(bst.size, 0)
node_val1 = 6
bst.add(node_val1)
self.assertEqual(bst.size, 1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
def test_empty_tree():
tree_one = BinarySearchTree()
tree_one.add(12)
tree_one.add(5)
tree_one.add(3)
tree_one.add(15)
tree_two = BinarySearchTree()
assert tree_intersection(tree_one, tree_two) == []
def test_bst():
B = BinarySearchTree()
assert B.size() == 0
B.add(25)
assert B.size() == 1
B.add(25)
assert B.size() == 1
B.add(25)
assert B.size() == 1
B.add(15)
assert B.size() == 2
assert B.find(25)
assert B.find(15)
assert not B.find(2)
B.remove(15)
assert B.size() == 1
assert not B.find(15)
assert B.find(25)
assert not B.find(2)
def test_print_tree(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
self.assertEqual(bst.__str__(), "4 6 10 16")
def test_print_tree(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
# 6
# / \
# 4 10
# \
# 16
self.assertEqual(bst.__str__(), "4 6 10 16")
def test_min(self):
# 6
# / \
# 4 10
# \
# 16
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
self.assertEqual(bst.min(), node_val2)
def test_min(self):
# 6
# / \
# 4 10
# \
# 16
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertEqual(bst.size, 4)
self.assertEqual(bst.min(), node_val2)
def test_is_search_node(self):
bst = BinarySearchTree()
self.assertEqual(bst.min(), None)
# 6
# / \
# 4 10
# \
# 16
node_val1 = 6
bst.add(node_val1)
node_val2 = 4
bst.add(node_val2)
node_val3 = 10
bst.add(node_val3)
node_val4 = 16
bst.add(node_val4)
self.assertTrue(BinarySearchTree.is_search_node(bst.root_node))
self.assertTrue(BinarySearchTree.is_search_node(bst.root_node.left_child))
self.assertTrue(BinarySearchTree.is_search_node(bst.root_node.right_child))
self.assertTrue(BinarySearchTree.is_search_node(None))
class BSTTestCase(unittest.TestCase):
def setUp(self):
"""
Executed before each test method.
Before each test method, create a BST with some fixed key-values.
"""
self.bst = BinarySearchTree()
self.bst.add(10, "Value for 10")
self.bst.add(52, "Value for 52")
self.bst.add(5, "Value for 5")
self.bst.add(8, "Value for 8")
self.bst.add(1, "Value for 1")
self.bst.add(40, "Value for 40")
self.bst.add(30, "Value for 30")
self.bst.add(45, "Value for 45")
def test_add(self):
"""
tests for add
"""
# Create an instance of BinarySearchTree
binary = BinarySearchTree()
# bsTree must be empty
self.assertEqual(binary.size(), 0)
# Add a key-value pair
binary.add(15, "Value for 15")
# Size of bsTree must be 1
self.assertEqual(binary.size(), 1)
# Add another key-value pair
binary.add(10, "Value for 10")
# Size of bsTree must be 2
self.assertEqual(binary.size(), 2)
# The added keys must exist.
self.assertEqual(binary.search(10), "Value for 10")
self.assertEqual(binary.search(15), "Value for 15")
def test_inorder(self):
"""
tests for inorder_walk
"""
self.assertListEqual(self.bst.inorder_walk(), [1, 5, 8, 10, 30, 40, 45, 52])
# Add one node
self.bst.add(25, "Value for 25")
# Inorder traversal must return a different sequence
self.assertListEqual(self.bst.inorder_walk(), [1, 5, 8, 10, 25, 30, 40, 45, 52])
def test_postorder(self):
"""
tests for postorder_walk
"""
self.assertListEqual(self.bst.postorder_walk(), [1, 8, 5, 30, 45, 40, 52, 10])
# Add one node
self.bst.add(25, "Value for 25")
# Inorder traversal must return a different sequence
self.assertListEqual(self.bst.postorder_walk(), [1, 8, 5, 25, 30, 45, 40, 52, 10])
def test_preorder(self):
"""
tests for preorder_walk
"""
self.assertListEqual(self.bst.preorder_walk(), [10, 5, 1, 8, 52, 40, 30, 45])
# Add one node
self.bst.add(25, "Value for 25")
# Inorder traversal must return a different sequence
self.assertListEqual(self.bst.preorder_walk(), [10, 5, 1, 8, 52, 40, 30, 25, 45])
def test_search(self):
"""
tests for search
"""
self.assertEqual(self.bst.search(40), "Value for 40")
self.assertFalse(self.bst.search(90))
self.bst.add(90, "Value for 90")
self.assertEqual(self.bst.search(90), "Value for 90")
def test_remove(self):
"""
tests for remove
"""
self.bst.remove(40)
self.assertEqual(self.bst.size(), 7)
self.assertListEqual(self.bst.inorder_walk(), [1, 5, 8, 10, 30, 45, 52])
self.assertListEqual(self.bst.preorder_walk(), [10, 5, 1, 8, 52, 45, 30])
def test_smallest(self):
"""
tests for smallest
"""
self.assertTupleEqual(self.bst.smallest(), (1, "Value for 1"))
# Add some nodes
self.bst.add(6, "Value for 6")
self.bst.add(4, "Value for 4")
self.bst.add(0, "Value for 0")
self.bst.add(32, "Value for 32")
# Now the smallest key is 0.
self.assertTupleEqual(self.bst.smallest(), (0, "Value for 0"))
def test_largest(self):
"""
tests for largest
"""
self.assertTupleEqual(self.bst.largest(), (52, "Value for 52"))
# Add some nodes
self.bst.add(6, "Value for 6")
self.bst.add(54, "Value for 54")
self.bst.add(0, "Value for 0")
self.bst.add(32, "Value for 32")
# Now the largest key is 54
self.assertTupleEqual(self.bst.largest(), (54, "Value for 54"))
from bst import BinarySearchTree B = BinarySearchTree() B.add(1) B.add(3) B.add(4) B.remove(2) B.remove(3)
class BSTTestCase(unittest.TestCase):
def setUp(self):
self.bst = BinarySearchTree()
self.bst.add(20, "Value for 20")
self.bst.add(12, "Value for 12")
self.bst.add(3, "Value for 3")
self.bst.add(7, "Value for 7")
self.bst.add(29, "Value for 29")
self.bst.add(11, "Value for 11")
self.bst.add(33, "Value for 33")
self.bst.add(19, "Value for 19")
self.bst.add(56, "Value for 56")
self.bst.add(27, "Value for 27")
self.bst.add(39, "Value for 39")
self.bst2 = BinarySearchTree()
self.bst2.add(1, "Value for 1")
self.bst2.add(2, "Value for 2")
self.bst2.add(3, "Value for 3")
self.bst2.add(4, "Value for 4")
self.bst2.add(5, "Value for 5")
def test_add(self):
self.assertEqual(self.bst.size(), 11)
self.assertEqual(self.bst2.size(), 5)
self.bst.add(11, "Value for 11")
self.assertEqual(self.bst.size(), 12)
self.assertEqual(self.bst.search(11), "Value for 11")
self.bst2.add(6, "Value for 6")
self.assertEqual(self.bst2.size(), 6)
self.assertEqual(self.bst2.search(6), "Value for 6")
def test_inorder(self):
self.assertListEqual(self.bst.inorder_walk(),
[3, 7, 11, 12, 19, 20, 27, 29, 33, 39, 56])
self.assertListEqual(self.bst2.inorder_walk(), [1, 2, 3, 4, 5])
self.bst2.add(6, "Value for 6")
self.assertListEqual(self.bst2.inorder_walk(), [1, 2, 3, 4, 5, 6])
def test_postorder(self):
self.assertListEqual(self.bst.postorder_walk(),
[11, 7, 3, 19, 12, 27, 39, 56, 33, 29, 20])
self.assertListEqual(self.bst2.postorder_walk(), [5, 4, 3, 2, 1])
self.bst2.add(6, "Value for 6")
self.assertListEqual(self.bst2.postorder_walk(), [6, 5, 4, 3, 2, 1])
def test_preorder(self):
self.assertListEqual(self.bst.preorder_walk(),
[20, 12, 3, 7, 11, 19, 29, 27, 33, 56, 39])
self.assertListEqual(self.bst2.preorder_walk(), [1, 2, 3, 4, 5])
self.bst2.add(6, "Value for 6")
self.assertListEqual(self.bst2.preorder_walk(), [1, 2, 3, 4, 5, 6])
def test_search(self):
self.assertEqual(self.bst.search(3), "Value for 3")
self.assertFalse(self.bst2.search(0))
self.bst2.add(6, "Value for 6")
self.assertEqual(self.bst2.search(6), "Value for 6")
def test_remove(self):
self.bst.remove(27)
self.assertEqual(self.bst.size(), 10)
self.bst2.remove(3)
self.assertListEqual(self.bst2.inorder_walk(), [1, 2, 4, 5])
self.assertListEqual(self.bst2.preorder_walk(), [1, 2, 4, 5])
self.assertListEqual(self.bst2.postorder_walk(), [5, 4, 2, 1])
def test_smallest(self):
self.assertTupleEqual(self.bst.smallest(), (3, "Value for 3"))
self.assertTupleEqual(self.bst2.smallest(), (1, "Value for 1"))
self.bst2.add(0, "Value for 0")
self.assertTupleEqual(self.bst2.smallest(), (0, "Value for 0"))
def test_largest(self):
self.assertTupleEqual(self.bst.largest(), (56, "Value for 56"))
self.bst.add(57, "Value for 57")
self.assertTupleEqual(self.bst.largest(), (57, "Value for 57"))
self.assertTupleEqual(self.bst2.largest(), (5, "Value for 5"))
self.bst2.remove(5)
self.assertTupleEqual(self.bst2.largest(), (4, "Value for 4"))
def test_add_to_empty_tree():
tree = BinarySearchTree()
tree.add(3)
assert(len(tree) == 1)
assert(tree.contains(3))
def test_element_only_added_once():
tree = BinarySearchTree()
tree.add(3)
tree.add(3)
assert(len(tree) == 1)
def test_everything_matches():
tree_one = BinarySearchTree()
tree_one.add(12)
tree_one.add(5)
tree_one.add(3)
tree_one.add(15)
tree_two = BinarySearchTree()
tree_two.add(12)
tree_two.add(5)
tree_two.add(3)
tree_two.add(15)
assert tree_intersection(tree_one, tree_two) == [3, 5, 15, 12]
while True:
print(*s, sep=' ', end='')
n = int(input(' : '))
if 1 <= n <= len(Menu):
return Menu(n)
tree = BinarySearchTree() # 이진 검색 트리를 생성
while True:
menu = select_Menu() # 메뉴 선택
if menu == Menu.insert: # 삽입
key = int(input('삽입할 키를 입력하세요.: '))
val = input('삽입할 값을 입력하세요.: ')
if not tree.add(key, val):
print('삽입에 실패했습니다!')
elif menu == Menu.remove: # 삭제
key = int(input('삭제할 키를 입력하세요.: '))
tree.remove(key)
elif menu == Menu.search: # 검색
key = int(input('검색할 키를 입력하세요.: '))
t = tree.search(key)
if t is not None:
print(f'이 키를 갖는 값은 {t}입니다.')
else:
print('해당 데이터가 없습니다.')
elif menu == Menu.dump: # 오름차순 덤프
class CustomBSTTest(unittest.TestCase):
def setUp(self):
self.data = [(11, 11), (10, 10), (15, 15), (1, 1), (17, 17), (25, 25),
(6, 6)]
self.bst = BinarySearchTree()
for (key, val) in self.data:
self.bst.add(key, val)
def testAdd(self):
bsTree = BinarySearchTree()
self.assertEqual(bsTree.size(), 0)
bsTree.add(15, 15)
self.assertEqual(bsTree.size(), 1)
bsTree.add(10, 10)
# Size of bsTree must be 2
self.assertEqual(bsTree.size(), 2)
self.assertEqual(bsTree.search(10), 10)
self.assertEqual(bsTree.search(15), 15)
self.assertEqual(bsTree.search(25), False)
def testInorder(self):
data = self.data.copy()
data.sort(key=lambda x: x[0])
self.assertListEqual(self.bst.inorder_walk(),
list(map(lambda x: x[0], data)))
# Add one node
self.bst.add(50, 50)
data.append((50, 50))
data.sort(key=lambda x: x[0])
self.assertListEqual(self.bst.inorder_walk(),
list(map(lambda x: x[0], data)))
def testPostorder(self):
self.assertListEqual(self.bst.postorder_walk(),
[6, 1, 10, 25, 17, 15, 11])
self.bst.add(12, 12)
self.assertListEqual(self.bst.postorder_walk(),
[6, 1, 10, 12, 25, 17, 15, 11])
def testPreorder(self):
self.assertListEqual(self.bst.preorder_walk(),
[11, 10, 1, 6, 15, 17, 25])
self.bst.add(12, 12)
self.assertListEqual(self.bst.preorder_walk(),
[11, 10, 1, 6, 15, 12, 17, 25])
def testSearch(self):
self.assertEqual(self.bst.search(11), 11)
self.assertFalse(self.bst.search(90))
self.assertEqual(self.bst.search(10), 10)
def testRemove(self):
self.assertFalse(self.bst.remove(40))
self.assertEqual(self.bst.size(), 7)
self.assertTrue(self.bst.remove(11))
self.assertEqual(self.bst.size(), 6)
self.assertListEqual(self.bst.inorder_walk(), [1, 6, 10, 15, 17, 25])
self.assertListEqual(self.bst.preorder_walk(), [15, 10, 1, 6, 17, 25])
def testSmallest(self):
self.assertTupleEqual(self.bst.smallest(), (1, 1))
self.bst.add(6, 6)
self.bst.add(4, 4)
self.bst.add(0, 0)
self.bst.add(32, 32)
# Now the smallest key is 0.
self.assertTupleEqual(self.bst.smallest(), (0, 0))
def testLargest(self):
self.assertTupleEqual(self.bst.largest(), (25, 25))
self.bst.add(6, 6)
self.bst.add(54, 54)
self.bst.add(0, 0)
self.bst.add(32, 32)
# Now the largest key is 54
self.assertTupleEqual(self.bst.largest(), (54, 54))
def test_inner_contained_tree():
tree_one = BinarySearchTree()
tree_one.add(55)
tree_one.add(12)
tree_one.add(6)
tree_one.add(5)
tree_one.add(3)
tree_one.add(100)
tree_one.add(23)
tree_one.add(1)
tree_two = BinarySearchTree()
tree_two.add(12)
tree_two.add(5)
tree_two.add(3)
assert intersection(tree_one, tree_two) == [3, 5, 12]
