def test_delete(self):
tree = BinarySearchTree()
self.assertIsNone(tree.delete(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for key in keys:
v = tree.delete("key{}".format(key))
self.assertEqual("value{}".format(key), v)
tree = BinarySearchTree()
for i in range(512):
tree.put(i, i * 100)
for i in range(512):
self.assertEqual(i * 100, tree.delete(i))
tree = BinarySearchTree()
for i in range(128):
tree.put(i, i * 100)
for i in reversed(range(128)):
self.assertEqual(i * 100, tree.delete(i))
for j in range(i):
self.assertEqual(j * 100, tree.get(j))
self.assertIsNone(tree.delete(0))
def test_delete(self):
tree = BinarySearchTree()
self.assertIsNone(tree.delete(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for key in keys:
v = tree.delete("key{}".format(key))
self.assertEqual("value{}".format(key), v)
tree = BinarySearchTree()
for i in range(512):
tree.put(i, i * 100)
for i in range(512):
self.assertEqual(i * 100, tree.delete(i))
tree = BinarySearchTree()
for i in range(128):
tree.put(i, i * 100)
for i in reversed(range(128)):
self.assertEqual(i * 100, tree.delete(i))
for j in range(i):
self.assertEqual(j * 100, tree.get(j))
self.assertIsNone(tree.delete(0))
def delete(self, remove):
parent = None
if remove.parent != None:
parent = remove.parent
self.splay(remove)
BinarySearchTree.delete(self, remove)
if parent:
self.splay(parent)
def delete(self, remove):
parent = None
if remove.parent != None:
parent = remove.parent
self.splay(remove)
BinarySearchTree.delete(self, remove)
if parent:
self.splay(parent)
class BinarySearchTreeTest(TestCase):
def setUp(self):
self.bst = BinarySearchTree()
self.bst.put('H', 5)
self.bst.put('B', 4)
self.bst.put('K', 9)
self.bst.put('C', 2)
self.bst.put('I', -1)
self.bst.put('M', 11)
def test_get(self):
self.assertEqual(self.bst.get('C'), 2)
self.assertEqual(self.bst.get('M'), 11)
self.assertEqual(self.bst.get('Z'), None)
def test_size(self):
self.assertEqual(self.bst.size(), 6)
def test_min(self):
self.assertEqual(self.bst.min(), 'B')
def test_max(self):
self.assertEqual(self.bst.max(), 'M')
def test_floor(self):
self.assertEqual(self.bst.floor('D'), 'C')
self.assertEqual(self.bst.floor('M'), 'M')
self.assertEqual(self.bst.floor('A'), None)
def test_select(self):
self.assertEqual(self.bst.select(0), 'B')
self.assertEqual(self.bst.select(1), 'C')
self.assertEqual(self.bst.select(5), 'M')
self.assertEqual(self.bst.select(6), None)
def test_rank(self):
self.assertEqual(self.bst.rank('B'), 0)
self.assertEqual(self.bst.rank('C'), 1)
self.assertEqual(self.bst.rank('D'), 2)
self.assertEqual(self.bst.rank('H'), 2)
self.assertEqual(self.bst.rank('M'), 5)
self.assertEqual(self.bst.rank('Z'), 6)
def test_delete_min(self):
self.bst.delete_min()
self.assertEqual(self.bst.size(), 5)
self.assertEqual(self.bst.min(), 'C')
def test_delete(self):
self.bst.delete('H')
self.assertEqual(self.bst.size(), 5)
self.assertEqual(self.bst.get('H'), None)
def test_keys(self):
keys = self.bst.keys('C', 'J')
self.assertEqual(keys, ['C', 'H', 'I'])
def test_delete(): bs_tree = BinarySearchTree() keys = [5, 2, -4, 3, 12, 9 ,21, 19, 25] for key in keys: node = Node() node.key = key bs_tree.insert(node) # delete leaf bs_tree.delete(bs_tree.search(-4)) assert(bs_tree.search(-4) is None) assert(bs_tree.search(2).left is None) # delete node with one child bs_tree.delete(bs_tree.search(2)) assert(bs_tree.search(2) is None) assert(bs_tree.root.left.key == 3) # delete node with two children bs_tree.delete(bs_tree.search(12)) assert(bs_tree.root.right.key == 19) assert(bs_tree.search(19).left.key == 9) assert(bs_tree.search(19).right.key == 21) # delete root bs_tree.delete(bs_tree.root) assert(bs_tree.root.key == 9) assert(bs_tree.root.left.key == 3) assert(bs_tree.root.right.key == 19)
def test_deleteRoot():
BST = BinarySearchTree()
BST.put(10, "ten")
BST.put(15, "fifteen")
BST.put(5, "five")
BST.put(3, "three")
BST.put(7, "seven")
BST.put(12, "twelve")
BST.put(17, "seventeen")
assert BST.inOrder(BST.root) == \
"3 5 7 10 12 15 17"
BST.delete(10)
assert BST.inOrder(BST.root) == \
"3 5 7 12 15 17"
def test_deleteNodeWithTwoChildren():
BST = BinarySearchTree()
BST.put(10, "ten")
BST.put(15, "fifteen")
BST.put(5, "five")
BST.put(3, "three")
BST.put(7, "seven")
BST.put(12, "twelve")
BST.put(17, "seventeen")
BST.delete(15)
assert BST.inOrder(BST.root) == \
"3 5 7 10 12 17"
BST.delete(5)
assert BST.inOrder(BST.root) == \
"3 7 10 12 17"
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.my_bst = BinarySearchTree()
self.tree_values = [25, 50, 12, 35, 5, 60, 17, 1]
for value in self.tree_values:
self.my_bst.insert(value)
def test_exceptions(self):
self.assertRaises(AttributeError, self.my_bst.insert, 50)
self.assertRaises(AttributeError, self.my_bst.insert, 12)
self.assertRaises(AttributeError, self.my_bst.insert, 35)
self.assertRaises(AttributeError, self.my_bst.insert, 1)
def test_tree_operations(self):
self.assertEquals(self.my_bst.find(13), False)
self.assertEquals(self.my_bst.find(27), False)
for val in self.tree_values:
self.assertTrue(self.my_bst.find(val))
self.assertIsNone(self.my_bst.delete(12))
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.my_bst = BinarySearchTree()
self.tree_values = [25, 50, 12, 35, 5, 60, 17, 1]
for value in self.tree_values:
self.my_bst.insert(value)
def test_exceptions(self):
self.assertRaises(AttributeError, self.my_bst.insert, 50)
self.assertRaises(AttributeError, self.my_bst.insert, 12)
self.assertRaises(AttributeError, self.my_bst.insert, 35)
self.assertRaises(AttributeError, self.my_bst.insert, 1)
def test_tree_operations(self):
self.assertEquals(self.my_bst.find(13), False)
self.assertEquals(self.my_bst.find(27), False)
for val in self.tree_values:
self.assertTrue(self.my_bst.find(val))
self.assertIsNone(self.my_bst.delete(12))
def test_bst():
# initialize BST
bst = BST(23, 'Apple')
# test insert
bst.insert(14, 'Pear')
bst.insert(105, 'Orange')
assert bst.preorder_traversal() == 'Apple, Pear, Orange, '
assert bst.postorder_traversal() == 'Pear, Orange, Apple, '
assert bst.inorder_traversal() == 'Pear, Apple, Orange, '
bst.insert(65, 'Mango')
bst.insert(2, 'Grape')
bst.insert(34, 'Watermelon')
bst.insert(20, 'Strawberry')
assert bst.preorder_traversal(
) == 'Apple, Pear, Grape, Strawberry, Orange, Mango, Watermelon, '
assert bst.postorder_traversal(
) == 'Grape, Strawberry, Pear, Watermelon, Mango, Orange, Apple, '
assert bst.inorder_traversal(
) == 'Grape, Pear, Strawberry, Apple, Watermelon, Mango, Orange, '
# test has
assert bst.has(23)
assert bst.has(14)
assert bst.has(105)
assert bst.has(2)
assert bst.has(65)
assert bst.has(34)
assert not bst.has(3)
assert not bst.has(74)
assert not bst.has(128)
# test lookup
assert bst.lookup(23) == 'Apple'
assert bst.lookup(14) == 'Pear'
assert bst.lookup(105) == 'Orange'
assert bst.lookup(2) == 'Grape'
assert bst.lookup(65) == 'Mango'
assert bst.lookup(34) == 'Watermelon'
assert bst.lookup(106) == ''
# test height
assert bst.height() == 3
# test delete
bst.delete(23)
assert bst.preorder_traversal(
) == 'Watermelon, Pear, Grape, Strawberry, Orange, Mango, '
assert bst.postorder_traversal(
) == 'Grape, Strawberry, Pear, Mango, Orange, Watermelon, '
assert bst.inorder_traversal(
) == 'Grape, Pear, Strawberry, Watermelon, Mango, Orange, '
assert bst.height() == 2
bst.delete(14)
assert bst.preorder_traversal(
) == 'Watermelon, Strawberry, Grape, Orange, Mango, '
assert bst.postorder_traversal(
) == 'Grape, Strawberry, Mango, Orange, Watermelon, '
assert bst.inorder_traversal(
) == 'Grape, Strawberry, Watermelon, Mango, Orange, '
assert bst.height() == 2
bst.delete(65)
assert bst.preorder_traversal(
) == 'Watermelon, Strawberry, Grape, Orange, '
assert bst.postorder_traversal(
) == 'Grape, Strawberry, Orange, Watermelon, '
assert bst.inorder_traversal(
) == 'Grape, Strawberry, Watermelon, Orange, '
bst.delete(20)
assert bst.preorder_traversal(
) == 'Watermelon, Grape, Orange, '
assert bst.postorder_traversal(
) == 'Grape, Orange, Watermelon, '
assert bst.inorder_traversal(
) == 'Grape, Watermelon, Orange, '
bst.insert(120, 'Blueberry')
bst.delete(34)
assert bst.preorder_traversal(
) == 'Orange, Grape, Blueberry, '
assert bst.postorder_traversal(
) == 'Grape, Blueberry, Orange, '
assert bst.inorder_traversal(
) == 'Grape, Orange, Blueberry, '
assert bst.height() == 1
bst.delete(120)
bst.delete(2)
bst.delete(105)
assert bst.preorder_traversal(
) == ''
assert bst.postorder_traversal(
) == ''
assert bst.inorder_traversal(
) == ''
assert bst.height() == 0
# test is_empty
assert bst.is_empty(bst.root)
assert bst.is_empty(None)
bst = BST(43, 'Blackberry')
assert not bst.is_empty(bst.root)
# test nuke
bst.nuke()
assert bst.is_empty(bst.root)
from BinarySearchTree import BinarySearchTree from Node import Node BST = BinarySearchTree(6) BST.insert(3) BST.insert(2) BST.insert(4) BST.insert(-1) BST.insert(1) BST.insert(-2) BST.insert(8) BST.insert(7) BST.delete(4)
#!/usr/bin/python
from BinarySearchTree import BinarySearchTree
bst = BinarySearchTree()
bst.put(10,'a')
bst.put(9,'b')
bst.put(2,'c')
bst.put(12,'d')
bst.put(14,'e')
bst.put(11,'e')
bst.put(16,'e')
bst[20] = 'f'
print bst.length()
print bst.get(12)
print bst.get(20)
bst.delete(12)
bst.delete(2)
print
for i in bst:
print i
