def merge_sorted_lists():
k = 10
n = 10
min_value = 0
max_value = 30
sorted_lists = generate_sorted_lists(k,n,min_value,max_value)
sorted_list = SingleLinkedList()
heap = MinHeap([], 0)
# fill in the 1st batch
for i, l in sorted_lists.items():
heap.add(IdAndValue(i, l.pop(0)))
while len(sorted_lists) > 0:
item = heap.pop()
sorted_list.append(item.get_value())
list_id = item.get_id()
if list_id in sorted_lists:
value = sorted_lists[list_id].pop(0)
if len(sorted_lists[list_id]) <= 0:
sorted_lists.pop(list_id)
heap.add(IdAndValue(list_id, value))
else:
list_id, list = sorted_lists.items()[0]
heap.add(IdAndValue(list_id, list.pop(0)))
if len(list) <= 0:
sorted_lists.pop(list_id)
while not heap.is_empty():
sorted_list.append(heap.pop())
print k*n, len(sorted_list), sorted_list
class Queue:
def __init__(self):
self._sll = SingleLinkedList()
def enqueue(self, value):
node = Node(value)
self._sll.append(node)
def dequeue(self):
if self._sll.isEmpty():
raise Exception("Empty Queue")
v = self._sll.head
self._sll.head = self._sll.head.next
return v.value
class SingleLinkedSet:
""" Data structure for storing only unique values.
Not thread-safe.
"""
def __init__(self, iterable=None):
self._container = SingleLinkedList()
if iterable:
for item in iterable:
self.add(item)
def add(self, value):
if not self._container.contains(value):
self._container.append(value)
def contains(self, value):
return self._container.contains(value)
def __contains__(self, value):
return self.contains(value)
class SingleLinkedStack0:
def __init__(self):
self.items = SingleLinkedList()
self.length = 0
def push(self, item):
self.items.append(item)
self.length += 1
return True
def pop(self):
if len(self.items) == 0:
return None
return self.items.pop(self.length - 1)
def __len__(self):
return len(self.items)
def __repr__(self):
"""
显示栈的容量
"""
return "<SingleLinkedStack0: %d>" % self.length
fast = single_linked.head
slow = single_linked.head
# 慢指针前进过程中前半部分逆序
while fast and fast._next:
fast = fast._next._next
next_ = slow._next
slow._next = prev
prev = slow
slow = next_
# 针对奇数情况
if fast:
slow = slow._next
# 对比
while slow:
if slow.val != prev.val:
return False
else:
slow = slow._next
prev = prev._next
return True
if __name__ == "__main__":
test = SingleLinkedList()
for i in ['a', 'b']:
test.append(i)
print(is_palindrome2(test))
