def swap_pairs(head): """ Swap every two adjacent nodes in given linked list :param head: head node of given linked list :type head: ListNode :return: head node of swapped linked list :rtype: ListNode """ # basic case if head is None: return head # dummy head dummy = ListNode(None) dummy.next = head # swap pairs curr = dummy while curr.next is not None and curr.next.next is not None: tmp_next = curr.next tmp_nnnext = curr.next.next.next curr.next = curr.next.next curr.next.next = tmp_next curr.next.next.next = tmp_nnnext curr = curr.next.next return dummy.next
def addTwoNumbers(l1, l2): """ Reverse the lists and then sum Time: O(m+n), m the length of l1 and n the length of l2 Space: O(m+n) since we have reversed the lists """ addone = 0 head = ListNode(-1) curr_node = head l1 = reverse_linked_list(l1) l2 = reverse_linked_list(l2) while l1 is not None or l2 is not None: if not l1: l1 = ListNode(0) elif not l2: l2 = ListNode(0) curr_sum = l1.val + l2.val + addone l1, l2 = l1.next, l2.next curr_node.next = ListNode(curr_sum % 10) curr_node = curr_node.next if curr_sum >= 10: addone = 1 else: addone = 0 if addone == 1: curr_node.next = ListNode(1) return reverse_linked_list(head.next)
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: carry = 0 out = None currNode = None while not (l1 is None and l2 is None and carry == 0): currVal = 0 if l1 is not None: currVal += l1.val if l2 is not None: currVal += l2.val if carry == 1: currVal += 1 carry = 0 if currVal >= 10: carry = 1 currVal -= 10 if out is None: currNode = ListNode(currVal) out = currNode else: currNode.next = ListNode(currVal) currNode = currNode.next if l1: l1 = l1.next if l2: l2 = l2.next return out
def mergeKLists(self, lists): """ 用优先队列优化方法 :type lists: List[ListNode] :rtype: ListNode """ # For python 2 # from queue import PriorityQueue # For python 3 from queue import PriorityQueue head = cur = ListNode(0) q = PriorityQueue() for l in lists: if l: q.put((l.val, l)) while not q.empty(): val, node = q.get() cur.next = ListNode(val) cur = cur.next node = node.next if node: q.put((node.val, node)) return head.next
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ k = len(lists) res = ListNode(0) tail = res heap = [] heapq.heapify(heap) for indx in range(k): if not lists[indx]: continue node = lists[indx] heapq.heappush(heap, (node.val, indx)) lists[indx] = node.next while heap: item, indx = heapq.heappop(heap) tail.next = ListNode(item) tail = tail.next if lists[indx]: heapq.heappush(heap, (lists[indx].val, indx)) lists[indx] = lists[indx].next return res.next
def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ left_finish = right_finish = False first = result = ListNode(0) add = 0 while True: if l1: left = l1.val l1 = l1.next else: left_finish = True left = 0 if l2: right = l2.val l2 = l2.next else: right_finish = True right = 0 if left_finish == right_finish == True and not add: break tmp = (left + right + add) if tmp >= 10: result.next = ListNode(tmp - 10) add = 1 else: result.next = ListNode(tmp) add = 0 result = result.next return first.next
def sort_list(head): def partition(start, end): node = start.next.next # node to iterate first_pivot = start.next first_pivot.next = end # Insert large node between pivot and end last_pivot = first_pivot while node != end: tmp = node.next if node.val > first_pivot.val: node.next = last_pivot.next last_pivot.next = node elif node.val < first_pivot.val: node.next = start.next start.next = node else: node.next = last_pivot.next last_pivot.next = node last_pivot = last_pivot.next node = tmp return [first_pivot, last_pivot] def qsort(start, end): if start.next != end: first_pivot, last_pivot = partition(start, end) qsort(start, first_pivot) qsort(last_pivot, end) head_pre = ListNode(0) head_pre.next = head qsort(head_pre, None) return head_pre.next
def add_two_numbers(l1, l2): """ Add two integers represented in linked lists :param l1: head of first linked list :type l1: ListNode :param l2: head of second linked list :type l2: ListNode :return: head of result linked list :rtype: ListNode """ result_dummy = ListNode(None) result = result_dummy carry = 0 while l1 is not None or l2 is not None or carry != 0: v1 = l1.val if l1 is not None else 0 v2 = l2.val if l2 is not None else 0 val = (v1 + v2 + carry) % 10 carry = (v1 + v2 + carry) // 10 result.next = ListNode(val) result = result.next if l1 is not None: l1 = l1.next if l2 is not None: l2 = l2.next return result_dummy.next
def delete_duplicates(head): """ Remove all duplicates in given linked list, leaving only distinct numbers :param head: head node of given linked list :type head: ListNode :return: head node of operated linked list :rtype: ListNode """ if head is None: return head dummy_head = ListNode(None) dummy_head.next = head curr = dummy_head while curr.next is not None and curr.next.next is not None: if curr.next.val == curr.next.next.val: val = curr.next.val while curr.next is not None and curr.next.val == val: tmp = curr.next curr.next = curr.next.next del tmp else: curr = curr.next return dummy_head.next
def addAtIndex(self, index: int, val: int) -> None: """ Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. """ # If index is greater than the length, # the node will not be inserted. if index > self.size: return # [so weird] If index is negative, # the node will be inserted at the head of the list. if index < 0: index = 0 self.size += 1 # find predecessor of the node to be added pred = self.head for _ in range(index): pred = pred.next # node to be added to_add = ListNode(val) # insertion itself to_add.next = pred.next pred.next = to_add
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: """ Time: O(max(m, n)) Space: O(max(m, n)) """ dummy = ListNode(0) current = dummy carry = 0 while l1 or l2: num = carry num += l1.val if l1 else 0 num += l2.val if l2 else 0 carry = num // 10 num %= 10 current.next = ListNode(num) current = current.next if l1 is not None: l1 = l1.next if l2 is not None: l2 = l2.next if carry == 1: current.next = ListNode(carry) return dummy.next
def reverseBetween(self, head, m, n): """ :type head: ListNode :type m: int :type n: int :rtype: ListNode """ dummy = ListNode(-1) dummy.next = head pre = dummy # 找到翻转链表部分的前一个节点, 1->2->3->4->5->NULL, m = 2, n = 4 指的是 节点值为1 for _ in range(m - 1): pre = pre.next # 用双指针,进行链表翻转 node = None cur = pre.next for _ in range(n - m + 1): tmp = cur.next cur.next = node node = cur cur = tmp # 将翻转部分 和 原链表拼接 pre.next.next = cur pre.next = node return dummy.next
def partition(head, x): """ Partition a given linked list with given number :param head: head node of given linked list :type head: ListNode :param x: given number :type x: int :return: head node of operated linked list :rtype: ListNode """ if head is None: return head left_dummy = ListNode(None) right_dummy = ListNode(None) left = left_dummy right = right_dummy curr = head while curr is not None: if curr.val < x: left.next = curr left = left.next else: right.next = curr right = right.next curr = curr.next right.next = None left.next = right_dummy.next return left_dummy.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: empty_head = ListNode() tail = empty_head carry = 0 while l1 or l2: num = (l1.val if l1 else 0) + (l2.val if l2 else 0) if carry: num += 1 carry = 0 if num >= 10: carry = 1 num -= 10 tail.next = ListNode(num) tail = tail.next if l1: l1 = l1.next if l2: l2 = l2.next if carry: tail.next = ListNode(carry) return empty_head.next
def remove_elements(head, val): """ Remove all elements from a linked list of integers that have value val. :param head: head node of given linked list :type head: ListNode :param val: value to remove :type val: int :return: head node of removed linked list :rtype: ListNode """ # basic case if head is None: return head # dummy head dummy = ListNode(None) dummy.next = head # traverse to remove nodes with given value curr = dummy while curr is not None: while curr.next is not None and curr.next.val == val: tmp = curr.next curr.next = curr.next.next del tmp curr = curr.next return dummy.next
def insertion_sort_list(head): """ Sort a linked list by insertion sort :param head: head node of given linked list :type head: ListNode :return: head node of sorted linked list :rtype: ListNode """ dummy = ListNode(None) dummy.next = head curr = head while curr is not None: if curr.next is not None and curr.next.val < curr.val: # find insertion position pre = dummy while pre.next is not None and pre.next.val < curr.next.val: pre = pre.next # insert the next node of curr to the position after node pre tmp = pre.next pre.next = curr.next curr.next = curr.next.next pre.next.next = tmp else: curr = curr.next return dummy.next
def swapPairs_loop(head): """ Loop Time: O(n) (but in runtime slower than recursion) Space: O(1) (but in runtime similar to recursion) """ # dummy head for return start = ListNode(-1) start.next = head # var to contain the previous node prev_node = start # stop the loop if only one or zero node left while head and head.next: # the current two nodes to be swapped first_node = head second_node = head.next # swap, and linked the second node in the pair to the previous node prev_node.next = second_node first_node.next = second_node.next second_node.next = first_node # update previous node to the next pair # update head to the first node in the next pair prev_node = first_node head = first_node.next return start.next
def remove_nth_from_end(head, n): """ Remove the n-th node from the end of list :param head: head node of given linked list :type head: ListNode :param n: order n :type n: int :return: head node of operated linked list :rtype: ListNode """ # basic case if head is None: return head # initialize variables dummy = ListNode(None) dummy.next = head slow = fast = dummy # slow pointer is slower than fast pointer by n positions count = 0 while fast.next is not None: fast = fast.next count += 1 if count > n: slow = slow.next # if need to remove node if count >= n: tmp = slow.next slow.next = slow.next.next del tmp return dummy.next
def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ p1 = l1 p2 = l2 head = tail = None r = 0 while p1 or p2: p1_next = p1.next if p1 else None p2_next = p2.next if p2 else None val = (p1.val if p1 else 0) + (p2.val if p2 else 0) + r if val >= 10: val -= 10 r = 1 else: r = 0 node = ListNode(val) if head is None: head = tail = node else: tail.next = node tail = node p1 = p1_next p2 = p2_next if r: node = ListNode(r) tail.next = node return head
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: """ Iterate from the right digits Create dummy node root and copy pointer to it While there are some nodes or transfer digit: Calculate sum of node values and transfer digit Create linked node with remainder to 10 Set transfer with quotient to 10 Link each node to next one Return dummy node next """ transfer = 0 root = ListNode() node = root while l1 or l2 or transfer: first = l1.val if l1 else 0 second = l2.val if l2 else 0 _sum = first + second + transfer node.next = ListNode(_sum % 10) transfer = _sum // 10 node = node.next l1 = l1.next if l1 else None l2 = l2.next if l2 else None return root.next
def deleteDuplicates_last(head): """ Remove all duplicates but the last and finally itself Time: O(n) Space: O(1) """ if not head: return head # setup the pseudo head return_head = ListNode(-1) return_head.next = head # prev_node is last the non-duplicate node prev_node = return_head # head could be None here while head and head.next: if head.val == head.next.val: # keep on moving forward until head is now the last occurrence while head.next and head.val == head.next.val: head = head.next # skip the last occurrence, NOTE: the new head could be None head = head.next prev_node.next = head else: prev_node = head head = head.next return return_head.next
def mergeTwoLists(self, l1, l2): """ 合并两个有序链表 :type l1: ListNode :type l2: ListNode :rtype: ListNode """ t1 = l1 t2 = l2 cur = head = ListNode(0) while t1 or t2: if not t1: cur.next = ListNode(t2.val) t2 = t2.next elif not t2: cur.next = ListNode(t1.val) t1 = t1.next elif t1.val < t2.val: cur.next = ListNode(t1.val) t1 = t1.next else: cur.next = ListNode(t2.val) t2 = t2.next cur = cur.next return head.next
def insert(pre, cur, val): nonlocal res new_node = ListNode(val) if not pre: res = new_node else: pre.next = new_node new_node.next = cur
def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ head_node = ListNode(0) head_node.next = head
def reverseK(head_node, k): dummpy_node = ListNode(0) dummpy_node.next = head_node tmp_ptr = dummpy_node for i in range(k): tmp_ptr = tmp_ptr.next if i < k - 1 and tmp_ptr is None: return dummpy_node.next
def generate_sll_from_list(values): D = c = ListNode(0) for v in values: c.next = ListNode(v) c = c.next res, D.next = D.next, None return res
def removeElements(self, head, val): prev = ListNode(0) prev.next = head cur = prev while cur.next: if cur.next.val == val: cur.next = cur.next.next else: cur = cur.next return prev.next
def copy(raw): if raw in cache: return cache[raw] new = Node(raw.val) cache[raw] = new if raw.next: new.next = copy(raw.next) if raw.random: new.random = copy(raw.random) return new
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: if l1 is None: return l2 elif l2 is None: return l1 elif l1.val < l2.val: l1.next = self.mergeTwoLists(l1.next, l2) return l1 else: l2.next = self.mergeTwoLists(l1, l2.next) return l2
def reverseKGroup(self, head: ListNode, k: int) -> ListNode: pre_head = ListNode(None) pre_head.next = head pre_node = pre_head last_node = self._move(pre_node, k) while last_node: next_k = last_node.next pre_node = self._reverse_sub_list_node(pre_node, next_k, k) last_node = self._move(next_k, k - 1) return pre_head.next
def helper(l1, l2, offset): if l1 is None: return None if offset == 0: result = ListNode(l1.val + l2.val) post = helper(l1.next, l2.next, 0) else: result = ListNode(l1.val) post = helper(l1.next, l2, offset-1) if post is not None and post.val > 9: result.val += 1 post.val -= 10 result.next = post return result
def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ def get_len(l): count = 0 while l is not None: l = l.next count += 1 return count def helper(l1, l2, offset): if l1 is None: return None if offset == 0: result = ListNode(l1.val + l2.val) post = helper(l1.next, l2.next, 0) else: result = ListNode(l1.val) post = helper(l1.next, l2, offset-1) if post is not None and post.val > 9: result.val += 1 post.val -= 10 result.next = post return result size1 = get_len(l1) size2 = get_len(l2) head = ListNode(1) if size1 < size2: head.next = helper(l2, l1, size2 - size1) else: head.next = helper(l1, l2, size1 - size2) if head.next.val > 9: head.next.val -= 10 return head else: return head.next
def merge_sort(self, head, n): # non recursive def split(p, step): last = None for i in xrange(step): if p is None: break last = p p = p.next if last: last.next = None return p def merge(h1, h2, tail): p1, p2 = h1, h2 while p1 or p2: if not p2 or p1 and p1.val <= p2.val: tail.next = p1 tail = p1 p1 = p1.next elif not p1 or p2 and p2.val <= p1.val: tail.next = p2 tail = p2 p2 = p2.next else: break return tail dummy = ListNode(0) dummy.next = head left = right = tail = None step = 1 while step < n: p = dummy.next tail = dummy while p: left = p right = split(p, step) p = split(right, step) tail = merge(left, right, tail) step <<= 1 return dummy.next
def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ if head is None: return head fake_head = ListNode(0) fake_head.next = head p,q,r = fake_head,head,head.next while q and r: p.next = r q.next = r.next r.next = q p = q q = p.next r = q.next if q else None return fake_head.next
__author__ = 'clp' from utils import ListNode class Solution(object): def removeElements(self, head, val): """ :type head: ListNode :type val: int :rtype: ListNode """ while head is not None and head.val == val: head = head.next if not head: return None current_node = head while current_node.next: if current_node.next.val == val: current_node.next = current_node.next.next else: current_node = current_node.next return head if __name__ == '__main__': ListNode.print_linked_list(Solution().removeElements(ListNode.build_linked_list([1,2,3,4,5,6]), 6)) ListNode.print_linked_list(Solution().removeElements(ListNode.build_linked_list([1,1,3,4,56]), 1)) ListNode.print_linked_list(Solution().removeElements(ListNode.build_linked_list([2,1,3,4,4,4,4]), 4)) ListNode.print_linked_list(Solution().removeElements(ListNode.build_linked_list([1]), 1))
:rtype: bool """ slow = fast = head while fast: slow = slow.next fast = fast.next.next if fast.next else None # slow is head of right half now, reverse right half p, last = slow, None while p: next = p.next p.next = last last = p p = next # compare left half and right half p1, p2 = head, last while p1 and p2: if p1.val != p2.val: return False p1 = p1.next p2 = p2.next return True if __name__ == '__main__': from utils import ListNode f = Solution().isPalindrome assert f(ListNode.make_list([1, 2, 3, 2, 1])) assert f(ListNode.make_list([1, 2, 2, 1])) assert not f(ListNode.make_list([1, 2, 1, 1])) assert not f(ListNode.make_list([1, 2, 3, 1, 1]))
def reverseList(self, head): """ :type head: ListNode :rtype: ListNode """ if not head: return None global new_head def reverse_list(node): global new_head if node.next is None: new_head = node return node next_node = reverse_list(node.next) next_node.next = node return node reverse_list(head) head.next = None return new_head if __name__ == '__main__': l = ListNode.build_linked_list([]) l = ListNode.build_linked_list([1]) # l = ListNode.build_linked_list([1, 2, 3, 4, 5]) ListNode.print_linked_list(Solution().reverseList(l))
return node lA, lB = link_len(headA), link_len(headB) if lA > lB: hA, hB = link_index(headA, lA - lB), headB elif lA < lB: hA, hB = headA, link_index(headB, lB - lA) else: hA, hB = headA, headB nA, nB = hA, hB while nA and nB: if nA == nB: return nA nA = nA.next nB = nB.next return None if __name__ == '__main__': headC = ListNode.build_linked_list([4,5,6]) headA = ListNode(1) headA.next = ListNode(2) headA.next.next = headC headB = headC print Solution().getIntersectionNode(headA, headB) print Solution().getIntersectionNode(None, None) print Solution().getIntersectionNode(ListNode.build_linked_list([1,3,5,7,9,11,13,15,17,19,21]), ListNode.build_linked_list([2]))
@param head The linked list's head. Note that the head is guaranteed to be not null, so it contains at least one node. :type head: ListNode """ self.head = head def getRandom(self): """ Returns a random node's value. :rtype: int """ # Reservoir Sampling p = self.head result = None i = 0 while p: if random.randint(0, i) == 0: result = p.val i += 1 p = p.next return result if __name__ == '__main__': from utils import ListNode s = Solution(ListNode.make_list([1, 2, 3, 4])) print s.getRandom() print s.getRandom() print s.getRandom() print s.getRandom()
i = 1 p = head last = None while i < m: last = p p = p.next i += 1 rhead = p rlast = None while p and i <= n: next = p.next p.next = rlast rlast = p p = next i += 1 rhead.next = p if m > 1: last.next = rlast else: head = rlast return head if __name__ == '__main__': from utils import ListNode f = Solution().reverseBetween print f(ListNode.make_list([1, 2, 3, 4, 5]), 2, 4) print f(ListNode.make_list([1, 2, 3, 4, 5]), 2, 5) print f(ListNode.make_list([1, 2, 3, 4, 5]), 1, 5) print f(ListNode.make_list([1, 2, 3, 4, 5]), 1, 4)
:rtype: ListNode """ if not head: return None hash_counter = {} current = head while current: k = current.val hash_counter[k] = hash_counter.get(k, 0) + 1 current = current.next new_head = None prev, current = None, head while current: if hash_counter[current.val] >= 2: if prev: prev.next = current.next prev, current = prev, current.next else: if not new_head: new_head = current prev, current = current, current.next return new_head if __name__ == '__main__': ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([1,1,2,3,1,1,2]))) ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([1,1,2,3,1,1]))) ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([1,2,3,3,4,4,5]))) ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([1, 5]))) ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([1]))) ListNode.print_linked_list(Solution().deleteDuplicates(ListNode.build_linked_list([])))
current = head while current: if current.val < x: if not f_head: f_head = current f_end = f_head else: f_end.next = current f_end = f_end.next else: if not b_head: b_head = current b_end = b_head else: b_end.next = current b_end = b_end.next current = current.next if f_head: f_end.next = b_head if b_end: b_end.next = None return f_head if f_head else b_head if __name__ == '__main__': ListNode.print_linked_list(Solution().partition(ListNode.build_linked_list([1, 4, 3, 2, 5, 2]), 3)) ListNode.print_linked_list(Solution().partition(ListNode.build_linked_list([1, 4, 3, 2, 5, 2]), 6)) ListNode.print_linked_list(Solution().partition(ListNode.build_linked_list([1, 4, 3, 2, 5, 2]), 1)) ListNode.print_linked_list(Solution().partition(ListNode.build_linked_list([1, 4, 3, 2, 5, 2]), 2)) ListNode.print_linked_list(Solution().partition(ListNode.build_linked_list([1]), 2)) ListNode.print_linked_list(Solution().partition(None, 2))
node = p.__class__(p.val) if tail and node.val > tail.val: tail = self.insert(tail, tail, node) else: tail = self.insert(new_head, tail, node) p = p.next return new_head.next def insert(self, head, tail, node): current = head.next last = head while current: if current.val > node.val: break last = current current = current.next if last: last.next = node node.next = current return node if current is None else tail if __name__ == "__main__": from datetime import datetime from utils import ListNode head = ListNode.make_list([3, 2, 1]) st = datetime.now() p = Solution().insertionSortList(head) # print p.to_list() print datetime.now() - st
""" p = head less_head = less_tail = None greater_head = greater_tail = None while p: if p.val < x: if less_head is None: less_head = less_tail = p else: less_tail.next = p less_tail = p else: if greater_head is None: greater_head = greater_tail = p else: greater_tail.next = p greater_tail = p p = p.next if greater_tail: greater_tail.next = None if less_tail: less_tail.next = greater_head return less_head or greater_head if __name__ == '__main__': f = Solution().partition from utils import ListNode print f(ListNode.make_list([1, 4, 3, 2, 5, 2]), 3) print f(ListNode.make_list([1]), 0)
h2 = self.merge_sort(head2, n - n / 2) p1, p2 = h1, h2 h = t = None while p1 or p2: if not p2 or p1 and p1.val <= p2.val: if h is None: h = t = p1 else: t.next = p1 t = p1 p1 = p1.next elif not p1 or p2 and p2.val <= p1.val: if h is None: h = t = p2 else: t.next = p2 t = p2 p2 = p2.next else: break return h if __name__ == '__main__': f = Solution().sortList from utils import ListNode print f(ListNode.make_list([3, 4, 2, 1, 7, 5, 6])) print f(ListNode.make_list([1])) print f(ListNode.make_list([5, 4, 3])) print f(ListNode.make_list([4,19,14,5,-3,1,8,5,11,15]))
# # This is very tricky, see proof in Gossip.md # class Solution(object): def detectCycle(self, head): """ :type head: ListNode :rtype: ListNode """ slow = fast = head while fast and fast.next: fast = fast.next.next slow = slow.next if fast == slow: slow = head while fast != slow: fast = fast.next slow = slow.next return slow return None if __name__ == '__main__': head = ListNode.build_linked_list([1,2,3,4,5]) head.next.next.next.next.next = head.next.next print Solution().detectCycle(head).val print Solution().detectCycle(None)
slow.next = None prev.next = None # reverse the list from the mid while current: next = current.next current.next = prev prev, current = current, next # interleave the two list current1, current2 = head, prev while current1 and current2: current1_next, current2_next = current1.next, current2.next current1.next, current2.next = current2, current1_next current1, current2 = current1_next, current2_next if __name__ == '__main__': l1 = ListNode.build_linked_list([1,2,3]) Solution().reorderList(l1) ListNode.print_linked_list(l1) l1 = ListNode.build_linked_list([1,2]) Solution().reorderList(l1) ListNode.print_linked_list(l1) l1 = ListNode.build_linked_list([]) Solution().reorderList(l1) ListNode.print_linked_list(l1) l1 = ListNode.build_linked_list([1]) Solution().reorderList(l1) ListNode.print_linked_list(l1) l1 = ListNode.build_linked_list([1,2,3,4,5,6]) Solution().reorderList(l1) ListNode.print_linked_list(l1) l1 = ListNode.build_linked_list([1,2,3,4,5,6,7])
class Solution: # @param head, a ListNode # @return a ListNode def deleteDuplicates(self, head): if head is None: return head new_head = head.__class__(0) new_head.next = head pre_last = new_head last = head current = head.next last_delete = None while current: if current.val == last.val: pre_last.next = current.next last_delete = current.val else: if last_delete != last.val: pre_last = last last = current current = current.next return new_head.next if __name__ == "__main__": from utils import ListNode head = ListNode.make_list([1, 1, 2, 2]) p = Solution().deleteDuplicates(head) print p
last = p p = next return last, head, p if k <= 1: return head result = None last = None p = head while p: new_head, new_tail, next = reverse(p, k) if p is head: result = new_head if last: last.next = new_head last = new_tail p = next return result if __name__ == '__main__': from utils import ListNode f = Solution().reverseKGroup print f(ListNode.make_list([1, 2, 3, 4, 5]), 2) print f(ListNode.make_list([1, 2, 3, 4, 5]), 3) print f(ListNode.make_list([1, 2, 3, 4, 5]), 1) print f(ListNode.make_list([1, 2, 3, 4, 5]), 0) print f(ListNode.make_list([1, 2, 3, 4, 5]), 4) print f(ListNode.make_list([1, 2, 3, 4, 5]), 5) print f(ListNode.make_list([1, 2, 3, 4, 5]), 6)
# count the length and get last_node length = 0 current = head while current: length += 1 if current.next is None: last_node = current current = current.next k = k % length if k == 0: return head idx = 0 current = head while current: if idx == length - k - 1: target_prev, target_current = current, current.next current = current.next idx += 1 new_head = target_current last_node.next = head target_prev.next = None return new_head if __name__ == '__main__': ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2,3,4,5]), 2)) ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2,3,4,5]), 3)) ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2,3,4,5]), 4)) ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2,3,4,5]), 5)) ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2,3,4,5]), 5)) ListNode.print_linked_list(Solution().rotateRight(ListNode.build_linked_list([1,2]), 2))
class Solution(object): def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ from heapq import heapify, heappop, heappush h = [(l.val, l) for l in lists if l] heapify(h) new_head = current = None while len(h): val, node = heappop(h) if node.next: heappush(h, (node.next.val, node.next)) if not new_head: current = new_head = node else: current.next = node current = node node.next = None return new_head if __name__ == '__main__': ListNode.print_linked_list(Solution().mergeKLists([b([1,3,5,7,9]), b([2,4,6,8,10]), b([12,14,15,17,19])])) ListNode.print_linked_list(Solution().mergeKLists([b([1,3,5,7,9]), b([2,4,6,8,10]), b([])])) ListNode.print_linked_list(Solution().mergeKLists([b([]), b([])])) ListNode.print_linked_list(Solution().mergeKLists([]))
class Solution(object): def rotateRight(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if not head: return head n = 0 p = head tail = p while p: tail = p p = p.next n += 1 tail.next = head k = k % n for i in xrange(n - k): tail = tail.next new_head = tail.next tail.next = None return new_head if __name__ == '__main__': f = Solution().rotateRight from utils import ListNode head = ListNode.make_list([1, 2, 3, 4, 5]) print f(head, 2)
return head elif m == n: return head c = 1 prev, current = None, head while current: if c == m: r_head_prev, r_head = prev, current prev, current = current, current.next elif m < c < n: next = current.next current.next = prev prev, current = current, next elif c == n: r_tail, r_tail_next = current, current.next current.next = prev prev, current = current, r_tail_next else: prev, current = current, current.next c += 1 if r_head_prev: r_head_prev.next = r_tail r_head.next = r_tail_next return head if m > 1 else r_tail if __name__ == '__main__': ListNode.print_linked_list(Solution().reverseBetween(ListNode.build_linked_list([1,2,3,4,5]), 2, 4)) ListNode.print_linked_list(Solution().reverseBetween(ListNode.build_linked_list([1,2,3,4,5]), 1, 4)) ListNode.print_linked_list(Solution().reverseBetween(ListNode.build_linked_list([1,2,3,4,5]), 1, 5)) ListNode.print_linked_list(Solution().reverseBetween(ListNode.build_linked_list([1,2,3,4,5]), 2, 2))
:rtype: ListNode """ if not l1 and not l2: return None l1_node, l2_node = l1, l2 l = dummy_new_head = ListNode(1) while l1_node and l2_node: if l1_node.val <= l2_node.val: l.next = ListNode(l1_node.val) l1_node = l1_node.next else: l.next = ListNode(l2_node.val) l2_node = l2_node.next l = l.next l.next = l1_node or l2_node return dummy_new_head.next if __name__ == "__main__": ListNode.print_linked_list(ListNode.build_linked_list([1,2,3])) #print_ListNode(Solution().mergeTwoLists(None, None)) #print_ListNode(Solution().mergeTwoLists(None, ListNode(1))) #print_ListNode(Solution().mergeTwoLists(build_ListNode([2]), build_ListNode([1]))) #print_ListNode(Solution().mergeTwoLists(build_ListNode([1]), build_ListNode([2]))) #print_ListNode(Solution().mergeTwoLists(build_ListNode([1,2,3]), build_ListNode([2, 5,7]))) ListNode.print_linked_list( Solution().mergeTwoLists( ListNode.build_linked_list([1, 2, 3]), ListNode.build_linked_list([2, 5, 7]) ) )
head.next = None while current: current_next = current.next if current.val < sorted_head.val: current.next = sorted_head sorted_head = current else: sorted_prev, sorted_current = sorted_head, sorted_head.next while sorted_current: if sorted_current.val > current.val: sorted_prev.next = current current.next = sorted_current break sorted_prev, sorted_current = sorted_current, sorted_current.next if current.val >= sorted_end.val: current.next = None sorted_end.next = current sorted_end = current current = current_next return sorted_head if __name__ == '__main__': ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([5,1,4,3,2]))) ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([1]))) ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([]))) ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([8,7]))) ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([8,7,1]))) ListNode.print_linked_list(Solution().insertionSortList(ListNode.build_linked_list([1])))
from utils import TreeNode, ListNode class Solution(object): def sortedListToBST(self, head): """ :type head: ListNode :rtype: TreeNode """ if head is None: return None fast, prev, slow = head, None, head while fast and fast.next: fast = fast.next.next prev, slow = slow, slow.next root = TreeNode(slow.val) if prev: prev.next = None else: return root root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(slow.next) return root if __name__ == '__main__': TreeNode.print_in_level_order(Solution().sortedListToBST(ListNode.build_linked_list([1,2]))) TreeNode.print_in_level_order(Solution().sortedListToBST(ListNode.build_linked_list([1]))) TreeNode.print_in_level_order(Solution().sortedListToBST(ListNode.build_linked_list([1,2,3,4,5,6]))) TreeNode.print_in_level_order(Solution().sortedListToBST(ListNode.build_linked_list([1,2,3,4,5]))) TreeNode.print_in_level_order(Solution().sortedListToBST(ListNode.build_linked_list([])))