def main():
solver = Solution()
head = ListNode(3)
head.next = ListNode(2)
solver.sortList2(head)
ptr = head
while ptr:
print(ptr.val)
ptr = ptr.next
head = ListNode(2)
head.next = ListNode(1)
solver.sortList2(head)
ptr = head
while ptr:
print(ptr.val)
ptr = ptr.next
def sortList2(self, head):
if not head or not head.next:
return head
n = 0
ptr = head
while ptr:
ptr = ptr.next
n += 1
step = 1
sentry = ListNode(0)
while step < n:
sentry.next = head
prev = sentry
while prev.next:
head1 = prev.next
tail1 = head1
for i in range(step - 1):
if tail1.next is None:
break
tail1 = tail1.next
if tail1.next is None:
break
head2 = tail1.next
tail2 = head2
tail1.next = None
for i in range(step - 1):
if tail2.next is None:
break
tail2 = tail2.next
post = tail2.next
tail2.next = None
prev.next = self.merge(head1, head2)
tail = prev.next
while tail.next:
tail = tail.next
tail.next = post
prev = tail
head = sentry.next
step <<= 1
return head
def list_pivoting(l: ListNode, x: int) -> Optional[ListNode]:
less_head = less_iter = ListNode()
equal_head = equal_iter = ListNode()
greater_head = greater_iter = ListNode()
# Populates the three lists.
while l:
if l.data < x:
less_iter.next = l
less_iter = less_iter.next
elif l.data == x:
equal_iter.next = l
equal_iter = equal_iter.next
else: # l.data > x.
greater_iter.next = l
greater_iter = greater_iter.next
l = l.next
# Combines the three lists.
greater_iter.next = None
equal_iter.next = greater_head.next
less_iter.next = equal_head.next
return less_head.next
def reverse_sublist(L: ListNode, start: int,
finish: int) -> Optional[ListNode]:
dummy_head = sublist_head = ListNode(0, L)
for _ in range(1, start):
sublist_head = sublist_head.next
sublist_iter = sublist_head.next
for _ in range(finish - start):
temp = sublist_iter.next
sublist_iter.next, temp.next, sublist_head.next = (temp.next,
sublist_head.next,
temp)
return dummy_head.next
def merge_two_sorted_lists_heap(L1: Optional[ListNode],
L2: Optional[ListNode]) -> Optional[ListNode]:
Item = collections.namedtuple('Item', ['val', 'list_idx'])
head, curr = None, None
lists = [L1, L2]
if not lists:
return None
# Initialize heap, assume at least 1 item in a list
candidate_heap = [
Item(node.data, list_idx) for list_idx, node in enumerate(lists)
if node
]
heapq.heapify(candidate_heap)
while candidate_heap:
# Get the minium value from heap and add to result
min_item = heapq.heappop(candidate_heap)
if not head:
curr = ListNode(min_item.val)
head = curr
else:
curr.next = ListNode(min_item.val)
curr = curr.next
lists[min_item.list_idx] = lists[min_item.list_idx].next
next_item = lists[min_item.list_idx]
# Check if list is exhausted
if next_item is None:
continue
# Else add the next value from list to result
item = Item(next_item.data, min_item.list_idx)
heapq.heappush(candidate_heap, item)
return head
def list_pivoting(l: ListNode, x: int) -> Optional[ListNode]:
# TODO - you fill in here.
less_head = less_iter = ListNode()
equal_head = equal_iter = ListNode()
great_head = great_iter = ListNode()
while l:
if l.data < x:
less_iter.next = l
less_iter = less_iter.next
elif l.data == x:
equal_iter.next = l
equal_iter = equal_iter.next
elif l.data > x:
great_iter.next = l
great_iter = great_iter.next
l = l.next
great_iter.next = None
equal_iter.next = great_head.next
less_iter.next = equal_head.next
return less_head.next
def reverse_sublist(L, start, finish):
sublist_head = dummy_head = ListNode(0, L)
for i in range(1, start):
sublist_head = sublist_head.next
current = sublist_head.next
for i in range(finish - start):
post = current.next
current.next = post.next
post.next = sublist_head.next
sublist_head.next = post
return dummy_head.next
def merge_two_sorted_lists(L1: ListNode, L2: ListNode) -> ListNode:
head: ListNode = ListNode()
tail: ListNode = head
while L1 and L2:
if L1.data < L2.data:
tail.next = L1
L1 = L1.next
else:
tail.next = L2
L2 = L2.next
tail = tail.next
tail.next = L1 or L2
return head.next
def reverse_sublist(L, start, finish):
dummy_head = sublist_head = ListNode(0, L)
for _ in range(1, start):
sublist_head = sublist_head.next
# Reverses sublist.
sublist_iter = sublist_head.next
for _ in range(finish - start):
temp = sublist_iter.next
sublist_iter.next, temp.next, sublist_head.next = (temp.next,
sublist_head.next,
temp)
return dummy_head.next
def add_two_numbers(L1: ListNode, L2: ListNode) -> Optional[ListNode]:
a = L1
b = L2
resultHead = resultTail = None
carry = 0
l1 = get_length(L1)
l2 = get_length(L2)
diff = l1 - l2
if diff > 0:
appendZereos(L2, diff)
elif diff < 0:
appendZereos(L1, -diff)
while a:
sum = a.data + b.data + carry
data = sum % 10
carry = sum // 10
dataNode = ListNode(data)
if resultHead == None:
resultHead = resultTail = dataNode
else:
resultTail.next = dataNode
resultTail = dataNode
a = a.next
b = b.next
if carry > 0:
carryNode = ListNode(carry)
resultTail.next = carryNode
resultTail = carryNode
return resultHead
def remove_kth_last(L, k):
dumbHead = ListNode(0, L)
fast = slow = dumbHead.next
for _ in range(k):
fast = fast.next
while fast and fast.next is not None:
slow, fast = slow.next, fast.next
slow.next = slow.next.next
return dumbHead.next
def remove_kth_last(L: ListNode, k: int) -> Optional[ListNode]:
# if k <= 0 : return None
dummyHead = ListNode(0, L)
q = dummyHead
for _ in range(k):
q = q.next
p = dummyHead
while q.next:
q = q.next
p = p.next
# res = p.next
p.next = p.next.next
# res.next = None
return dummyHead.next
def reverse_sublist(L, start, finish):
dummy = ListNode(0, L)
sub_head = dummy
for _ in range(1, start):
sub_head = sub_head.next
sub_head_iter = sub_head.next
for _ in range(finish - start):
temp = sub_head_iter.next
sub_head_iter.next, temp.next, sub_head.next = temp.next, sub_head.next, temp
return dummy.next
def merge_two_sorted_lists(L1, L2):
# TODO - you fill in here.
head = tail = ListNode()
while L1 and L2:
if L1.data < L2.data:
tail.next = L1
L1 = L1.next
else:
tail.next = L2
L2 = L2.next
tail = tail.next
tail.next = L1 or L2
return head.next
def author_solution(L1, L2):
# Creates a placeholder for the result
dummy_head = tail = ListNode()
while L1 and L2:
if L1.data < L2.data:
tail.next, L1 = L1, L1.next
else:
tail.next, L2 = L2, L2.next
tail = tail.next
# Appends the remaining nodes of L1 or L2
tail.next = L1 or L2
return dummy_head.next
def remove_kth_last(L, k):
dummy = ListNode(None, L)
fast = dummy.next
for _ in range(k):
fast = fast.next
slow = dummy
while fast:
fast, slow = fast.next, slow.next
delNode = slow.next
slow.next = delNode.next
delNode.next = None
L = dummy.next
return L
def merge_two_sorted_lists(L1, L2):
# TODO - you fill in here.
head = L = ListNode()
while L1 and L2:
if L1.data < L2.data:
L.next, L1, L2 = L1, L1.next, L2
else:
L.next, L1, L2 = L2, L1, L2.next
L = L.next
L.next = L1 or L2
return head.next
def merge_two_sorted_lists(L1, L2):
placeholder = ListNode()
pointer = placeholder
while L1 and L2:
if L1.data < L2.data:
pointer.next = L1
L1 = L1.next
else:
pointer.next = L2
L2 = L2.next
pointer = pointer.next
pointer.next = L1 or L2
return placeholder.next
def even_odd_merge(L):
# TODO - you fill in here.
if not L:
return L
even_head = ListNode(0)
odd_head = ListNode(0)
even_runner = even_head
odd_runner = odd_head
i = 0
while L:
if i % 2 == 0:
even_runner.next = L
even_runner = even_runner.next
else:
odd_runner.next = L
odd_runner = odd_runner.next
L = L.next
i += 1
even_runner.next = odd_head.next
odd_runner.next = None
return even_head.next
def add_two_numbers(L1, L2):
carry = 0
result = iter = ListNode(0, L1)
while L1 or L2:
if not L1 and L2:
L1, L2 = L2, L1
if not L1:
break
L1.data += L2.data + carry if L2 else carry
carry, L1.data = divmod(L1.data, 10)
iter.next = L1
iter = L1
L1 = L1.next if L1 and L1.next else None
L2 = L2.next if L2 and L2.next else None
if carry:
iter.next = ListNode(carry)
return result.next
def remove_kth_last(L, k):
dummy_head = ListNode(0, L)
first = L
for _ in range(k):
first = first.next
second = dummy_head
while first:
first, second = first.next, second.next
second.next = second.next.next
return dummy_head.next
def remove_kth_last(L, k):
p1 = p2 = dummy_head = ListNode(0, L)
p1 = p1.next
for _ in range(k):
p1 = p1.next
while p1:
p1 = p1.next
p2 = p2.next
p2.next = p2.next.next
return dummy_head.next
def merge_two_sorted_lists(L1, L2):
# Creates a placeholder for the result.
dummy_head = tail = ListNode()
while L1 and L2:
if L1.data < L2.data:
tail.next, L1 = L1, L1.next
else:
tail.next, L2 = L2, L2.next
tail = tail.next
# Appends the remaining nodes of L1 or L2
tail.next = L1 or L2
return dummy_head.next
def merge_two_sorted_lists(L1, L2):
dummy = ListNode()
tail = dummy
while L1 and L2:
if L1.data <= L2.data:
tail.next, L1 = L1, L1.next
else:
tail.next, L2 = L2, L2.next
tail = tail.next
tail.next = L1 if L1 else L2
return dummy.next
def add_to_tail(self, val):
"""
1. Check if tail doesn't exist.
a. If true, add a new instance of ListNode to tail.
2. If tail exists but head doesn't exist,
a. Assign the tail to the head.
b. Replace current tail with new instance of ListNode.
c. Set prev pointer of new tail to the head.
d. Set head's next pointer to the new tail.
3. If both head and tail already exists:
a. Replace current tail with the new tail instance.
b. Set the new tail's prev pointer to the previous tail.
c. Set the previous tail's next pointer to the new tail.
"""
if not self.tail:
self.tail = ListNode(val, self.head, None)
elif not self.head:
self.head = self.tail
self.tail = ListNode(val, self.head, None)
self.head.next = self.tail
else:
self.tail = ListNode(val, self.tail, None)
self.tail.prev.next = self.tail
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
dummy = ListNode(0)
dummy.sum = 0
dummy.next = head
cur_sum = 0
p = head
while p:
cur_sum += p.val
p.sum = cur_sum
p = p.next
start = dummy
while start:
cur = start.next # node0
while cur:
range_sum = cur.sum - start.sum
if range_sum == 0:
start.next = cur.next # delete start->next 到 cur
break
else:
cur = cur.next
start = start.next
return dummy.next
def reverse_sublist(L, start, finish):
dummy = subhead = ListNode()
dummy.next = L
for _ in range(1, start):
subhead = subhead.next
subtail = subhead.next
for _ in range(start, finish):
tmp = subhead.next
subhead.next = subtail.next
subtail.next = subtail.next.next
subhead.next.next = tmp
return dummy.next
def remove_kth_last(L: ListNode, k: int) -> Optional[ListNode]:
dummy_head = ListNode(0, L)
first = dummy_head.next
for _ in range(k):
first = first.next
second = dummy_head
while first:
first, second = first.next, second.next
# second points to the (k + 1)-th last node, deletes its successor.
second.next = second.next.next
return dummy_head.next
def list_pivoting(l: ListNode, x: int) -> Optional[ListNode]:
low, eq, high = ListNode(), ListNode(), ListNode()
low_next, eq_next, high_next = low, eq, high
while l:
if l.data < x:
low_next.next = l
low_next = l
elif l.data == x:
eq_next.next = l
eq_next = l
else:
high_next.next = l
high_next = l
l = l.next
# combine
high_next.next = None
eq_next.next = high.next
low_next.next = eq.next
return low.next
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
"""
:type head: ListNode
:type n: int
:rtype: ListNode
Runs in O(L) where L is number of nodes in the ListNode
"""
temp = ListNode(0)
temp.next = head
fast_pointer = temp
slow_pointer = temp
for _ in range(n):
fast_pointer = fast_pointer.next
while fast_pointer and fast_pointer.next:
fast_pointer = fast_pointer.next
slow_pointer = slow_pointer.next
slow_pointer.next = slow_pointer.next.next
return temp.next
def merge_two_sorted_lists(L1: Optional[ListNode],
L2: Optional[ListNode]) -> Optional[ListNode]:
dummy_head = tail = ListNode()
while L1 and L2:
if L1.data < L2.data:
tail.next, L1 = L1, L1.next
else:
tail.next, L2 = L2, L2.next
tail = tail.next
if L1: tail.next = L1
elif L2: tail.next = L2
return dummy_head.next
def merge_two_sorted_lists(L1: Optional[ListNode],
L2: Optional[ListNode]) -> Optional[ListNode]:
# TODO - you fill in here.
head = current = ListNode()
while (L1 and L2):
if (L1.data < L2.data):
current.next = L1
L1 = L1.next
else:
current.next = L2
L2 = L2.next
current = current.next
current.next = L1 or L2
return head.next
# @param B : head node of linked list
# @return the head node in the linked list
def mergeTwoLists(self, A, B):
if A == None:
return B
elif B == None:
return A
if A.val < B.val:
A.next = self.mergeTwoLists(A.next, B)
return A
else:
B.next = self.mergeTwoLists(A, B.next)
return B
s = Solution()
a1 = ListNode(1)
a2 = ListNode(5)
a3 = ListNode(9)
a1.next = a2
a2.next = a3
b1 = ListNode(2)
b2 = ListNode(3)
b3 = ListNode(10)
b1.next = b2
b2.next = b3
merged = s.mergeTwoLists(a1, b1)
tmp = merged
while tmp.next != None:
