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