def singly_linked_list_reverse(L):
L_ = List()
L_.head = None
while L.head is not None:
x = L.head
singly_linked_list_delete(L, L.head)
singly_linked_list_insert(L_, x)
L.head = L_.head
def testGraphMixedSID():
# Options and parameters
size = 20
bm_start = 0
bm_length = 3
bm_interval = 5
filename = "plots/testGraphMixedSID.tex"
# Generate operation sequence
ops = generateRandomOperationSequence(size)
# Initialize data structures
bst = BinarySearchTree()
stromberg_treap = StrombergTreap()
jenks_treap = JenksTreap()
pyskiplist = PySkipList()
redblacktree = RedBlackTree()
sortedlist = SortedList()
builtinlist = List()
# Create functions list
searches = \
[
bst.search,
stromberg_treap.get_key,
jenks_treap.__getitem__,
pyskiplist.search,
redblacktree.find_node,
sortedlist.search,
builtinlist.search,
]
inserts = \
[
bst.insert,
stromberg_treap.insert,
jenks_treap.insert,
pyskiplist.insert,
redblacktree.add,
sortedlist.add,
builtinlist.add
]
deletes = \
[
bst.delete,
stromberg_treap.remove,
jenks_treap.__delitem__,
pyskiplist.remove,
redblacktree.remove,
sortedlist.remove,
builtinlist.remove
]
# Run the graph
graphMixedSID(filename, searches, inserts, deletes, ops, bm_start,
bm_length, bm_interval)
def circular_lists_union(S1, S2):
S = List()
if S1.head is not None and S2.head is not None:
x = S1.head.next
S1.head.next = S2.head.next
S2.head.next = x
if S1.head is not None:
S.head = S1.head
else:
S.head = S2.head
S1.head = S2.head = None
return S
def get_random_sorted_singly_linked_list():
size = random.randint(1, 5)
keys = sorted([random.randint(0, 999) for _ in range(size)])
nodes = [SNode(key) for key in keys]
list_ = List()
prev_node = list_.head
for node in nodes:
if prev_node is None:
list_.head = node
else:
prev_node.next = node
prev_node = node
return list_, nodes, keys
def get_random_singly_linked_list(min_size=1, max_size=20, max_value=999):
size = random.randint(min_size, max_size)
keys = [random.randint(0, max_value) for _ in range(size)]
nodes = [SNode(key) for key in keys]
list_ = List()
prev_node = list_.head
for node in nodes:
if prev_node is None:
list_.head = node
else:
prev_node.next = node
prev_node = node
return list_, nodes, keys
def josephus_simulate(n, m):
L = List()
singly_linked_list_insert(L, SNode(n))
x = L.head
for i in rbetween(n - 1, 1):
singly_linked_list_insert(L, SNode(i))
x.next = L.head
for i in between(1, n):
for j in between(1, m):
x = x.next
print(x.next.key)
if L.head is x.next:
L.head = x.next.next
x.next = x.next.next
def get_random_doubly_linked_list_with_sentinel(min_size=1, max_size=20, max_value=999):
size = random.randint(min_size, max_size)
keys = [random.randint(0, max_value) for _ in range(size)]
nodes = [Node(key) for key in keys]
list_ = List()
list_.nil = sentinel = Node(None)
sentinel.prev = sentinel.next = sentinel
prev_node = sentinel
for node in nodes:
prev_node.next = node
node.prev = prev_node
node.next = sentinel
sentinel.prev = node
prev_node = node
return list_, nodes, keys
def merge_sorted_lists(lists):
k = lists.length
Q = Array.indexed(1, k)
Q.heap_size = 0
for list_ in lists:
if list_.head is not None:
x = list_.head
list_.head = list_.head.next
x.next = None
_min_heap_insert_pair(Q, (x, list_))
merged_list = List()
tail = None
while Q.heap_size > 0:
element, list_ = _heap_extract_min_pair(Q)
if merged_list.head is None:
tail = merged_list.head = element
else:
tail.next = element
tail = tail.next
if list_.head is not None:
_min_heap_insert_pair(Q, (list_.head, list_))
list_.head = list_.head.next
return merged_list
def sorted_list_make_min_heap():
return List()
def list_make_min_heap():
heap = List()
heap.tail = None
return heap