常见双指针技巧用法，只总结思路，具体边界判定想不清楚的时候稍微画个图就行了
1. 快慢指针判断链表是否含有环、环入口（快慢指针再次相遇即有环；再从头节点和快慢指针的相遇位置同速度向后，相遇点即为环入口）。
2. 快慢指针找链表中点、倒数第k个元素（快指针到达 Null 时慢指针所处位置即为中点；快指针先走k步，然后和慢指针一起同速度向后，快指针到达 Null 时慢指针的位置就是倒数第k个节点）。
3. 左右指针二分查找、在有序数组中找两数之和、反转数组
4. 滑动窗口，典型题包括 #76、#438、#3
76. 最小覆盖子串 https://leetcode-cn.com/problems/minimum-window-substring/
给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。
示例：
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
说明：
如果 S 中不存这样的子串，则返回空字符串 ""。
如果 S 中存在这样的子串，我们保证它是唯一的答案。
解：
可以用滑动窗口技巧，left 和 right 指针都初始化为0，然后 right 向右滑动直到 s[left, ..., right] 中包括了T串中所有的字符，就得到一个可能的解，再令 left 右滑收紧窗口直到不能满足包括T串所有字符。
from collections import Counter
class Solution:
def minWindow(self, s: str, t: str) -> str:
if not s or not t:
return ''
dict_t = Counter(t)
required = len(dict_t) # 一共需要满足条件的字符数
l, r = 0, 0
formed = 0 # window中已经满足条件的字符数
window = {}
ans = float("inf"), None, None # (window length, left, right)
while r < len(s):
char = s[r]
window[char] = window.get(char, 0) + 1
if char in dict_t and window[char] == dict_t[char]:
formed += 1
while l <= r and formed == required: # 满足的window，记录结果后，需要右移left
char = s[l]
if r-l+1 < ans[0]:
ans = (r-l+1, l, r)
window[char] -= 1
if char in dict_t and window[char] < dict_t[char]:
formed -= 1
l += 1
r += 1
return '' if ans[0] == float("inf") else s[ans[1]: ans[2]+1]
438.找到字符串中所有字母异位词 https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/
给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。
字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。
说明：
字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
解：
依然是滑动窗口的思路，只不过现在窗口中进哈希表的元素，必须在模式串中（这样比较方便）。最大的差别还是在，既要满足所有模式串中的key的value都相等（多一个少一个都不行），窗口长度又必须等于模式串长度。
from collections import Counter
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
if not s:
return []
dict_p = Counter(p)
required = len(dict_p)
l, r = 0, 0
formed = 0
window = {}
res = []
while r < len(s):
char = s[r]
if char in dict_p:
window[char] = window.get(char, 0) + 1
if window[char] == dict_p[char]:
formed += 1
while l <= r and formed == required:
if r - l + 1 == len(p):
res.append(l)
char = s[l]
if char in dict_p:
window[char] -= 1
if window[char] < dict_p[char]:
formed -= 1
l += 1
r += 1
return res
189. 旋转数组 https://leetcode-cn.com/problems/rotate-array/
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
说明:
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。
解：
如果空间复杂度可以是O(n)的话，先把数组转成环形链表，然后把第n-k个节点的next断开，以第n-k+1个节点开始往后扫一边，得到数组。
暴力，先想一下k=1的情况，把最后一个拿出来，然后依次后移。插k次就行了，O(kN)，超时。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
for _ in range(k):
tmp = nums[-1]
for i in range(len(nums)-1, 0, -1):
nums[i] = nums[i-1]
nums[0] = tmp
return
# python 中用列表是动态数组，可以通过
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
n = len(nums)
k = k % n # 先 mod n 一下，避免k大于n
for _ in range(k):
nums.insert(0, nums.pop())
# 再来一个python独享的moment，直接用列表切片来操作
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
n = len(nums)
k = k % n # 先 mod n 一下，避免k大于n
nums[:] = nums[-k:] + nums[:-k]
如果重复做k次超时，干脆一步到位，直接把元素放到对应位置，O(N)
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
n = len(nums)
k = k % n # 先 mod n 一下，避免k大于n
step = 0
start = 0
while step < n:
cur = start
prev_val = nums[start] # 第一个要跳的数
while True: # 没有回到开始的点的话就一直跳数即可
nex = (cur + k) % n
tmp = nums[nex] # 暂存被跳过来的数占位置的数
nums[nex] = prev_val
prev_val = tmp # tmp是下一个要跳位置的数
step += 1 # 统计已经移动了多少个数
cur = nex # 更新游标cur
if cur == start:
break
start += 1
return
最简单直接的解法，把数组两部分分别反转，然后再整个数组反转一次。类似于谷歌面试题，一句话：A cycle of boom and bust. 倒装成：bust and boom of cycle A. 原地倒装，不允许使用额外存储空间。先全部反转，然后每个单词分别反转即可。
# python 超精简操作
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
n = len(nums)
k = k % n # 先 mod n 一下，避免k大于n
nums[-k:] = nums[-k:][::-1]
nums[:-k] = nums[:-k][::-1]
nums[:] = nums[::-1]
# 写一下原地交换
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums or k == 0:
return
n = len(nums)
k = k % n # 先 mod n 一下，避免k大于n
self.helper(nums, 0, n-1)
self.helper(nums, 0, k-1)
self.helper(nums, k, n-1)
def helper(self, nums, start, end):
if start >= end:
return
nums[start], nums[end] = nums[end], nums[start]
self.helper(nums, start+1, end-1)
# 直接用迭代可能会快一点
def helper(self, nums, start, end):
if start >= end:
return
mid = start + (end-start)//2
for i in range(start, mid + 1):
nums[i], nums[end-(i-start)] = nums[end-(i-start)], nums[i]
206. 反转链表 https://leetcode-cn.com/problems/reverse-linked-list/
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
解：
迭代实现，从第二个节点开始头插，反转整个链表。或者换个思路，只需要把每个指针的指向调转一下即可。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if head is None or head.next is None:
return head
pre = head
p = head.next
while p: # 头插
pre.next = p.next
p.next = head
head = p
p = pre.next
return head
# 按照简单调转指针的思路，把代码精简一下
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return head
cur, prev = head, None
while cur:
cur.next, prev, cur = prev, cur, cur.next
return prev
递归实现
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if head is None or head.next is None:
return head
reverse_head = self.reverseList(head.next)
# 此时 head 指向reverse_head链的尾节点
head.next.next = head
head.next = None
return reverse_head
141. 环形链表 https://leetcode-cn.com/problems/linked-list-cycle/
给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
解：
设置一个比如1s的时间限制，硬解，如果没有遍历到链尾，说明有环（权当开拓一下思路。。。。）
哈希集合存已经遍历过的节点，对新节点进行 O(1) 复杂度判重，空间换时间
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
if head is None or head.next is None:
return False
hashset = set()
p = head
while p:
if p in hashset:
return True
else:
hashset.add(p)
p = p.next
return False
快慢指针，如果相遇说明有环，记录相遇位置。从头节点和相遇点同速度向后遍历，相遇点即为环入口。
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
if head is None or head.next is None:
return False
slow = head
quick = head
while quick and quick.next:
slow = slow.next
quick = quick.next.next
if slow is quick:
return True
return False
24. 两两交换链表中的节点 https://leetcode-cn.com/problems/swap-nodes-in-pairs/
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
解：
迭代实现，需要一个pre始终指向新链表的head，游标指向每两个一组的前驱，向后遍历并两两交换
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
if head is None or head.next is None:
return head
pre = ListNode(0)
pre.next = head
p = pre
while p.next and p.next.next:
tmp = p.next
p.next = tmp.next
tmp.next = tmp.next.next
p.next.next = tmp # 交换 p.next 和p.next.next
p = tmp # 下一组两个的前驱
return pre.next
递归实现
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
if head is None or head.next is None:
return head
# 递归，先把head开始的两个之后的链表处理完, head指向子链表的头节点，head.next指向head，head.next为新的头节点
p = head.next
head.next = self.swapPairs(p.next)
p.next = head
return p
142. 环形链表 https://leetcode-cn.com/problems/linked-list-cycle-ii/
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
解：
基本和 #141 的两种思路一致，找到环入口即可。
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def detectCycle(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return None
visited = set() # hashset
p = head
while p:
if p in visited:
return p
visited.add(p)
p = p.next
return None
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def detectCycle(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return None
intersect = self.getIntersect(head)
if not intersect:
return None
p1 = head
p2 = intersect
while p1 != p2:
p1 = p1.next
p2 = p2.next
return p1
def getIntersect(self, head):
if head is None or head.next is None:
return None
slow = head
quick = head
while quick and quick.next:
slow = slow.next
quick = quick.next.next
if slow is quick:
return slow
return None
25. K个一组翻转链表 https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
示例 :
给定这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
说明 :
你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
解：
迭代实现，每K个一组，尾插法实现翻转，如果一组不够K个就不用操作
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def reverseKGroup(self, head, k):
"""
:type head: ListNode
:type k: int
:rtype: ListNode
"""
if head is None or head.next is None or k<=1:
return head
p = ListNode(0)
p.next = head # p始终指向链表头节点
pre = p
tail = p # pre, tail 都指向第一组的head
while True:
count = k
while count and tail:
count -= 1
tail = tail.next # 如果剩余节点超过k，tail应指向这一组第k位置节点
if not tail: # 如果剩余节点不足k，tail为空，不需要翻转
break
# 翻转；尾插法，始终插到tail后面
head = pre.next # 当前组原本的头节点
while pre.next != tail: # 只要pre（前一组最后一个）没指向当前组第k位置节点，一直尾插
cur = pre.next
pre.next = cur.next # 把要尾插的节点拿掉
cur.next = tail.next # 尾插
tail.next = cur
pre = head # pre 和 tail 都指向下一组的第一个节点
tail = head
return p.next
迭代实现，用栈实现翻转
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def reverseKGroup(self, head, k):
"""
:type head: ListNode
:type k: int
:rtype: ListNode
"""
if head is None or head.next is None or k<=1:
return head
prev = ListNode(0) # 始终指向链表头节点
prev.next = head
p = prev
while True:
count = k
stack = [] # 用栈实现k个一组的翻转
tmp = head # 从这一组的head开始往后入栈，结束以后tmp为下一组的head
while count and tmp:
stack.append(tmp)
tmp = tmp.next
count -= 1
if count: # 链表剩下不够k个，跳出循环，上一组最后一个节点p接上这一组的head
p.next = head
break
# 翻转，这一组k个节点出栈，循环结束时 p 指向当前组的最后一个节点
while stack:
p.next = stack.pop()
p = p.next
p.next = tmp # 当前组的最后一个指向下一组的head
head = tmp # 更新 head 记录
return prev.next
21. 合并两个有序链表 https://leetcode-cn.com/problems/merge-two-sorted-lists/
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
解：
双指针实现。虚拟头节点是一个比较好的技巧，能够减少复杂的边界判定。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return None
if not l2:
return l1
if not l1:
return l2
new_head_pre = ListNode(0) # 虚拟头节点
p1, p2, p = l1, l2, new_head_pre
while p1 and p2:
if p1.val < p2.val:
p.next = p1
p = p.next
p1 = p1.next
else:
p.next = p2
p = p.next
p2 = p2.next
if p1: # p1或p2 还剩下的话，全部链上去，否则链个None收尾
p.next = p1
elif p2:
p.next = p2
else:
p.next = None
return new_head_pre.next
递归实现，非常简洁。merge函数会返回合并好的给定两个有序链表。那么，只要1l更小，就拿出来，链上 merge(l1.next, l2) 的头节点；否则的话拿l2出来，链上 merge(l1, l2.next) 的头节点。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return None
if not l2:
return l1
if not l1:
return l2
if l1.val < l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1, l2.next)
return l2
23. 合并k个排序链表 https://leetcode-cn.com/problems/merge-k-sorted-lists/
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
解：
暴力，遍历所有链表，把元素放到一个数组中，然后排序，再链成表。O(NlogN)，时间都花在排序上。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
nodes = []
head_pre = ListNode(0)
p = head_pre
for l in lists:
while l:
nodes.append(l.val)
l = l.next
nodes.sort()
for val in nodes:
p.next = ListNode(val)
p = p.next
p.next = None
return head_pre.next
每次都比较k个节点，拿出最小值链上，被链上的那个链表的指针后移，其他不动，O(kN)。用优先队列优化上述方法，维护一个小顶堆每次pop出来最小值，O(Nlogk)
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
import heapq
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
head_pre = ListNode(0)
p = head_pre
head = []
for i in range(len(lists)):
if lists[i]:
heapq.heappush(head, (lists[i].val, i))
lists[i] = lists[i].next
while head:
val, idx = heapq.heappop(head)
p.next = ListNode(val)
p = p.next
if lists[idx]:
heapq.heappush(head, (lists[idx].val, idx))
lists[idx] = lists[idx].next
return head_pre.next
逐一两两合并的思路。O(kN)。用分治优化逐一两两合并O(Nlogk)
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
if not lists:
return
n = len(lists)
return self.merge(lists, 0, n-1)
def merge(self, lists, left, right): # 合并left到right位置的链表
if left == right:
return lists[left]
mid = left + (right - left) // 2
l1 = self.merge(lists, left, mid) # 先合并 left到mid
l2 = self.merge(lists, mid+1, right) # 再合并mid+1到right
return self.mergeTwoLists(l1, l2) # 把左右两个合并好的链表合并起来
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return None
if not l2:
return l1
if not l1:
return l2
if l1.val < l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1, l2.next)
return l2
2. 两数相加 https://leetcode-cn.com/problems/add-two-numbers/
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
解：
从后向前双指针模拟加法，需要注意的是，即使两个链表都遍历到最后了，也有可能出现相加后最高位进位的情况，新链表还是要再链一次。要考虑全面
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return ListNode(0)
p1, p2 = l1, l2
head_pre = ListNode(0)
p = head_pre
nex = 0
while p1 or p2 or nex:
tmp = nex
if p1:
tmp += p1.val
p1 = p1.next
if p2:
tmp += p2.val
p2 = p2.next
cur = tmp % 10
nex = tmp // 10
p.next = ListNode(cur)
p = p.next
p.next = None
return head_pre.next
考虑把两个的链表表示的数表示整型，相加后再链成表。相当于要遍历两边。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return ListNode(0)
p1, p2 = l1, l2
head_pre = ListNode(0)
p = head_pre
value1, value2 = 0, 0
i = 1
while p1 or p2:
if p1:
value1 += p1.val*i
p1 = p1.next
if p2:
value2 += p2.val*i
p2 = p2.next
i *= 10
res = value1 + value2
if res == 0:
return ListNode(0)
while res:
p.next = ListNode(res % 10)
p = p.next
res //= 10
return head_pre.next
如果链表中的数字不是按逆序存储的呢？例如：(3→4→2)+(4→6→5)=8→0→7。用递归。
11. 盛水最多的容器 https://leetcode-cn.com/problems/container-with-most-water/
给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。
解：
暴力迭代，O(n2)，超时
class Solution:
def maxArea(self, height: List[int]) -> int:
if len(height) < 2:
return 0
n = len(height)
res = 0
for i in range(n):
for j in range(i+1, n):
size = min(height[j], height[i]) * (j-i)
res = max(res, size)
return res
暴力dfs，超时。由于没有重叠子问题，记忆化的dfs也不能加速。
class Solution:
def maxArea(self, height: List[int]) -> int:
if len(height) < 2:
return 0
n = len(height)
res = 0
def helper(start):
nonlocal res
if start == n:
return
for end in range(start+1, n):
size = min(height[end], height[start]) * (end-start)
res = max(res, size)
helper(start+1)
helper(0)
return res
双指针，左右指针往中间收紧，长度减小造成容量减小，只有取到更长的高度才可能弥补
class Solution:
def maxArea(self, height: List[int]) -> int:
if len(height) < 2:
return 0
n = len(height)
res = 0
left, right = 0, n-1
while left < right:
tmp = min(height[left], height[right])
res = max(res, tmp*(right-left))
# 两边指针往中间收紧，只有取到更高的高度才可能弥补长度减小的损失
if height[left] < height[right]:
while left < right and height[left] <= tmp:
left += 1
else:
while left < right and height[right] <= tmp:
right -= 1
return res
19. 删除链表的倒数第N个节点 https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
解：
两趟遍历实现，注意使用虚拟头节点的技巧，能减少很多边界条件判断
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
if head is None:
return head
dummy = ListNode(0)
dummy.next = head
length = 0
p = head
while p:
length += 1
p = p.next
length -= n
p = dummy
while length > 0:
length -= 1
p = p.next
p.next = p.next.next
return dummy.next
双指针一趟遍历实现，第一个指针向前移动n+1步，第二个指针从开头出发，现在这两个指针被n个节点分开，同时移动这两个指针保持间隔，第一个指针到达尾节点，第二个指针到达倒数第n个节点。
继续使用虚拟头节点技巧，从dummy出发，第一个指针移动到Null，第二个指针移动到的p的下一个即为待删节点
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
if head is None:
return head
dummy = ListNode(0)
dummy.next = head
length = n + 1
p1, p2 = dummy, dummy
while length > 0:
length -= 1
p1 = p1.next
while p1:
p1 = p1.next
p2 = p2.next
p2.next = p2.next.next
return dummy.next
31. 下一个排列 https://leetcode-cn.com/problems/next-permutation/
实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须原地修改，只允许使用额外常数空间。
以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1
解：
字典序中下一个更大的排列：
先找出最大的索引 k 满足 nums[k] < nums[k+1]，如果不存在就翻转整个数组
再找出另一个最大索引 l 满足 nums[l] > nums[k]
交换 nums[l] 和 nums[k]
最后翻转nums[k+1:]
class Solution:
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if not nums:
return
n = len(nums)
firstIndex = -1
def reverse(nums, i, j):
while i<j:
nums[j], nums[i] = nums[i], nums[j]
i += 1
j -= 1
for i in range(n-2, -1, -1):
if nums[i] < nums[i+1]:
firstIndex = i
break
if firstIndex == -1:
reverse(nums, 0, n-1)
return
secondIndex = -1
for i in range(n-1, firstIndex, -1):
if nums[i] > nums[firstIndex]:
secondIndex = i
break
nums[firstIndex], nums[secondIndex] = nums[secondIndex], nums[firstIndex]
reverse(nums, firstIndex+1, n-1)