时间复杂度O(N）空间复杂度O(1)
'''
def removeZeroSumSublists(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None:
return None
dummy = ListNode(0)
dummy.next = head
diff = {}
sum = 0
node = dummy
while node:
sum += node.val
diff[sum] = node
node = node.next
sum = 0
node = dummy
while node:
sum += node.val
node.next = diff[sum].next
node = node.next
return dummy.next
l = make_linkedlist([1, 2, 3, -3, -2])
show_linkedlist(Solution().removeZeroSumSublists(l))
prev = dummy
count = 0
node = prev.next
while node:
count += 1
if count % 2 == 0:
prev = self.swap(prev, node)
node = prev.next
else:
node = node.next
show_linkedlist(dummy.next)
def swap(self, start, end):
prev = start
head = start.next
tail = end.next
cur, next = head, head.next
while cur is not end:
head.next = next.next
next.next = cur
cur = next
next = head.next
prev.next = cur
head.next = tail
return head
l = make_linkedlist([1, 2, 3, 4, 5])
Solution().swapPairs(l)
拼接K个链表
解题思路：
顺序拼接每个链表，变成子问题位拼接2个链表的问题，时间复杂度O（KKN）， 空间复杂度O（1），
'''
# def mergeKLists(self, lists):
# """
# :type lists: List[ListNode]
# :rtype: ListNode
# """
# if lists is None:
# return None
# if len(lists) == 0:
# return None
# if len(lists) == 1:
# return lists[0]
#
# merged = None
# for n in lists:
# merged = self.mergeTwo(n, merged)
# show_linkedlist(merged)
# return merged
#
#
l1 = [1, 4, 5]
l2 = [1, 3, 4]
l3 = [2, 6]
n1 = make_linkedlist(l3)
n2 = make_linkedlist(l2)
n3 = make_linkedlist(l1)
Solution().mergeKLists([n1, n2, n3])
class Solution(object):
'''
单调栈，维护一个索引栈一个元素栈
时间复杂度O（N）空间复杂度O（N）
'''
def nextLargerNodes(self, head):
"""
:type head: ListNode
:rtype: List[int]
"""
stack = []
location = []
ans = []
loc = -1
node = head
while node:
loc += 1
ans.append(0)
while stack and stack[-1] < node.val:
ans[location[-1]] = node.val
stack.pop()
location.pop()
stack.append(node.val)
location.append(loc)
node = node.next
return ans
l = make_linkedlist([1, 7, 5, 1, 9, 2, 5, 1])
Solution().nextLargerNodes(l)
dummy = ListNode(0)
dummy.next = head
node = dummy
count = 0
while node and count != m - 1:
node = node.next
count += 1
print(node.val)
self.reverse(node, n - m)
return dummy.next
def reverse(self, prev, size):
head = prev.next
cur = head
next = cur.next
count = 0
while cur and count != size:
head.next = next.next
next.next = cur
cur = next
next = head.next
count += 1
prev.next = cur
l = make_linkedlist([1,2])
show_linkedlist(Solution().reverseBetween(l, 1,2))
extra = 0
dummy = ListNode(0)
head = dummy
while l1 or l2:
if l1:
n1 = l1.val
else:
n1 = 0
if l2:
n2 = l2.val
else:
n2 = 0
res = (n1 + n2 + extra) % 10
extra = (n1 + n2 + extra) // 10
dummy.next = ListNode(res)
if l1:
l1 = l1.next
if l2:
l2 = l2.next
dummy = dummy.next
if extra != 0:
dummy.next = ListNode(extra)
return head.next
l1 = make_linkedlist([9, 9])
l2 = make_linkedlist([1])
l3 = Solution().addTwoNumbers(l1, l2)
show_linkedlist(l3)
class Solution(object):
'''
快慢指针 + 虚拟头结点，确保头结点可以删除第一个头结点
'''
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
if head is None:
return None
if head.next is None and n == 1:
return None
count = 0
dummy = ListNode(0)
dummy.next = head
node, cur = dummy, dummy
while node:
if count > n:
cur = cur.next
node = node.next
count += 1
cur.next = cur.next.next
return dummy.next
l = make_linkedlist([1])
show_linkedlist(Solution().removeNthFromEnd(l, 1))
:rtype: List[ListNode]
"""
node = root
size = 0
while node:
size += 1
node = node.next
length = size // k
rest = size % k
parts = []
cur = root
for _ in range(k):
head = cur
count = length
if rest > 0:
count += 1
rest -= 1
for _ in range(count - 1):
if cur:
cur = cur.next
if cur:
cur.next, cur = None, cur.next
parts.append(head)
return parts
l = make_linkedlist([1, 2, 3])
nodes = Solution().splitListToParts(l, 5)
print(nodes)
# if head is None or head.next is None:
# return head
#
# node = head
# total = {}
# while node:
# if node.val not in total:
# total[node.val] = 1
# else:
# total[node.val] += 1
# node = node.next
#
# dummy = ListNode(0)
# dummy.next = head
# prev, cur = dummy, head
#
# while cur:
# if total[cur.val] > 1:
# prev.next = cur.next
# cur = prev.next
# else:
# prev = prev.next
# cur = cur.next
#
# return dummy.next
l = make_linkedlist([1,2,2,3,3,4,4,5,5,5,6])
show_linkedlist(Solution().deleteDuplicates(l))
return head.next
'''
分治法自顶向下递归分裂链表，排序合并
时间复杂度O（nlogn)空间复杂度O（N）
'''
# def sortList(self, head):
# """
# :type head: ListNode
# :rtype: ListNode
# """
# return self.divide(head)
#
# def divide(self, head):
# if head is None or head.next is None:
# return head
#
# fast, slow = head, head
# while fast.next and fast.next.next:
# slow = slow.next
# fast = fast.next.next
# head2 = slow.next
# slow.next = None
# h1 = self.divide(head)
# h2 = self.divide(head2)
# return self.merge(h1, h2)
#
l = make_linkedlist([4, 2, 1, 3])
show_linkedlist(Solution().sortList(l))
stack2 = []
while l1 or l2:
if l1:
stack1.append(l1.val)
l1 = l1.next
if l2:
stack2.append(l2.val)
l2 = l2.next
dummy = ListNode(0)
extra = 0
while stack1 or stack2:
n1 = stack1.pop() if stack1 else 0
n2 = stack2.pop() if stack2 else 0
sum = n1 + n2 + extra
node = ListNode(sum % 10)
extra = sum // 10
node.next = dummy.next
dummy.next = node
if extra != 0:
node = ListNode(extra)
node.next = dummy.next
dummy.next = node
return dummy.next
l1 = make_linkedlist([9,9,9,9,9])
l2 = make_linkedlist([5,6,4])
show_linkedlist(Solution().addTwoNumbers(l1, l2))
class Solution(object):
'''
拿到一个节点将节点拼入新的链表
时间复杂度O（N）空间复杂度O（1）
'''
def insertionSortList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return head
dummy = ListNode(-0)
cur = dummy
node = head
while node:
if cur.next is None or cur.next.val > node.val:
prev = node.next
node.next = cur.next
cur.next = node
cur = dummy
node = prev
else:
cur = cur.next
return dummy.next
l = make_linkedlist([-1, 5, 3, 4, 0])
show_linkedlist(Solution().insertionSortList(l))
时间复杂度O（N）空间复杂度O（1）
'''
def partition(self, head, x):
"""
:type head: ListNode
:type x: int
:rtype: ListNode
"""
if head is None or head.next is None:
return head
large = ListNode(0)
l_node = large
small = ListNode(0)
s_node = small
node = head
while node:
if node.val < x:
s_node.next = node
s_node = s_node.next
else:
l_node.next = node
l_node = l_node.next
node = node.next
l_node.next = None
s_node.next = large.next
return small.next
l = make_linkedlist([1, 4, 3, 2, 5, 2])
show_linkedlist(Solution().partition(l, 3))
