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)