# 206. Reverse Linked List
# Reverse a singly linked list.
# Example:
# Input: 1->2->3->4->5->NULL
# Output: 5->4->3->2->1->NULL
from leetcode.listnode import lst2link, link2Lst
def reverseList(head: 'ListNode') -> 'ListNode':
cur = head
pre = None
while cur:
tmp = cur.next
cur.next = pre
pre = cur
cur = tmp
return pre
head = lst2link([1, 2, 3, 4, 5])
p = reverseList(head)
print(link2Lst(p))
# The given linked list will contain between 1 and 1000 nodes.
# Each node in the linked list has -1000 <= node.val <= 1000.
#
#
#
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
import collections
from leetcode.listnode import ListNode, lst2link, link2Lst
def removeZeroSumSublists(head: ListNode) -> ListNode:
cur = dummy = ListNode(0)
dummy.next = head
prefix = 0
seen = collections.OrderedDict()
while cur:
prefix += cur.val
node = seen.get(prefix, cur)
while prefix in seen:
seen.popitem()
seen[prefix] = node
node.next = cur = cur.next
return dummy.next
print(link2Lst(removeZeroSumSublists(lst2link([1,3,2,-3,-2,5]))))
print(link2Lst(removeZeroSumSublists(lst2link([1,3,2,-3,-2,5,5,-5,1]))))
pre = dummy = ListNode(0)
cur = dummy.next = head
while cur:
while cur.next and cur.val == cur.next.val:
cur = cur.next
if pre.next is cur:
pre = cur
else:
pre.next = cur.next
cur = cur.next
return dummy.next
# leaving only distinct numbers from the original list.
def deleteDuplicates1(head):
"""
:type head: ListNode
:rtype: ListNode
"""
cur = head
while cur:
while cur.next and cur.val == cur.next.val:
cur.next = cur.next.next
cur = cur.next
return head
p = lst2link([-1, 1,1,1,2,2,3,3,5])
q = deleteDuplicates2(p)
print(link2Lst(q))
# 21. Merge Two Sorted Lists
# Merge two sorted linked lists and return it as a new list.
# The new list should be made by splicing together the nodes of the first two lists.
# Example:
# Input: 1->2->4, 1->3->4
# Output: 1->1->2->3->4->4
from leetcode.listnode import lst2link, ListNode, print_link
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:
dummy = cur = ListNode(0)
while l1 and l2:
if l1.val < l2.val:
cur.next = l1
l1 = l1.next
else:
cur.next = l2
l2 = l2.next
cur = cur.next
cur.next = l1 or l2
return dummy.next
l1 = lst2link([1, 2, 4])
l2 = lst2link([1, 3, 4])
print_link(mergeTwoLists(l1, l2))
def sortedListToBST1(head: 'ListNode') -> 'TreeNode':
def link2Lst(head):
cur = head
result = []
while cur:
result.append(cur.val)
cur = cur.next
return result
def sortedArrayToBST(nums: 'List[int]') -> 'TreeNode':
if not nums:
return None
p = len(nums) // 2
root = TreeNode(nums[p])
root.left = sortedArrayToBST(nums[:p])
root.right = sortedArrayToBST(nums[p + 1:])
return root
if not head:
return None
nums = link2Lst(head)
return sortedArrayToBST(nums)
p = lst2link([-10, -3, 0, 5, 9])
print(treeNodeToLst(sortedListToBST(p)))
p = lst2link([-10, -3, 0, 5, 9])
print(treeNodeToLst(sortedListToBST1(p)))