class Solution(object): def rotateRight(self, head, k): # first pass: find length node, l = head, 0 while node != None: node = node.next l += 1 if l == 0: return head k = k % l if k == 0: return head # second pass fast = head while k > 0: fast = fast.next k -= 1 slow = head while fast.next != None: slow = slow.next fast = fast.next retval = slow.next slow.next = None fast.next = head return retval if __name__ == '__main__': l = generate_list([1, 2, 3]) print Solution().rotateRight(l, 2)
Given linked list: 1->2->3->4->5, and n = 2. After removing the second node from the end, the linked list becomes 1->2->3->5. Note: Given n will always be valid. Try to do this in one pass. ''' from structs.singly_linked_list import generate_list class Solution(object): def removeNthFromEnd(self, head, n): fast = slow = head for _ in xrange(n): fast = fast.next if not fast: # n == len(list) return head.next while True: fast = fast.next if fast: slow = slow.next else: slow.next = slow.next.next break return head if __name__ == '__main__': l = generate_list([1, 2]) print Solution().removeNthFromEnd(l, 2)
node = slow.next if node is None: return tmp = node.next node.next = slow.next = None while tmp is not None: tmp.next, node, tmp = node, tmp, tmp.next # pass 3: intertwine head, node l1, l2 = head, node while l2 is not None: l1.next, l1 = l2, l1.next if l1 is None: break l2.next, l2 = l1, l2.next if __name__ == '__main__': l = generate_list([1, 2, 3, 4, 5]) Solution().reorderList(l) print l l = generate_list([1, 2, 3, 4]) Solution().reorderList(l) print l l = generate_list([1, 2, 3]) Solution().reorderList(l) print l l = generate_list([1, 2]) Solution().reorderList(l) print l l = generate_list([1]) Solution().reorderList(l) print l l = generate_list([])
class Solution(object): def reverseKGroup(self, head, k): if k < 2: return head dummy = ListNode(0) dummy.next = head cur = dummy while True: node = cur for _ in xrange(k): node = node.next if node is None: break if node is None: break n1 = cur.next n2 = n1.next n3 = n2.next while True: n2.next = n1 if n2 is node: break n1, n2, n3 = n2, n3, n3.next n1 = cur.next n1.next = n3 cur.next = n2 cur = n1 return dummy.next if __name__ == '__main__': l = generate_list([]) print Solution().reverseKGroup(l, 2)
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. ''' from Queue import PriorityQueue from structs.singly_linked_list import ListNode, generate_list class Solution(object): def mergeKLists(self, lists): q = PriorityQueue() for l in lists: if l: q.put((l.val, l)) head = tail = ListNode(0) while True: try: _, l = q.get(block=False) except: break tail.next = l tail = l l = l.next if l: q.put((l.val, l)) return head.next if __name__ == '__main__': l1 = generate_list([0]) l2 = generate_list([1, 2]) l3 = generate_list([]) print Solution().mergeKLists([l1])
class Solution(object): def mergeTwoLists(self, l1, l2): if l1 is None: return l2 if l2 is None: return l1 if l1.val < l2.val: head = tail = l1 l1 = l1.next else: head = tail = l2 l2 = l2.next while l1 and l2: if l1.val < l2.val: tail.next = l1 tail = l1 l1 = l1.next else: tail.next = l2 tail = l2 l2 = l2.next if l1 is None: tail.next = l2 elif l2 is None: tail.next = l1 return head if __name__ == '__main__': l1 = generate_list([1]) l2 = generate_list([]) print Solution().mergeTwoLists(l1, l2)
l2 = l2.next elif l1 is not None and l2 is None: v = l1.val + z if v <= 9: node = ListNode(v) prev.next = node node.next = l1.next return result else: v -= 10 z = 1 node = ListNode(v) prev.next = node prev = node l1 = l1.next else: if z == 0: prev.next = None return result else: node = ListNode(z) prev.next = node node.next = None return result if __name__ == '__main__': l1 = generate_list([9, 9, 9, 9, 9]) l2 = generate_list([1, 0, 0, 0, 0, 1]) print Solution().addTwoNumbers(l1, l2)
tmp = node node = node.next tmp.next = head head = tmp else: p = head while p.next and p.next.val < node.val: p = p.next tmp = node node = node.next tmp.next = p.next p.next = tmp return head if __name__ == '__main__': l = generate_list([3, 2, 1]) print Solution().insertionSortList(l) l = generate_list([1, 2, 3]) print Solution().insertionSortList(l) l = generate_list([4, 3, 1, 2]) print Solution().insertionSortList(l) l = generate_list([1]) print Solution().insertionSortList(l) l = None print Solution().insertionSortList(l) l = generate_list([2, 6, 4, 9, 1, 3, 7, 2, 3]) print Solution().insertionSortList(l) l = generate_list(range(5000)) l = Solution().insertionSortList(l)
def test2(self): l = generate_list([1]) self.assertEqual(str(Solution().reverseList(l)), str(l))
def test1(self): l1 = generate_list([1, 2, 3, 4, 5]) l2 = generate_list([5, 4, 3, 2, 1]) self.assertEqual(str(Solution().reverseList(l1)), str(l2))
slow = slow.next try: fast = fast.next.next except: return None slow, fast = headA, fast.next while slow != fast: slow = slow.next fast = fast.next return slow finally: tail.next = None if __name__ == '__main__': l1 = generate_list([1, 2, 6, 7, 8]) l2 = generate_list([3, 4, 5]) l2.next.next.next = l1.next.next print l1 print l2 print Solution().getIntersectionNode(l1, l2) print '-' * 20 l1 = generate_list([3, 4, 5]) l2 = generate_list([1, 2]) l2.next.next = l1 print l1 print l2 print Solution().getIntersectionNode(l1, l2) print Solution().getIntersectionNode(l2, l1) print '-' * 20 l1 = generate_list([1, 2, 3])
''' from structs.singly_linked_list import generate_list, ListNode class Solution(object): def reverseBetween(self, head, m, n): dummy = ListNode(0) dummy.next = head start = dummy n -= m while m > 1: start = start.next m -= 1 end = snx = start.next nx = end.next while n > 0: pre = end end = nx nx = nx.next end.next = pre n -= 1 start.next = end snx.next = nx return dummy.next if __name__ == '__main__': l = generate_list([1, 2, 3, 4, 5]) print Solution().reverseBetween(l, 1, 2)