def parentless_rb_insert(T, z): path_length = _get_path_length_from_root_to_leaf(T, z) S = Array.indexed(1, path_length + 1) S.top = 0 y = T.nil push(S, y) x = T.root while x is not T.nil: y = x push(S, y) if z.key < x.key: x = x.left else: x = x.right if y is T.nil: T.root = z else: if z.key < y.key: y.left = z else: y.right = z z.left = T.nil z.right = T.nil z.color = Red parentless_rb_insert_fixup(T, S, z)
def stack_dequeue(S): if stack_empty(S): raise RuntimeError('underflow') S_ = Array.indexed(1, S.length) S_.top = 0 while not stack_empty(S): push(S_, pop(S)) x = pop(S_) while not stack_empty(S_): push(S, pop(S_)) return x
def test_push(self): size = 10 stack, _ = get_random_array(min_size=size, max_size=size) stack.top = random.randint(0, size - 1) x = random.randint(0, 999) expected_keys = get_stack_elements(stack) + [x] push(stack, x) actual_keys = get_stack_elements(stack) assert_that(actual_keys, is_(equal_to(expected_keys)))
def iterative_inorder_tree_walk(T): S = Array.indexed(1, _get_tree_size(T.root)) S.top = 0 x = T.root while not stack_empty(S) or x is not None: if x is not None: push(S, x) x = x.left else: x = pop(S) print(x.key) x = x.right
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 persistent_rb_insert(T, z): path_length = _get_path_length_from_root_to_node(T, z) S = Array.indexed(1, path_length + 1) S.top = 0 y = T.nil x = T.root T_ = RedBlackTree(sentinel=T.nil) y_ = T_.nil push(S, y_) while x is not T.nil: y = x x_ = rb.ParentlessNode.clone(x) if y_ is T_.nil: T_.root = x_ else: if x is y_.left: y_.left = x_ else: y_.right = x_ y_ = x_ push(S, y_) if z.key < x.key: x = x.left else: x = x.right if y is T.nil: T_.root = z else: if z.key < y.key: y_.left = z else: y_.right = z z.left = z.right = T.nil z.color = Red _persistent_rb_insert_fixup(T_, S, z) return T_
def effective_stack_dequeue(S1, S2): if stack_empty(S2): while not stack_empty(S1): push(S2, pop(S1)) return pop(S2)
def effective_stack_enqueue(S1, x): push(S1, x)
def huge_array_insert(T, S, x): push(S, x) T[x.key] = S.top
def persistent_rb_delete(T, z): T_ = RedBlackTree() T_.root = T_.nil = T.nil if z.left is T.nil or z.right is T.nil: y = z else: y = rb_successor(z, T.nil) path_length = _get_path_length_from_root_to_node(T, y) S = Array.indexed(1, path_length + 1) S.top = 0 p = T.root r = T.nil p_ = r_ = T_.nil push(S, p_) z_ = T.nil while p is not y: p_ = rb.ParentlessNode.clone(p) push(S, p_) if p is z: z_ = p_ if r_ is T_.nil: T_.root = p_ else: if p is r_.left: r_.left = p_ else: r_.right = p_ r = p r_ = p_ if y.key < p.key: p = p.left else: p = p.right if y.left is not T.nil: x = y.left else: x = y.right if y.color == Black: if x is not T.nil: x_ = rb.ParentlessNode.clone(x) else: x_ = T.nil if y is T.root: T_.root = x_ else: if y is r.left: p_.left = x_ else: p_.right = x_ if y is not z: z_.key = y.key z_.data = y.data persistent_rb_delete_fixup(T_, S, x_) else: if y is r.left: p_.left = x else: p_.right = x if y is not z: z_.key = y.key z_.data = y.data return T_
def stack_enqueue(S, x): push(S, x)