LeetCode链表题精解：双指针与高频题型实战

1. 为什么链表题是LeetCode必刷？

链表作为数据结构中的基础类型，在LeetCode题库中占比高达18%（根据2023年LeetCode官方统计）。不同于数组的连续存储特性，链表的节点离散分布特点使其在插入删除操作上具有O(1)时间复杂度优势，但也带来了指针操作的高出错率。大厂面试中约70%的算法题会涉及链表变形操作，如字节跳动高频考察的"LRU缓存机制"就结合了哈希表与双向链表。

初学者常陷入的误区是直接照搬数组解题思路。比如在解决"反转链表"时，试图通过下标访问节点，却忽略了链表只能通过指针顺序访问的特性。我在最初刷题阶段就因此卡壳近两小时，直到发现pre/cur双指针的经典解法才豁然开朗。

2. 双指针法的实战精要

2.1 快慢指针的三种变体

快慢指针不仅是判断环的利器，其变形应用更能解决各类位置定位问题：

• 标准版（1:2速度）：用于检测环（LeetCode 141）和找中点（LeetCode 876）

python复制def hasCycle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

• 步长差版：如快指针先走k步，再同步前进，用于找倒数第k个节点（LeetCode 19）
• 多指针版：处理复杂链表重组时，可能需要3-4个指针协同工作

实战经验：在链表长度为偶数时，快指针终止条件fast.next is None会导致慢指针停在中点偏右位置。若题目要求严格左中点，需调整判断为fast.next.next is None

2.2 指针穿针引线法

处理链表重组类题目时，保持清晰的指针操作顺序至关重要。以"反转链表II"（LeetCode 92）为例：

1. 使用dummy节点处理头节点可能被反转的情况
2. 定位到反转区间的前驱节点pre
3. 采用头插法逐个反转区间内节点
4. 注意维护反转区间外节点的连接

python复制def reverseBetween(head, m, n):
    dummy = ListNode(0)
    dummy.next = head
    pre = dummy
    
    for _ in range(m-1):
        pre = pre.next
        
    cur = pre.next
    for _ in range(n-m):
        temp = cur.next
        cur.next = temp.next
        temp.next = pre.next
        pre.next = temp
        
    return dummy.next

3. 模拟加法的工程化实现

3.1 大数相加的链表解法

当处理"两数相加"（LeetCode 2）这类问题时，链表模拟加法比数组方案更具扩展性。核心在于：

1. 同步遍历两个链表
2. 维护进位值carry
3. 处理链表不等长情况
4. 最后检查剩余进位

python复制def addTwoNumbers(l1, l2):
    dummy = cur = ListNode(0)
    carry = 0
    while l1 or l2 or carry:
        v1 = v2 = 0
        if l1:
            v1 = l1.val
            l1 = l1.next
        if l2:
            v2 = l2.val
            l2 = l2.next
        carry, val = divmod(v1+v2+carry, 10)
        cur.next = ListNode(val)
        cur = cur.next
    return dummy.next

3.2 进位处理的边界陷阱

实际编码中最易出错的是进位处理时机：

• 在while循环条件中必须包含or carry，否则会漏掉最高位进位
• 使用divmod同时获取商和余数比分开计算更可靠
• 链表不等长时，空节点应视为0值参与计算

我在美团面试中就因漏掉最高位进位被面试官连续追问三次，这个教训让我养成了在纸上画出最终进位情况的习惯。

4. 高频题型的举一反三

4.1 链表排序的进阶路线

从简单的"合并两个有序链表"（LeetCode 21）到复杂的"排序链表"（LeetCode 148），体现了分治思想的演进：

1. 基础版：递归合并 → O(n)空间
2. 优化版：迭代合并 → O(1)空间
3. 终极版：自底向上归并 → 真正O(1)空间

python复制def sortList(head):
    if not head or not head.next:
        return head
    
    # 快慢指针找中点
    slow, fast = head, head.next
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        
    mid = slow.next
    slow.next = None
    
    left = sortList(head)
    right = sortList(mid)
    
    return merge(left, right)

4.2 环形链表的衍生问题

除了基本的环检测（LeetCode 141），还有两个高阶变种：

• 环入口定位（LeetCode 142）：快慢指针相遇后，将慢指针移回起点，改为同速前进
• 环长度计算：定位到环入口后，单指针绕环一周计数

这类问题的核心在于数学推导：设环前长度a，环长b，快慢指针相遇时慢指针走了s步，则有2s = s + nb → s = nb。这个推导过程在面试中常被要求手写证明。

5. 调试技巧与性能优化

5.1 链表调试三板斧

1. 可视化打印：实现自定义的链表打印函数，标注节点关系和值

python复制def print_list(head):
    nodes = []
    while head:
        nodes.append(str(head.val))
        head = head.next
    print("->".join(nodes))

2. 循环检测：在遍历时设置最大节点数限制（如1000），防止无限循环
3. 边界测试：专门测试空链表、单节点链表、全相同值链表等特殊情况

5.2 空间复杂度优化策略

当题目要求O(1)空间时，可以考虑：

• 原地修改：如反转链表时直接改变指针方向
• 复用现有节点：合并链表时不必创建新节点
• 位运算：某些情况下可用异或交换指针值（但会降低可读性）

在链表题目中，时间复杂度往往已经最优（O(n)），重点考察的是空间复杂度的优化能力。我在面试腾讯时就被要求在不使用递归的情况下反转链表，这正是考察对空间复杂度的掌控。