题目要求用两个栈模拟一个队列，一个简单的方法是：每次push时都将元素压入到同一个栈（input_stack）中，当需要pop时则将input_stack里的元素全部弹出并压入到另一个栈（output_stack）里，此时output_stack里的顶部元素就是pop需要移除的元素，将其移除后再把output_stack剩余的元素全部倒回input_stack即可。
上面这个方法虽然简单，但是每次pop时都需要将所有元素都倒腾一遍，其时间复杂度为\(O(n)\)，这里我们可以利用output_stack的一个特点进行优化：output_stack里的元素自顶向下就已经按照队列pop的顺序排列好了。因此我们可以去掉把output_stack剩余元素全部倒回input_stack的操作，在pop的时直接从output_stack顶部进行弹出，当output_stack为空时则先把input_stack里的元素全部倒入output_stack。
在进行了优化之后，每个元素都只会有常数次（三次）移动：
因此pop操作的均摊时间复杂度从原来的\(O(n)\)优化到了\(O(1)\)。
class MyQueue:
def __init__(self):
self.input_stack = []
self.output_stack = []
def push(self, x: int) -> None:
self.input_stack.append(x)
def _shift(self):
while len(self.input_stack) != 0:
self.output_stack.append(self.input_stack.pop())
def pop(self) -> int:
if len(self.output_stack) == 0:
self._shift()
return self.output_stack.pop()
def peek(self) -> int:
if len(self.output_stack) == 0:
self._shift()
return self.output_stack[-1]
def empty(self) -> bool:
return len(self.input_stack) == 0 and len(self.output_stack) == 0
题目要求执行push、pop和min操作的时间复杂度必须为\(O(1)\)，所以搜索整个栈找出最小值的做法是不可行的，必须在执行push/pop操作时就记录下栈当前的最小值。
一个简单的做法是在栈里维护一个min变量，每次执行push操作时把当前的min（\(min(当前栈中的最小值，准备入栈的数据)\)）和数据值一起压入栈中，执行pop操作时则用新的栈顶元素中记录的min值维护min变量。然而这种方法会使得每个栈中的元素都要记录一个min值，可能会浪费许多空间。
一种更好的方法是另外使用一个栈min_stack来记录min数据，每次执行min操作时都返回min_stack的栈顶数据（若min_stack为空则返回整数最大值）。每次执行push/pop操作时，根据入栈/出栈的数据和当前min返回结果的大小关系来相应地更新min_stack。这样就能省下许多记录重复min值的空间，但是这里有一种特殊情况，那就是所有的值都是最小值。这种情况下是不会节省空间的，因为min_stack必须存储跟当前数据栈相同数量的最小值（例如，如果当前数据栈中的最小值为m，且数据栈中有n个m，那么min_stack中也应该有n个m），不然一个pop操作之后min_stack就变成空栈了，这也是为什么下面代码中push函数里的if条件是val <= self.getMin()而不是val < self.getMin()。
class MinStack:
def __init__(self):
self.value_stack = []
self.min_stack = []
def push(self, val: int) -> None:
self.value_stack.append(val)
if val <= self.getMin():
self.min_stack.append(val)
def pop(self) -> None:
val = self.value_stack.pop()
if val == self.getMin():
self.min_stack.pop()
def top(self) -> int:
return self.value_stack[-1]
def getMin(self) -> int:
if len(self.min_stack) > 0:
return self.min_stack[-1]
else:
return sys.maxsize
首先要检测链表中是否存在环路，这里可以使用快慢指针的技巧，因为快指针与慢指针在存在环路的链表中必然会相遇。
digraph G {
layout = circo
A -> B -> C -> D
D -> E -> F -> G -> H -> I -> J -> D
}
记链表中环路之前的部分长度为k，环路的长度为loop_size。当慢指针走了k步进入环路起始点时，快指针已经走了2k步，也就是已经走了k步进入环路并且在环路部分中又走了k步，此时快指针位于\(P = k \bmod loop\_size\)的位置。
如下图所示，慢指针位于环路起始处，快指针位于位置P，二者相距\(loop\_size - P\)个节点，由于慢指针每走一步快指针就走两步，快指针每次都会向慢指针多靠近一步，所以二者会在\(loop\_size - P\)步之后相遇，也就是说慢指针从环路起始处走\(loop\_size - P\)步之后的节点就是快慢指针相遇的节点。
由上图可知，快慢指针相遇的节点距离环路起始处的距离为P，而\(P = k \bmod loop\_size\)，也就是说从这个相遇节点出发，再走k步即可到达环路起始处，而从链表头到环路起始处的距离也为k，所以我们同时从链表头和相遇节点出发，走过k步之后必然会在环路起始处首次相遇。
class Solution:
def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
if head is None:
return None
fast = head
slow = head
while fast is not None:
fast = fast.next
if fast is not None:
fast = fast.next
slow = slow.next
if fast == slow:
slow = head
break
if fast is None:
return fast
node1 = fast
node2 = slow
while node1 != node2:
node1 = node1.next
node2 = node2.next
return node1
Intersection of Two Linked Lists
由下图可以看出，如果两个链表相交的话，在相交节点以及之后的那一部分必然是相同的，而相交节点就是第一个同时位于链表A与链表B的节点。
graph LR
A1 --> A2 --> C1 --> C2 --> C3
B1--> B2 --> B3 --> C1
style C1 fill:red
由于链表A与链表B不一定有相同长度，所以同时遍历两个链表不一定会同时抵达相交节点，但是我们可以运用下面的技巧来解决这个问题：节点1先遍历链表A再遍历链表B，节点2先遍历链表B再遍历链表A，这样节点1与节点2必然会在相交节点上相遇。证明如下：假设链表A的头部到相交节点的距离为a，而链表B的头部到相交节点的距离为b，相交部分的长度为c，因为 \(a + c + b = b + c + a\)，所以节点1与节点2必然在相交节点上相遇。
class Solution:
def getIntersectionNode(
self, headA: ListNode, headB: ListNode
) -> Optional[ListNode]:
nodeA = headA
nodeB = headB
while nodeA is not nodeB:
if nodeA is None:
nodeA = headB
else:
nodeA = nodeA.next
if nodeB is None:
nodeB = headA
else:
nodeB = nodeB.next
return nodeA
因为回文链表从前往后遍历与从后往前遍历得到的结果是一样的，所以如果我们从链表的头尾两端同时向中间遍历的话，就可以检验该链表是否为回文链表。通过运用快慢指针+反转链表的技巧，我们可以在\(O(n)\)的时间复杂度以及\(O(1)\)的空间复杂度以内做到从链表的头尾两端同时向中间遍历。
首先使用快慢指针遍历链表，快指针每次跨过两个节点，慢指针每次跨过一个节点，当快指针到达链表末端时，慢指针恰好指向链表的中间节点。
digraph G {
{
rank=same
A[label="1"]
B[label="6"]
C[label="4"]
D[label="5" color="blue" style="filled"]
E[label="4"]
F[label="6"]
G[label="1" color="red" style="filled"]
}
A -> B -> C -> D -> E -> F -> G
A:n -> C:n -> E:n -> G:n [arrowhead="none", color="red"]
A:s -> B:s -> C:s -> D:s [arrowhead="none", color="blue"]
{
node[shape=plain]
fast
slow
}
G -> fast [dir=back]
D -> slow [dir=back]
}
获取中间节点之后，我们把后半段链表逐个节点进行反转，反转之后即可得到链表的末尾节点，此时我们就可以从链表的头尾两端同时向中间遍历以检验该链表是否为回文链表了。
digraph G {
{
rank=same
A[label="1"]
B[label="6"]
C[label="4"]
D[label="5" color="blue" style="filled"]
E[label="4"]
F[label="6"]
G[label="1"]
}
A -> B -> C -> D
D -> E -> F -> G [dir="back" color="red"]
{
rank = same
node[shape=plain]
head
slow
tail
}
D -> slow [dir=back]
A -> head [dir=back]
G -> tail [dir=back]
}
class Solution:
def isPalindrome(self, head: Optional[ListNode]) -> bool:
fast = head
slow = head
while fast is not None and fast.next is not None:
fast = fast.next.next
slow = slow.next
middle = slow
previous = None
current = middle
while current is not None:
temp = current.next
current.next = previous
previous = current
current = temp
head_node = head
tail_node = previous
result = True
while tail_node is not None:
if head_node.val != tail_node.val:
result = False
break
tail_node = tail_node.next
head_node = head_node.next
return result
本题可以通过反转链表的方式来将问题转换为更容易求解的Add Two Numbers问题，也可以借助递归或者栈结构来求解，不过这里将介绍另外的特殊解法：我们可以直接将两个链表从最高位开始按位相加（先不处理进位），并构造一个从最低位指向最高位的链表，然后再一边处理进位一边反转链表。
graph TB
subgraph numbers
千位1[9] --> 百位1[8] --> 十位1[7] --> 个位1[6]
千位2[5] --> 百位2[4] --> 十位2[3] --> 个位2[2]
end
subgraph sum
direction RL
个位和[8] --> 十位和[10] --> 百位和[12] --> 千位和[14]
end
subgraph result
万位[1] --> 千位[5] --> 百位[3] --> 十位[0] --> 个位[8]
end
numbers -- 直接相加 --> sum -- 处理进位并反转 --> result
class Solution:
def countNodes(self, head: Optional[ListNode]):
node = head
count = 0
while node is not None:
count += 1
node = node.next
return count
def addTwoNumbers(
self, l1: Optional[ListNode], l2: Optional[ListNode]
) -> Optional[ListNode]:
size1 = self.countNodes(l1)
size2 = self.countNodes(l2)
if size2 > size1:
l1, l2 = l2, l1
size1, size2 = size2, size1
for _ in range(size1 - size2):
l2 = ListNode(0, l2)
node1 = l1
node2 = l2
head_node = None
while node1 is not None and node2 is not None:
sum = node1.val + node2.val
if head_node is None:
head_node = ListNode(sum)
else:
head_node = ListNode(sum, head_node)
node1 = node1.next
node2 = node2.next
previous_node = None
digit_node = head_node
carry = 0
while digit_node is not None:
sum = digit_node.val + carry
if sum >= 10:
carry = 1
else:
carry = 0
digit_node.val = sum % 10
next_node = digit_node.next
digit_node.next = previous_node
previous_node = digit_node
digit_node = next_node
result_node = previous_node
if carry > 0:
result_node = ListNode(1, previous_node)
return result_node
如果能观察到下列事项，我们自然就能拼出答案来了：
class Solution:
def deleteNode(self, node):
next_node = node.next
node.val = next_node.val
node.next = next_node.next
由于链表插入/删除首尾节点的时间/空间复杂度均为\(O(1)\)，所以我们不需要像分割数组那样分配额外空间。
首先创建左右两个链表，然后遍历输入的链表，把每个节点裁剪出来插入这两个链表，最后把左右链表拼接起来即可。
class Solution:
def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
left_list_head = None
left_list_tail = None
right_list_head = None
right_list_tail = None
current = head
while current is not None:
next = current.next
current.next = None
if current.val < x:
if left_list_head is None:
left_list_head = current
left_list_tail = current
else:
left_list_tail.next = current
left_list_tail = current
else:
if right_list_head is None:
right_list_head = current
right_list_tail = current
else:
right_list_tail.next = current
right_list_tail = current
current = next
if left_list_head is None:
return right_list_head
left_list_tail.next = right_list_head
return left_list_head
Remove Nth Node From End of List
双指针技巧是常见的处理链表的手法，这里我们运用其中的快慢指针方法来解题：首先让一个快指针从head开始提前移动k个节点，然后把慢指针初始化为head，再让两个指针同时前进。当快指针到达链表末尾的Null时，慢指针就会指向倒数第k个节点。
class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
forward_node = head
count = 0
while forward_node is not None and count < n:
forward_node = forward_node.next
count += 1
previous = None
current = head
while forward_node is not None:
previous = current
current = current.next
forward_node = forward_node.next
if previous is None:
head = head.next
else:
previous.next = current.next
return head
首先需要注意，我们不能在扫描完整个矩阵之前进行清零操作，因为这样会把后面未扫描到的矩阵元素置零，从而可能导致零值被错误地扩散出去。
在空间复杂度必须为\(O(1)\)的限制下，我们只能在矩阵内存储需要清零的行/列信息。一个方法是在首行首列存储需要清零的行和列，但是这样会导致首行首列本身是否需要清零的信息被映射到同一个位置matrix[0][0]而无法区别开来，所以我们需要两个额外的变量来存储这两项信息。
class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
row_size = len(matrix)
column_size = len(matrix[0])
first_row_has_0 = any([True for x in matrix[0] if x == 0])
first_column_has_0 = any(
[True for row in range(row_size) if matrix[row][0] == 0]
)
for row, array in enumerate(matrix):
for column, value in enumerate(array):
if value == 0:
matrix[row][0] = 0
matrix[0][column] = 0
for row in range(1, row_size):
if matrix[row][0] == 0:
matrix[row] = [0] * column_size
for column in range(1, column_size):
if matrix[0][column] == 0:
for row in range(row_size):
matrix[row][column] = 0
if first_row_has_0:
matrix[0] = [0] * column_size
if first_column_has_0:
for row in range(row_size):
matrix[row][0] = 0