def reverseBetween(self, head, m, n):
"""
:type head: ListNode
:type m: int
:type n: int
:rtype: ListNode
"""
if m == n:
return head
dummy = ListNode(0)
dummy.next = head
# p1 points to (m-1)th node
p1 = dummy
for i in range(m - 1):
p1 = p1.next
# Reverse node from position m to n
pre, curr = None, p1.next
for i in range(n - m + 1):
temp = curr.next
curr.next = pre
pre, curr = curr, temp
# Let original mth node points to (n+1)th node
p1.next.next = curr
# Let original (m-1)th node points to nth node
p1.next = pre
return dummy.next
def main():
l1 = ListNode.from_str("1 2 8 4")
l2 = ListNode.from_str("2 0 3")
ans = ListNode.from_str("3 2 1 5")
result = addTwoNumbers(l1, l2)
print(f"{l1} + {l2} = {result}")
assert result == ans
def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:
carry, sum_val = divmod(l1.val + l2.val, 10)
ret = ListNode(sum_val)
ret_ptr = ret
zero = ListNode(0)
while True:
if l1.next is None and l2.next is None and carry == 0:
break
l1 = l1.next if l1.next else zero
l2 = l2.next if l2.next else zero
carry, sum_val = divmod(l1.val + l2.val + carry, 10)
ret_ptr.next = ListNode(sum_val)
ret_ptr = ret_ptr.next
return ret
def swapPairs(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
dummy = ListNode(0)
dummy.next = head
curr = dummy
while curr.next and curr.next.next:
p1, p2 = curr.next, curr.next.next
p1.next = p2.next
p2.next = p1
curr.next = p2
curr = curr.next.next
return dummy.next
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
dummy = ListNode(0)
dummy.next = head
p1, p2 = head, dummy
for _ in range(n):
p1 = p1.next
while p1:
p1 = p1.next
p2 = p2.next
p2.next = p2.next.next
return dummy.next
def removeElements(self, head, val):
"""
:type head: ListNode
:type val: int
:rtype: ListNode
"""
if not head:
return None
dummy = ListNode(0)
dummy.next = head
current = dummy
while current:
while current.next and current.next.val == val:
current.next = current.next.next
current = current.next
return dummy.next
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
p1, p2 = l1, l2
len1, len2 = 0, 0
while p1 or p2:
if p1:
p1, len1 = p1.next, len1 + 1
if p2:
p2, len2 = p2.next, len2 + 1
dummy = ListNode(0)
curr = dummy
size = max(len1, len2)
while size:
val = 0
if size <= len1:
val += l1.val
l1 = l1.next
if size <= len2:
val += l2.val
l2 = l2.next
curr.next = ListNode(val)
curr = curr.next
size -= 1
prev = dummy
while prev:
curr = prev.next
while curr and curr.val == 9:
curr = curr.next
while prev != curr:
if curr and curr.val > 9:
prev.val += 1
prev.next.val -= 10
prev = prev.next
if dummy.val:
return dummy
return dummy.next
def partition(self, head, x):
"""
:type head: ListNode
:type x: int
:rtype: ListNode
"""
h1 = ListNode(0)
h2 = ListNode(0)
p1, p2 = h1, h2
while head:
if head.val < x:
p1.next = head
p1 = p1.next
else:
p2.next = head
p2 = p2.next
head = head.next
p1.next = h2.next
p2.next = None
return h1.next
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
dummy = ListNode(0)
node = dummy
carry = 0
while l1 or l2:
carry = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
node.next = ListNode(carry % 10)
carry //= 10
node = node.next
if l1:
l1 = l1.next
if l2:
l2 = l2.next
if carry:
node.next = ListNode(carry)
return dummy.next
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
if not head:
return None
dummy = ListNode(0)
dummy.next = head
p1, p2 = dummy, head
while p2 and p2.next:
p1 = p1.next
p2 = p2.next.next
mid = p1.next
p1.next = None
root = TreeNode(mid.val)
if head != mid:
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(mid.next)
return root
def rotateRight(self, head, k):
"""
:type head: ListNode
:type k: int
:rtype: ListNode
"""
if not head or k == 0:
return head
dummy = ListNode(0)
dummy.next = head
# Get list size
p2, size = dummy, 0
while p2.next:
p2 = p2.next
size += 1
# Update k
k = (k - 1) % size + 1
# Find last k-th node
p1, p2 = dummy, dummy
for i in range(k):
p2 = p2.next
while p2.next:
p1 = p1.next
p2 = p2.next
# Rotate
if p1 != dummy:
dummy.next = p1.next
p1.next = None
p2.next = head
return dummy.next
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
dummy = ListNode(0)
curr = dummy
while l1 and l2:
if l1.val > l2.val:
curr.next = l2
l2, curr = l2.next, curr.next
else:
curr.next = l1
l1, curr = l1.next, curr.next
if l1:
curr.next = l1
elif l2:
curr.next = l2
return dummy.next
def test_list_node_to_str():
ln = ListNode.from_str("1 2 3")
assert str(ln) == "1 -> 2 -> 3"
def test_list_node_from_str():
l1 = ListNode.from_str("1 2 3")
l2 = ListNode(1)
l2.next = ListNode(2)
l2.next.next = ListNode(3)
assert l1 == l2