def swapPairs_bad(self, head: ListNode) -> ListNode:
if not head.next:
return head
tail = ListNode()
result = tail
node_stack = []
next_node = head
while next_node:
node_stack.append(next_node)
next_node = next_node.next
if len(node_stack) == 2:
node_1 = node_stack.pop()
node_2 = node_stack.pop()
tail.next = node_1
node_1.next = node_2
node_2.next = next_node
tail = node_2
return result.next
def _merge(self, head1: ListNode, head2: ListNode):
res = ListNode()
ptr = res
while head1 and head2:
ptr.next = head1
head1 = head1.next
ptr.next.next = head2
head2 = head2.next
ptr = ptr.next.next
ptr.next = head2
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
"""
Idea:
Make a function to reverse ListNode from start to end and return the head and tail after reverse
Call the function between k nodes
Use iteration to prevent using extra memory
"""
if k == 1:
return head
def reverse(start: ListNode,
end: ListNode) -> Tuple[ListNode, ListNode]:
p = start
pv = ListNode()
while p and pv != end:
ne = p.next
p.next = pv
pv = p
p = ne
return end, start
res = ListNode()
res.next = head
prev = res
ptr = head
depth = 0
while ptr:
if depth == k - 1:
n = ptr.next
head, tail = reverse(prev.next, ptr)
prev.next = head
tail.next = n
prev = ptr
ptr = n
depth = 0
else:
ptr = ptr.next
depth += 1
return res.next
def reverse(start: ListNode,
end: ListNode) -> Tuple[ListNode, ListNode]:
p = start
pv = ListNode()
while p and pv != end:
ne = p.next
p.next = pv
pv = p
p = ne
return end, start
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
dummy = ListNode(0) # construct a dummy node
dummy.next = head
pre = dummy # set up pre and cur pointers
cur = head
while cur:
if cur.next and cur.val == cur.next.val:
# loop until cur point to the last duplicates
while cur and cur.next and cur.val == cur.next.val:
cur = cur.next
pre.next = cur.next # propose the next for pre
# this will be verified by next line
else:
pre = pre.next
cur = cur.next
return dummy.next
def swapPairs(self, head):
"""
From https://leetcode.com/problems/swap-nodes-in-pairs/discuss/11019/7-8-lines-C%2B%2B-Python-Ruby Here,
pre is the previous node. Since the head doesn't have a previous node, I just use self instead. Again,
a is the current node and b is the next node.
To go from pre -> a -> b -> b.next to pre -> b -> a -> b.next, we need to change those three references.
Instead of thinking about in what order I change them, I just change all three at once.
"""
result = ListNode()
pre, pre.next = result, head
while pre.next and pre.next.next:
a = pre.next
b = a.next
pre.next, b.next, a.next = b, a, b.next
pre = a
return result.next
def merge2List(self, head1: ListNode, head2: ListNode) -> ListNode:
res = ListNode()
ptr = res
while head1 and head2:
if head1.val < head2.val:
ptr.next = head1
head1 = head1.next
else:
ptr.next = head2
head2 = head2.next
ptr = ptr.next
if head1:
ptr.next = head1
elif head2:
ptr.next = head2
return res.next
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
head = ListNode(0)
ptr = head
while l1 and l2:
if l1.val > l2.val:
ptr.next = l2
l2 = l2.next
else:
ptr.next = l1
l1 = l1.next
ptr = ptr.next
if l1:
ptr.next = l1
elif l2:
ptr.next = l2
return head.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
"""
Idea:
1. Find out the length of each list so that we can align two linkedlist
2. Add nodes that are in the same level together and reverse it
3. Deal with the carry
4. return the reversed linkedlist
"""
if not l1 and not l2:
return ListNode()
if not l1:
return l2
if not l2:
return l1
# get the size of both linked list
size_1, size_2 = 0, 0
ptr_1, ptr_2 = l1, l2
while ptr_1:
size_1 += 1
ptr_1 = ptr_1.next
while ptr_2:
size_2 += 1
ptr_2 = ptr_2.next
# add nodes that are in the same level
res = ListNode()
ptr_1, ptr_2, res_ptr = l1, l2, res
while size_1 or size_2:
if size_1 == size_2:
res_ptr.next = ListNode(ptr_1.val + ptr_2.val)
ptr_1 = ptr_1.next
ptr_2 = ptr_2.next
res_ptr = res_ptr.next
size_1 -= 1
size_2 -= 1
elif size_1 > size_2:
res_ptr.next = ListNode(ptr_1.val)
ptr_1 = ptr_1.next
res_ptr = res_ptr.next
size_1 -= 1
else:
res_ptr.next = ListNode(ptr_2.val)
ptr_2 = ptr_2.next
res_ptr = res_ptr.next
size_2 -= 1
last = self.reverse_LinkedList(res.next) # flip the res
# deal with carry
carry = 0
last_ptr = last
prev = None
while last_ptr:
last_ptr.val += carry
carry = last_ptr.val // 10
last_ptr.val %= 10
prev = last_ptr
last_ptr = last_ptr.next
if carry:
prev.next = ListNode(carry)
return self.reverse_LinkedList(last)