def test_delete_head_only():
"""Test deleteing a one node head."""
from bst import BST
b = BST([20])
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
def main():
tree = BST()
tree.read_File('input.txt')
tree.print_tree()
tree.delete(19)
print('')
tree.print_tree()
def test_delete_one_item():
from bst import BST
bst = BST()
bst.insert(42)
bst.delete(42)
assert not bst._search(42)
assert not bst.contains(42)
def test_delete_no_children():
"""delete(self, val) should remove val from the tree if present,
if not present it should do nothing. Return None in all cases"""
bintree = BST()
with pytest.raises(TypeError):
bintree.delete() # 1 value required
bintree.insert(5)
bintree.insert(3)
bintree.insert(7)
bintree.insert(2)
bintree.insert(4)
bintree.insert(1)
bintree.insert(9)
bintree.insert(10)
# 5
# / \
# 3 7
# /\ \
# 2 4 9
# | |
# 1 10
assert bintree.size() == 8
assert bintree.delete(-1) is None
assert bintree.size() == 8
assert bintree.delete(4) is None
assert bintree.size() == 7
assert not bintree.leftchild.rightchild # 4 is gone
assert bintree.delete(10) is None
assert bintree.size() == 6
assert not bintree.rightchild.rightchild.leftchild # 9 is a leaf
assert not bintree.rightchild.rightchild.rightchild
def test_delete_case_1(self):
print("Running test_delete_case_1")
h = BST([50, 30, 70, 20, 40, 60, 80])
h.delete(20)
self.check_multiline(str(h),
[["50"], ["30", "70"], ["_", "40", "60", "80"],
["_", "_", "_", "_", "_", "_"],
["30", "40", "50", "60", "70", "80"]])
def test_delete_node_with_child():
"""Test that nodes are rearranged after delete."""
a = BST([5, 4, 6, 3, 4.5, 4.6, 7, 5.5])
a.delete(4.5)
b = a.bft()
result = []
for i in range(7):
result.append(next(b))
assert result == [5, 4, 6, 3, 4.6, 5.5, 7]
def test_delete_head_one_right_child():
"""Test deleting a head with one right child."""
from bst import BST
b = BST([20])
b.insert(22)
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
assert b.top.value == 22
def test_simple_delete_4(self): # XX
print("Running test_simple_delete_4")
h = BST([6, 4, 5, 10])
self.check_multiline(str(h), [["6"], ["4", "10"], ["_", "5", "_", "_"],
["_", "_"], ["4", "5", "6", "10"]])
n = h.delete(4)
self.assertEqual(h.in_order_traversal(), [5, 6, 10])
self.assertTrue(n)
n_2 = h.delete(4)
self.assertFalse(n_2)
def test_delete_middle_of_tree():
t = BST()
t.insert(3)
t.insert(2)
t.insert(5)
t.insert(1)
t.insert(4)
t.insert(6)
t.insert(7)
t.delete(5)
assert list(t.pre_order()) == [3, 2, 1, 6, 4, 7]
def test_delete(self):
for j in range(100):
newbst = BST()
target = randint(1, 1000)
for i in range(100):
key = randint(1, 1000)
if key != target:
newbst.insert(key, key)
newbst.insert(target, 1)
self.assertEqual(newbst.search(target).data, 1)
newbst.delete(target)
self.assertEqual(newbst.search(target), None)
def test_delete_head_two_children():
"""Test deleting a head with two children."""
from bst import BST
b = BST([20])
b.insert(18)
b.insert(22)
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
assert b.top.value == 22
assert b.top.left.value == 18
assert b.top.right is None
def test_delete_multiple(self):
tree = BST()
tree.insert(2, 'b')
tree.insert(1, 'a')
tree.insert(3, 'c')
tree.delete(1)
self.assertEqual(tree.search(1), None)
self.assertEqual(tree.left, None)
self.assertNotEqual(tree.right, None)
tree.insert(1, 'a')
self.assertEqual(tree.left.key, 1)
self.assertEqual(tree.right.key, 3)
tree.delete(2)
self.assertEqual(tree.search(2), None)
def test_delete_connections(self):
print("Running test_delete_connections")
h = BST([20, 10, 25, 5, 18, 13, 15])
self.check_multiline(str(h),
[["20"], ["10", "25"], ["5", "18", "_", "_"],
["_", "_", "13", "_"], ['_', '15'], ['_', '_'],
["5", "10", "13", "15", "18", "20", "25"]])
h.delete(10)
self.check_multiline(str(h),
[["20"], ["13", "25"], ["5", "18", "_", "_"],
["_", "_", "15", "_"], ['_', '_'],
["5", "13", "15", "18", "20", "25"]])
# Start checking all connections
root = h.get_root()
self.assertEqual(root.get_key(), 20)
self.assertEqual(root.get_parent(), None)
self.assertEqual(root.get_left_child().get_key(), 13)
self.assertEqual(root.get_right_child().get_key(), 25)
# Check Left = 13
node_13 = root.get_left_child()
self.assertEqual(node_13.get_key(), 13)
self.assertEqual(node_13.get_parent().get_key(), 20)
self.assertEqual(node_13.get_left_child().get_key(), 5)
self.assertEqual(node_13.get_right_child().get_key(), 18)
# Check Right = 25
node_25 = root.get_right_child()
self.assertEqual(node_25.get_key(), 25)
self.assertEqual(node_25.get_parent().get_key(), 20)
self.assertEqual(node_25.get_left_child(), None)
self.assertEqual(node_25.get_right_child(), None)
# Check Left Left = 5
node_5 = node_13.get_left_child()
self.assertEqual(node_5.get_key(), 5)
self.assertEqual(node_5.get_parent().get_key(), 13)
self.assertEqual(node_5.get_left_child(), None)
self.assertEqual(node_5.get_right_child(), None)
# Check Left Right = 18
node_18 = node_13.get_right_child()
self.assertEqual(node_18.get_key(), 18)
self.assertEqual(node_18.get_parent().get_key(), 13)
self.assertEqual(node_18.get_left_child().get_key(), 15)
self.assertEqual(node_18.get_right_child(), None)
# Check Left Right Left = 15
node_15 = node_18.get_left_child()
self.assertEqual(node_15.get_key(), 15)
self.assertEqual(node_15.get_parent().get_key(), 18)
self.assertEqual(node_15.get_left_child(), None)
self.assertEqual(node_15.get_right_child(), None)
def delete(self, key):
"""Remove the Node object containing the key if the key exists in
the AVL using the BST delete operation. In addition, it ensures that
the AVL tree is still balanced after this operation is performed.
Return the node that actually got removed from the AVL, which might
be successor of the removed key."""
# Delete a key from the tree
BST.delete(self, key)
node = BST.search(self, key)
root = BST.get_root(self)
# Update balance and fix balance (rotate tree) if necessary
self.update_balance(node)
self.fix_balance(root)
def testDelateLastNode(self):
tree2 = BST()
tree2.insert(1)
deleted = tree2.delete(1)
self.assertEqual(1, deleted.key)
tree2.check_ri()
tree2.insert(2)
tree2.check_ri()
def test_delete_random(self):
tree = BST()
numbers = list(range(10000))
inserted = []
for v in range(1000):
k = choice(numbers)
tree.insert(k, v)
inserted.append(k)
numbers.remove(k)
for v in range(999):
k = choice(inserted)
tree.delete(k)
inserted.remove(k)
self.assertEqual(tree.search(k), None)
self.assertEqual(tree.isBST(), True)
for k in inserted:
self.assertNotEqual(tree.search(k), None)
def test_delete_one_child():
"""delete(self, val) should remove val from the tree if present,
if not present it should do nothing. Return None in all cases"""
bintree = BST()
bintree.insert(5)
bintree.insert(3)
bintree.insert(7)
bintree.insert(2)
bintree.insert(4)
bintree.insert(1)
bintree.insert(9)
bintree.insert(10)
# 5
# / \
# 3 7
# /\ \
# 2 4 9
# | |
# 1 10
assert bintree.size() == 8
assert bintree.delete(7) is None
# 5
# / \
# 3 9
# /\ \
# 2 4 10
# |
# 1
assert bintree.size() == 7
assert not bintree.contains(7)
assert bintree.contains(9)
assert bintree.contains(10)
assert bintree.balance() == 1
assert bintree.delete(2) is None
# 5
# / \
# 3 9
# /\ \
# 1 4 10
assert bintree.size() == 6
assert not bintree.contains(2)
assert bintree.contains(1)
assert bintree.leftchild.leftchild.value == 1
assert bintree.balance() == 0
def test_delete_two_children():
bintree = BST()
bintree.insert(5)
bintree.insert(3)
bintree.insert(7)
bintree.insert(6)
bintree.insert(2)
bintree.insert(4)
bintree.insert(1)
bintree.insert(9)
bintree.insert(10)
# 5
# / \
# 3 7
# /\ / \
# 2 4 6 9
# | |
# 1 10
assert bintree.size() == 9
assert bintree.leftchild.balance() == 1 # The subtree at 3 is left-heavy
assert bintree.delete(3) is None # So this will delete left-style
# 5
# / \
# 2 7
# /\ / \
# 1 4 6 9
# |
# 10
assert bintree.size() == 8
assert bintree.leftchild.value == 2
assert bintree.balance() == -1 # The whole tree is now right-heavy
assert bintree.delete(5) is None # So deleting the top will go right-style
# 6
# / \
# 2 7
# /\ \
# 1 4 9
# |
# 10
assert bintree.value == 6
assert bintree.size() == 7
assert bintree.rightchild.value == 7
assert bintree.balance() == -1
def test_simple_delete_3(self): # XX
print("Running test_simple_delete_3")
h = BST([6, 5, 10])
self.check_multiline(
str(h),
[["6"], ["5", "10"], ["_", "_", "_", "_"], ["5", "6", "10"]])
n = h.delete(6)
self.check_multiline(str(h),
[["10"], ["5", "_"], ["_", "_"], ["5", "10"]])
self.assertTrue(n)
def from_string_to_graphvz(tree_type, tree_string):
if tree_type == "bst":
tree = BST()
elif tree_type == "avl":
tree = AVL()
elif tree_type == "rbt":
tree = RedBlackTree()
else:
raise Exception
try:
op_list = json.loads(tree_string)
except Exception:
op_list = []
for op in op_list:
if op[0] == "insert":
tree.insert(int(op[1]))
elif op[0] == "delete":
tree.delete(int(op[1]))
dot = from_tree_to_file(tree.root)
return dot.source
def test_delete():
tree = BST()
for n in [0, 2, -2, 1, -1, 3, -3]:
tree.insert(n)
for n in [-3, -2, -1, 0, 1, 2, 3]:
assert tree.contains(n)
tree.delete(-3)
assert tree.contains(-3) is False
tree.delete(-2)
assert tree.contains(-2) is False
for n in [-1, 0, 1, 2, 3]:
assert tree.contains(n)
assert tree.size() == 5
tree.insert(5)
tree.insert(4)
tree.insert(6)
tree.delete(3)
assert tree.size() == 7
for i in [-1, 0, 1, 2, 4, 5, 6]:
assert tree.contains(i)
# coding=utf-8
from bst import Node
from bst import BST
from bst import BinarySearchTree
if __name__ == '__main__':
tree = BST()
values = [8, 5, 15, 3, 7, 12, 18, 2, 4, 6, 11, 14, 17, 19, 13]
for v in values:
tree.insert(v)
tree.inorder_traversal()
tree.search(13)
tree.search(7)
tree.delete(13)
tree.inorder_traversal()
tree.search(11)
tree.delete(5)
tree.inorder_traversal()
tree.search(3)
tree = BinarySearchTree()
for v in values:
tree.insert(v)
res = tree.traverse()
print('->'.join([str(d) for d in res]))
class TestBST(TestCase):
def setUp(self):
self.bst = BST()
self.node_5 = Node(-5)
self.node_4 = Node(-4)
self.node_3 = Node(-3)
self.node_2 = Node(-2)
self.node_1 = Node(-1)
self.node0 = Node(0)
self.node1 = Node(1)
self.node2 = Node(2)
self.node3 = Node(3)
self.node4 = Node(4)
self.node5 = Node(5)
self.mytree = BST()
self.mytree.insert(5)
self.mytree.insert(2)
self.mytree.insert(3)
self.mytree.insert(1)
self.mytree.insert(4)
self.mytree.insert(0)
self.mytree.insert(2.5)
self.mytree.insert(8)
self.mytree.insert(9)
self.mytree.insert(6)
self.mytree.insert(4.5)
def test_insert(self):
assert (self.bst.root == None)
self.bst.insert(self.node0.data)
assert (self.bst.root.data == self.node0.data)
self.bst.insert(self.node3.data)
assert (self.bst.root.right.data == self.node3.data)
self.bst.insert(self.node5.data)
assert (self.bst.root.right.data == self.node5.data)
self.bst.insert(self.node4.data)
assert (self.bst.root.right.left.data == self.node4.data)
self.bst.insert(self.node2.data)
assert (self.bst.root.left.right.data == self.node2.data)
self.bst.insert(self.node1.data)
assert (self.bst.root.left.data == self.node1.data)
def test_delete(self):
assert (self.mytree.exists(0) == True)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 8, 9])
self.mytree.delete(0)
assert (self.mytree.exists(0) == False)
assert (self.mytree.to_list_from_root() == [1, 2, 2.5, 3, 4, 4.5, 5, 6, 8, 9])
assert (self.mytree.exists(4.5) == True)
self.mytree.delete(4.5)
assert (self.mytree.exists(4.5) == False)
assert (self.mytree.to_list_from_root() == [1, 2, 2.5, 3, 4, 5, 6, 8, 9])
self.mytree.insert(0)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 5, 6, 8, 9])
assert (self.mytree.exists(1) == True)
self.mytree.delete(1)
assert (self.mytree.exists(1) == False)
assert (self.mytree.exists(0) == True)
assert (self.mytree.to_list_from_root() == [0, 2, 2.5, 3, 4, 5, 6, 8, 9])
# RESET
self.setUp()
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 8, 9])
self.mytree.delete(5)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 4.5, 6, 8, 9])
self.mytree.delete(6)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 4.5, 8, 9])
self.mytree.delete(4.5)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 8, 9])
self.mytree.delete(4)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 8, 9])
self.mytree.delete(3)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 8, 9])
self.mytree.delete(2.5)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 8, 9])
self.mytree.delete(8)
assert (self.mytree.to_list_from_root() == [0, 1, 2, 9])
self.mytree.delete(2)
assert (self.mytree.to_list_from_root() == [0, 1, 9])
self.mytree.delete(1)
assert (self.mytree.to_list_from_root() == [0, 9])
self.mytree.delete(0)
assert (self.mytree.to_list_from_root() == [9])
# RESET
self.setUp()
self.mytree.delete(4.5)
self.mytree.delete(4)
self.mytree.delete(2.5)
self.mytree.delete(3)
self.mytree.delete(0)
self.mytree.delete(1)
self.mytree.delete(2)
self.mytree.delete(6)
assert (self.mytree.to_list_from_root() == [5, 8, 9])
self.mytree.delete(5)
assert (self.mytree.to_list_from_root() == [8, 9])
self.mytree.delete(8)
assert (self.mytree.to_list_from_root() == [9])
def test_exists(self):
assert (self.mytree.exists(5) == True)
assert (self.mytree.exists(4) == True)
assert (self.mytree.exists(3) == True)
assert (self.mytree.exists(2) == True)
assert (self.mytree.exists(1) == True)
assert (self.mytree.exists(0) == True)
assert (self.mytree.exists(9) == True)
assert (self.mytree.exists(80) == False)
assert (self.mytree.exists(-5) == False)
assert (self.mytree.exists(-10) == False)
assert (self.mytree.exists(230) == False)
assert (self.mytree.exists(340) == False)
def test_to_list_from_root(self):
assert (self.bst.to_list_from_root() == [])
self.bst.insert(5)
self.bst.insert(2)
self.bst.insert(8)
self.bst.insert(6)
self.bst.insert(1)
self.bst.insert(3)
self.bst.insert(0)
self.bst.insert(4)
self.bst.insert(9)
assert (self.bst.to_list_from_root() == [0, 1, 2, 3, 4, 5, 6, 8, 9])
assert (self.mytree.to_list_from_root() == [0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 8, 9])
def test_next(self): # [0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 8, 9]
assert (self.mytree.next(-1).data == 0)
assert (self.mytree.next(0).data == 1)
assert (self.mytree.next(1).data == 2)
assert (self.mytree.next(2).data == 2.5)
assert (self.mytree.next(2.5).data == 3)
assert (self.mytree.next(3).data == 4)
assert (self.mytree.next(4).data == 4.5)
assert (self.mytree.next(4.5).data == 5)
assert (self.mytree.next(5).data == 6)
assert (self.mytree.next(6).data == 8)
assert (self.mytree.next(8).data == 9)
assert (self.mytree.next(9) is None)
def test_prev(self):
assert (self.mytree.prev(0) is None)
assert (self.mytree.prev(1).data == 0)
assert (self.mytree.prev(2).data == 1)
assert (self.mytree.prev(2.5).data == 2)
assert (self.mytree.prev(3).data == 2.5)
assert (self.mytree.prev(4).data == 3)
assert (self.mytree.prev(4.5).data == 4)
assert (self.mytree.prev(5).data == 4.5)
assert (self.mytree.prev(6).data == 5)
assert (self.mytree.prev(8).data == 6)
assert (self.mytree.prev(9).data == 8)
assert (self.mytree.prev(10).data == 9)
def test_delete_root_small_bst():
"""Delete root, and replace it with replacement."""
bst = BST([10, 5, 20])
bst.delete(10)
assert not bst.contains(10)
def test_delete_node_not_in_bst():
"""Return error message when node not in BST."""
bst = BST([10, 5, 20])
assert bst.delete(29) is None
def test_delete_leaf_node_right():
"""BST no longer has pointer to deleted leaf node."""
bst = BST([10, 5, 20])
bst.delete(20)
assert not bst.contains(20)
def test_delete_root():
"""Self.root is none if it is only node and deleted."""
bst = BST([5])
bst.delete(5)
assert bst.root is None
def test_delete_empty():
"""Return error message when BST is empty."""
bst = BST()
with pytest.raises(ValueError) as message:
bst.delete(5)
assert "Val not in BST" in str(message)
def test_delete_only_node_in_bst():
"""Test deleting the only node in a tree."""
a = BST([9])
a.delete(9)
assert a.size() == 1
def test_delete_non_existent_node():
"""Test for value error when trying to delete nonexist node."""
a = BST([9, 8, 5])
with pytest.raises(ValueError):
a.delete(99)
# t.put("aa")
# t.put("aaa")
# t.put("zzz")
# t.put("hi")
# t.put(u"salam")
# t.put("هههه")
# t.put(u"الف")
# t.put("aab")
# t.put("salav")
# t.put("mamas")
# t.put("mahdi2")
for i, j in t.sorted_by_count():
print(i, j)
print(t.root.value)
t.delete("s1")
print(t.root.value)
t.plot()
# print()
#
# for i,j in t:
# print(i,j)
# def p(node):
# p=node.parent.value if node.parent else None
# l=node.left.value if node.left else None
# r=node.right.value if node.right else None
#
# print(node.value, r, l , p)
def delete(self, key):
deleted_node = BST.delete(self, key)
self._rebalance(deleted_node)
return deleted_node
from bst import BST
if __name__ == '__main__':
t = BST() # 이진탐색트리 객체 t 생성
t.put(500, 'apple')
t.put(600, 'banana')
t.put(200, 'melon')
t.put(100, 'orange')
t.put(400, 'lime')
t.put(250, 'kiwi')
t.put(150, 'grape')
t.put(800, 'peach')
t.put(700, 'cherry')
t.put(50, 'pear')
t.put(350, 'lemon')
t.put(10, 'plum')
print('전위순회:\t', end='')
t.preorder(t.root)
print('\n중위순회:\t', end='')
t.inorder(t.root)
print('\n250: ',t.get(250))
t.delete(200)
print('200 삭제 후:')
print('전위순회:\t', end='')
t.preorder(t.root)
print('\n중위순회:\t', end='')
t.inorder(t.root)
class TestBST(unittest.TestCase):
def setUp(self) -> None:
self.tree = BST()
def test_init(self):
self.assertIsNone(self.tree.root)
def test_insert_0(self):
self.assertTrue(self.tree.insert(1))
self.assertEqual(1, self.tree.root.val)
self.assertIsNone(self.tree.root.left)
self.assertIsNone(self.tree.root.right)
def test_insert_1(self):
self.assertTrue(self.tree.insert(4))
self.assertTrue(self.tree.insert(0))
self.assertTrue(self.tree.insert(6))
self.assertTrue(self.tree.insert(5))
self.assertTrue(self.tree.insert(8))
self.assertTrue(self.tree.insert(7))
self.assertFalse(self.tree.insert(4))
self.assertFalse(self.tree.insert(0))
self.assertFalse(self.tree.insert(6))
self.assertFalse(self.tree.insert(5))
self.assertFalse(self.tree.insert(8))
self.assertFalse(self.tree.insert(7))
self.assertEqual(self.tree.pre_order(),
"4(0(N,N),6(5(N,N),8(7(N,N),N)))")
def test_insert_2(self):
self.assertTrue(self.tree.insert(5))
self.assertTrue(self.tree.insert(3))
self.assertTrue(self.tree.insert(6))
self.assertTrue(self.tree.insert(1))
self.assertTrue(self.tree.insert(4))
self.assertTrue(self.tree.insert(8))
self.assertEqual(self.tree.pre_order(),
"5(3(1(N,N),4(N,N)),6(N,8(N,N)))")
def test_insert_3(self):
self.assertTrue(self.tree.insert(8))
self.assertTrue(self.tree.insert(7))
self.assertTrue(self.tree.insert(6))
self.assertTrue(self.tree.insert(5))
self.assertTrue(self.tree.insert(4))
self.assertTrue(self.tree.insert(3))
self.assertTrue(self.tree.insert(2))
self.assertTrue(self.tree.insert(1))
self.assertEqual(self.tree.pre_order(),
"8(7(6(5(4(3(2(1(N,N),N),N),N),N),N),N),N)")
def test_update_0(self):
self.tree.insert(1, a=1, b=2)
self.assertEqual(self.tree.pre_order(True), "1{'a': 1, 'b': 2}(N,N)")
self.tree.update(1, a=3, b=2)
self.assertEqual(self.tree.pre_order(True), "1{'a': 3, 'b': 2}(N,N)")
def test_update_1(self):
for i in [5, 3, 6, 1, 4, 8]:
self.tree.insert(i)
self.assertEqual(self.tree.pre_order(True),
"5{}(3{}(1{}(N,N),4{}(N,N)),6{}(N,8{}(N,N)))")
self.tree.update(8, a=3, b=5)
self.tree.update(3, a=7, b=9)
self.tree.update(5, a=10, b=11)
self.assertEqual(
self.tree.pre_order(True),
"5{'a': 10, 'b': 11}(3{'a': 7, 'b': 9}(1{}(N,N),4{}(N,N)),"
"6{}(N,8{'a': 3, 'b': 5}(N,N)))")
def test_update_2(self):
for i in [8, 7, 6, 5, 4, 3, 2, 1]:
self.tree.insert(i)
self.assertEqual(
self.tree.pre_order(True),
"8{}(7{}(6{}(5{}(4{}(3{}(2{}(1{}(N,N),N),N),N),N),N),N),N)")
self.tree.update(8, a=3, b=5)
self.tree.update(3, a=7, b=9)
self.tree.update(5, a=10, b=11)
self.tree.update(10, a=10, b=11)
self.tree.update(11, a=10, b=11)
self.assertEqual(
self.tree.pre_order(True),
"8{'a': 3, 'b': 5}(7{}(6{}(5{'a': 10, 'b': 11}"
"(4{}(3{'a': 7, 'b': 9}(2{}(1{}(N,N),N),N),N),N),N),N),N)")
def test_delete_0(self):
self.tree.insert(1)
self.assertFalse(self.tree.delete(3)[0])
self.assertTrue(self.tree.delete(1)[0])
self.assertEqual(self.tree.pre_order(), "N")
self.tree.insert(1)
self.tree.insert(2)
self.tree.insert(3)
self.assertEqual(self.tree.pre_order(), "1(N,2(N,3(N,N)))")
def test_delete_1(self):
for i in [5, 3, 7, 2, 4, 6, 8]:
self.tree.insert(i)
self.assertEqual(self.tree.pre_order(),
"5(3(2(N,N),4(N,N)),7(6(N,N),8(N,N)))")
self.assertTrue(self.tree.delete(2)[0])
self.assertTrue(self.tree.delete(8)[0])
self.assertFalse(self.tree.delete(8)[0])
self.assertFalse(self.tree.delete(2)[0])
self.assertEqual(self.tree.pre_order(), "5(3(N,4(N,N)),7(6(N,N),N))")
self.assertTrue(self.tree.delete(7)[0])
self.assertTrue(self.tree.delete(3)[0])
self.assertFalse(self.tree.delete(17)[0])
self.assertFalse(self.tree.delete(13)[0])
self.assertEqual(self.tree.pre_order(), "5(4(N,N),6(N,N))")
self.tree.delete(5)
self.assertEqual(self.tree.pre_order(), "6(4(N,N),N)")
self.tree.delete(6)
self.assertEqual(self.tree.pre_order(), "4(N,N)")
self.tree.delete(4)
self.assertEqual(self.tree.pre_order(), "N")
self.assertIsNone(self.tree.root)
def test_delete_2(self):
for i in [5, 3, 7, 2, 4, 6, 8]:
self.tree.insert(i)
self.assertEqual(self.tree.pre_order(),
"5(3(2(N,N),4(N,N)),7(6(N,N),8(N,N)))")
self.tree.delete(3)
self.assertEqual(self.tree.pre_order(),
"5(4(2(N,N),N),7(6(N,N),8(N,N)))")
self.tree.delete(5)
self.assertEqual(self.tree.pre_order(), "6(4(2(N,N),N),7(N,8(N,N)))")
self.assertTrue(self.tree.delete(7)[0])
self.assertTrue(self.tree.delete(8)[0])
self.assertEqual(self.tree.pre_order(), "6(4(2(N,N),N),N)")
self.assertTrue(self.tree.delete(6)[0])
self.assertTrue(self.tree.delete(4)[0])
self.assertTrue(self.tree.delete(2)[0])
self.assertEqual(self.tree.pre_order(), "N")
self.tree.insert(1)
self.tree.insert(2)
self.tree.insert(3)
self.assertEqual(self.tree.pre_order(), "1(N,2(N,3(N,N)))")
self.assertTrue(self.tree.delete(2)[0])
self.assertTrue(self.tree.delete(3)[0])
self.assertTrue(self.tree.delete(1)[0])
self.assertEqual(self.tree.pre_order(), "N")
self.tree.insert(3)
self.tree.insert(2)
self.tree.insert(1)
self.assertEqual(self.tree.pre_order(), "3(2(1(N,N),N),N)")
self.assertTrue(self.tree.delete(2)[0])
self.assertTrue(self.tree.delete(3)[0])
self.assertTrue(self.tree.delete(1)[0])
def test_all(self):
arr = [i for i in range(1000)]
shuffle(arr)
for i in arr:
self.tree.insert(i)
for i in range(1000):
self.assertTrue(self.tree.search(i)[0])
self.tree.update(i, v=i, vv=i * 10)
for i in range(1000):
self.assertEqual(self.tree.search(i)[1], {"v": i, "vv": i * 10})
for i in range(1000, 2000):
self.assertEqual(self.tree.update(i), False)
self.assertEqual(self.tree.search(i), (False, {}))
for i in range(999, 0, -1):
self.assertEqual(self.tree.delete(i)[1], {"v": i, "vv": i * 10})
def test_height_insert_delete_2(self):
print("Running test_height_insert_delete_2")
h = BST()
h.insert(5)
self.assertEqual(h.get_root().get_height(), 0)
h.insert(2)
self.assertEqual(h.get_root().get_height(), 1)
self.assertEqual(h.get_root().get_left_child().get_height(), 0)
h.insert(8)
self.assertEqual(h.get_root().get_height(), 1)
self.assertEqual(h.get_root().get_left_child().get_height(), 0)
self.assertEqual(h.get_root().get_right_child().get_height(), 0)
h.insert(1)
self.assertEqual(h.get_root().get_height(), 2)
self.assertEqual(h.get_root().get_right_child().get_height(), 0)
self.assertEqual(h.get_root().get_left_child().get_height(), 1)
self.assertEqual(
h.get_root().get_left_child().get_left_child().get_height(), 0)
h.insert(3)
self.assertEqual(h.get_root().get_height(), 2)
self.assertEqual(h.get_root().get_right_child().get_height(), 0)
self.assertEqual(h.get_root().get_left_child().get_height(), 1)
self.assertEqual(
h.get_root().get_left_child().get_left_child().get_height(), 0)
self.assertEqual(
h.get_root().get_left_child().get_right_child().get_height(), 0)
h.insert(9)
self.assertEqual(h.get_root().get_height(), 2)
self.assertEqual(h.get_root().get_right_child().get_height(), 1)
self.assertEqual(
h.get_root().get_right_child().get_right_child().get_height(), 0)
self.assertEqual(h.get_root().get_left_child().get_height(), 1)
self.assertEqual(
h.get_root().get_left_child().get_left_child().get_height(), 0)
self.assertEqual(
h.get_root().get_left_child().get_right_child().get_height(), 0)
h.insert(10)
self.assertEqual(h.get_root().get_height(), 3)
self.assertEqual(h.get_root().get_right_child().get_height(), 2)
self.assertEqual(
h.get_root().get_right_child().get_right_child().get_height(), 1)
self.assertEqual(
h.get_root().get_right_child().get_right_child().get_right_child().
get_height(), 0)
self.assertEqual(h.get_root().get_left_child().get_height(), 1)
self.assertEqual(
h.get_root().get_left_child().get_left_child().get_height(), 0)
self.assertEqual(
h.get_root().get_left_child().get_right_child().get_height(), 0)
self.check_multiline(str(h),
[["5"], ["2", "8"], ["1", "3", "_", "9"],
["_", "_", "_", "_", "_", "10"], ["_", "_"],
["1", "2", "3", "5", "8", "9", "10"]])
h.delete(1)
h.delete(3)
self.assertEqual(h.get_root().get_height(), 3)
self.assertEqual(h.get_root().get_right_child().get_height(), 2)
self.assertEqual(
h.get_root().get_right_child().get_right_child().get_height(), 1)
self.assertEqual(
h.get_root().get_right_child().get_right_child().get_right_child().
get_height(), 0)
self.assertEqual(h.get_root().get_left_child().get_height(), 0)
self.check_multiline(
str(h), [["5"], ["2", "8"], ["_", "_", "_", "9"], ["_", "10"],
["_", "_"], ["2", "5", "8", "9", "10"]])
