def joinable_rb_delete(T, z):
if z.left is None or z.right is None:
y = z
else:
y = rb_successor(z)
if y.left is not None:
x = y.left
else:
x = y.right
if x is None:
x = Node(None) # create a dummy node that will mimic sentinel
x.p = y.p
if y.p is None:
T.root = x
else:
if y is y.p.left:
y.p.left = x
else:
y.p.right = x
if y is not z:
z.key = y.key
z.data = y.data
if y.color == Black:
joinable_rb_delete_fixup(T, x)
if x.key is None: # if x is the dummy node replace it with None
if x is T.root:
T.root = None
T.bh = 0
else:
if x is x.p.left:
x.p.left = None
else:
x.p.right = None
return y
def joinable_rb_delete(T, z):
if z.left is None or z.right is None:
y = z
else:
y = rb_successor(z)
if y.left is not None:
x = y.left
else:
x = y.right
if x is None:
x = Node(None) # create a dummy node that will mimic sentinel
x.p = y.p
if y.p is None:
T.root = x
else:
if y is y.p.left:
y.p.left = x
else:
y.p.right = x
if y is not z:
z.key = y.key
z.data = y.data
if y.color == Black:
joinable_rb_delete_fixup(T, x)
if x.key is None: # if x is the dummy node replace it with None
if x is T.root:
T.root = None
T.bh = 0
else:
if x is x.p.left:
x.p.left = None
else:
x.p.right = None
return y
def test_create_red_black_tree(self):
left = Node(3)
right = Node(20)
root = Node(17, left=left, right=right)
tree = RedBlackTree(root)
assert_that(tree.root, is_(root))
assert_that(root.left, is_(left))
assert_that(root.right, is_(right))
assert_parent_pointers_consistent(tree, sentinel=tree.nil)
def test_get_child_no(self):
node = Node(3)
self.assertEqual(node._get_child_no(), 0)
node._left = Node(1)
self.assertEqual(node._get_child_no(), 1)
node._right = Node(4)
self.assertEqual(node._get_child_no(), 2)
def test_min_gap_tree(self):
_, keys = get_random_unique_array()
tree = RedBlackTree()
tree.nil.min_key = tree.nil.min_gap = math.inf
tree.nil.max_key = -math.inf
for key in keys:
min_gap_insert(tree, Node(key))
nodes = get_binary_tree_nodes(tree, sentinel=tree.nil)
while nodes:
node = random.choice(nodes)
key = node.key
keys.remove(key)
actual_found = min_gap_search(tree, key)
assert_that(actual_found.key, is_(equal_to(key)))
min_gap_delete(tree, node)
actual_found = min_gap_search(tree, key)
assert_that(actual_found, is_(tree.nil))
actual_min_gap = min_gap(tree)
expected_min_gap = get_expected_min_gap(keys)
assert_that(actual_min_gap, is_(equal_to(expected_min_gap)))
nodes = get_binary_tree_nodes(tree, sentinel=tree.nil)
def test_find(self):
node = Node(3)
node.insert(1)
node.insert(0)
node.insert(5)
node = node._parent
self.assertTrue(node.find(0))
self.assertTrue(node.find(5))
self.assertFalse(node.find(10))
def test_get_inorder(self):
node = Node(3)
node.insert(1)
node.insert(5)
self.assertListEqual([(1, NodeColor.RED), (3, NodeColor.BLACK),
(5, NodeColor.RED)], node.get_inorder())
node.insert(6)
self.assertListEqual([(1, NodeColor.BLACK), (3, NodeColor.BLACK),
(5, NodeColor.BLACK), (6, NodeColor.RED)],
node.get_inorder())
def test_rb_parentless_insert(self):
keys = [random.randrange(1000) for _ in range(20)]
tree = RedBlackTree()
for key in keys:
parentless_rb_insert(tree, Node(key))
assert_red_black_tree(tree, sentinel=tree.nil)
actual_keys = get_binary_tree_keys(tree, sentinel=tree.nil)
assert_that(actual_keys, contains_inanyorder(*keys))
def test_rb_insert(self):
_, keys = get_random_array()
tree = RedBlackTree()
for key in keys:
rb_insert(tree, Node(key), sentinel=tree.nil)
assert_red_black_tree(tree, sentinel=tree.nil)
assert_parent_pointers_consistent(tree, sentinel=tree.nil)
actual_keys = get_binary_tree_keys(tree, sentinel=tree.nil)
assert_that(actual_keys, contains_inanyorder(*keys))
def test_joinable_rb_insert(self):
keys = [random.randrange(1000) for _ in range(20)]
tree = RedBlackTree(sentinel=None)
tree.bh = 0
for key in keys:
joinable_rb_insert(tree, Node(key))
assert_red_black_tree(tree)
assert_parent_pointers_consistent(tree)
actual_keys = get_binary_tree_keys(tree)
assert_that(actual_keys, contains_inanyorder(*keys))
actual_black_height = calculate_black_height(tree.root)
assert_that(tree.bh, is_(equal_to(actual_black_height)))
def activity_scheduler(s, f):
n = s.length
A = Array.indexed(1, n)
F = Array(list(rbetween(n, 1)))
F.top = n
B = RedBlackTree()
# events contains triples (a, b, c) where a = 0 if the event is finish of an activity and 1 if it is start,
# b as the activity number, and c as the start time or the finish time
events = [(0, i + 1, finish_time) for i, finish_time in enumerate(f)] + \
[(1, i + 1, start_time) for i, start_time in enumerate(s)]
events.sort(key=lambda e: (e[2], e[0]))
for e in events:
if e[0] == 1:
hall_number = pop(F)
A[e[1]] = hall_number
rb_insert(B, Node(e[1], data=hall_number), sentinel=B.nil)
else:
hall = rb_search(B.root, e[1], sentinel=B.nil)
push(F, hall.data)
rb_delete(B, hall, sentinel=B.nil)
return A
def test_rb_join(self):
tree1, _, keys1 = get_random_red_black_tree(
black_height=random.randint(0, 4),
min_value=0,
max_value=999,
sentinel=None)
tree1.bh = calculate_black_height(tree1.root)
middle_key = random.randint(1000, 1999)
x = Node(middle_key)
tree2, _, keys2 = get_random_red_black_tree(
black_height=random.randint(0, 4),
min_value=2000,
max_value=2999,
sentinel=None)
tree2.bh = calculate_black_height(tree2.root)
actual_joined_tree = rb_join(tree1, x, tree2)
assert_red_black_tree(actual_joined_tree)
actual_keys = get_binary_tree_keys(actual_joined_tree)
assert_that(actual_keys,
contains_inanyorder(*(keys1 + [middle_key] + keys2)))
def test_right_left_case(self):
root = Node(15)
root._color = NodeColor.BLACK
root._left = Node(7)
root._left._color = NodeColor.BLACK
root._left._parent = root
root._right = Node(25)
root._right._color = NodeColor.RED
root._right._parent = root
self.assertListEqual([(7, NodeColor.BLACK), (15, NodeColor.BLACK),
(25, NodeColor.RED)], root.get_inorder())
root.insert(24)
root = root._parent
self.assertListEqual([(7, NodeColor.BLACK), (15, NodeColor.RED),
(24, NodeColor.BLACK), (25, NodeColor.RED)],
root.get_inorder())
def test_str(self):
node = Node(1)
self.assertEqual(str(node), "1B")
node._color = NodeColor.RED
self.assertEqual(str(node), "1R")
def test_insert(self):
node = Node(3)
self.assertFalse(node.insert(3))
self.assertTrue(node.insert(1))
