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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
l1 = createListNode([5, 2, 4])
l2 = createListNode([5, 7, 5, 9])
sumList = sol.addTwoNumbers(l1, l2)
printListNode(sumList)
l1 = createListNode([5, 4, 3, 1])
l2 = createListNode([5, 7, 5, 2])
sumList = sol.addTwoNumbers(l1, l2)
printListNode(sumList)
except:
pass
# 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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, printListNode, createListNode
sol = Solution()
head = createListNode([1, 2, 3, 4, 5])
printListNode(sol.reverseBetween(head, 2, 4)) # 1 4 3 2 5
head = createListNode([1, 2, 3, 4, 5])
printListNode(sol.reverseBetween(head, 0, 3))
except:
pass
"""
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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode
from utils.TreeNode import TreeNode, printTreeNode
sol = Solution()
head = createListNode([1, 2, 3, 4, 5, 6])
printTreeNode(sol.sortedListToBST(head))
except Exception as e:
print(e)
: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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
l1 = createListNode([1, 3, 5, 7])
l2 = createListNode([2, 4, 6, 8])
printListNode(sol.mergeTwoLists(l1, l2))
except:
pass
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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
head = createListNode([1, 4, 3, 2, 5, 2])
printListNode(sol.partition(head, 3))
printListNode(sol.partition(None, 3))
except:
pass
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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
head = createListNode([1])
printListNode(sol.swapPairs(head))
head = createListNode([1, 2])
printListNode(sol.swapPairs(head))
head = createListNode([1, 2, 3, 4, 5, 6, 7])
printListNode(sol.swapPairs(head)) # Odd case
head = createListNode([1, 2, 3, 4, 5, 6])
printListNode(sol.swapPairs(head)) # Even case
except:
pass
head = head.next.next
while head and head.next:
p1.next = head
p2.next = head.next
head = head.next.next
p1 = p1.next
p2 = p2.next
if head and not head.next:
p1.next = head
p2.next = None
p1 = p1.next
p1.next = evenHead
return oddHead
if __name__ == "__main__":
try:
from utils.ListNode import createListNode, printListNode
sol = Solution()
root = createListNode([1, 2, 3, 4, 5, 6, 7, 8])
printListNode(sol.oddEvenList(root))
root = createListNode([1, 2, 3, 4, 5, 6, 7])
printListNode(sol.oddEvenList(root))
except Exception as e:
print(e)
# Rotate
if p1 != dummy:
dummy.next = p1.next
p1.next = None
p2.next = head
return dummy.next
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, printListNode, createListNode
sol = Solution()
arr = [1, 2, 3, 4, 5]
head = createListNode(arr)
printListNode(sol.rotateRight(head, 1))
arr = [1]
head = createListNode(arr)
printListNode(sol.rotateRight(head, 1))
arr = [1]
head = createListNode(arr)
printListNode(sol.rotateRight(head, 99))
arr = [1, 2]
head = createListNode(arr)
printListNode(sol.rotateRight(head, 1))
arr = [1, 2]
class Solution(object):
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head:
return None
node = head
while node.next:
if node.next.val == node.val:
node.next = node.next.next
else:
node = node.next
return head
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
head = createListNode([1, 1, 2, 2, 3])
printListNode(sol.deleteDuplicates(head))
head = createListNode([1, 2, 3])
printListNode(sol.deleteDuplicates(head))
head = createListNode([1])
printListNode(sol.deleteDuplicates(head))
except:
pass
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
if __name__ == "__main__":
try:
from utils.ListNode import ListNode, createListNode, printListNode
sol = Solution()
l1 = createListNode([7, 2, 4, 3])
l2 = createListNode([5, 6, 4])
printListNode(sol.addTwoNumbers(l1, l2))
except Exception as e:
print(e)
# Reverse second-half of linked list
prev, curr = None, slow
while curr:
temp = curr.next
curr.next = prev
curr, prev = temp, curr
# Compare and check palindrome
p1, p2 = head, prev
while p2:
if p1.val != p2.val:
return False
p1 = p1.next
p2 = p2.next
return True
if __name__ == "__main__":
try:
from utils.ListNode import createListNode, printListNode
sol = Solution()
arr = createListNode([1, 2, 2, 1])
print(sol.isPalindrome(arr) is True)
arr = createListNode([1, 2, 3, 2, 1])
print(sol.isPalindrome(arr) is True)
arr = createListNode([1, 2, 3, 4, 2, 1])
print(sol.isPalindrome(arr) is False)
except Exception as e:
print(e)
