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: