链表双指针技巧与高频算法题解析

1. 链表高频题的双指针解法实战

链表作为数据结构中的常青树，在LeetCode中出现的频率高得惊人。我刷了300+链表题后发现，80%的中等难度题目都可以用双指针技巧优雅解决。双指针不是简单的快慢指针，而是一套系统化的解题思维框架。

1.1 双指针的三种经典模式

同向指针是最基础的形态，但实际应用中容易陷入思维定式。比如在"删除排序链表中的重复元素II"（LeetCode 82）中，我们需要维护三个指针：prev、current和next。这种模式的关键在于确定指针移动的触发条件：

python复制def deleteDuplicates(head):
    dummy = ListNode(0, head)
    prev, current = dummy, head
    
    while current:
        if current.next and current.val == current.next.val:
            while current.next and current.val == current.next.val:
                current = current.next
            prev.next = current.next
        else:
            prev = prev.next
        current = current.next
    
    return dummy.next

相向指针在链表中应用较少，但在特定问题中效果惊人。比如"回文链表"（LeetCode 234），结合快慢指针找到中点后，反转后半部分再进行双指针比对：

python复制def isPalindrome(head):
    # 找中点
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    
    # 反转后半部分
    prev = None
    while slow:
        temp = slow.next
        slow.next = prev
        prev = slow
        slow = temp
    
    # 双指针比对
    left, right = head, prev
    while right:
        if left.val != right.val:
            return False
        left = left.next
        right = right.next
    
    return True

快慢指针的变体远不止于检测环。在"旋转链表"（LeetCode 61）中，我们先用快指针探路确定链表长度，再计算实际旋转位置：

python复制def rotateRight(head, k):
    if not head or not head.next or k == 0:
        return head
    
    # 计算长度并成环
    tail = head
    length = 1
    while tail.next:
        tail = tail.next
        length += 1
    tail.next = head
    
    # 找到新头节点的前驱
    steps = length - k % length - 1
    new_tail = head
    for _ in range(steps):
        new_tail = new_tail.next
    
    new_head = new_tail.next
    new_tail.next = None
    
    return new_head

1.2 边界条件处理的五个黄金法则

1. 空链表检查：任何链表操作前必须检查head是否为None
2. 单节点处理：特别是涉及prev和next指针操作时
3. 头节点修改：使用dummy节点统一处理逻辑
4. 循环终止条件：while循环要同时考虑current和current.next
5. 指针解引用顺序：先检查再访问，避免None.next错误

实战经验：在"两两交换链表中的节点"（LeetCode 24）中，同时处理四个指针时要特别注意顺序：

1. 先保存next节点
2. 再修改当前节点指向
3. 最后移动指针

2. 模拟加法的艺术与细节

链表形式的数字加减是面试中的常客，这类问题的难点不在于算法本身，而在于边界处理和代码整洁度。

2.1 大数加法的链表实现

"两数相加"（LeetCode 2）是这类问题的典型代表。关键点在于：

• 进位carry的维护方式
• 不等长链表的处理
• 最后剩余进位的处理

python复制def addTwoNumbers(l1, l2):
    dummy = ListNode()
    current = dummy
    carry = 0
    
    while l1 or l2 or carry:
        val1 = l1.val if l1 else 0
        val2 = l2.val if l2 else 0
        
        total = val1 + val2 + carry
        carry = total // 10
        current.next = ListNode(total % 10)
        
        current = current.next
        l1 = l1.next if l1 else None
        l2 = l2.next if l2 else None
    
    return dummy.next

2.2 进阶变种：数字的正序存储

当数字在链表中是正序存储时（LeetCode 445），我们需要先用栈反转数字顺序：

python复制def addTwoNumbers(l1, l2):
    stack1, stack2 = [], []
    
    while l1:
        stack1.append(l1.val)
        l1 = l1.next
    while l2:
        stack2.append(l2.val)
        l2 = l2.next
    
    dummy = ListNode()
    carry = 0
    
    while stack1 or stack2 or carry:
        val1 = stack1.pop() if stack1 else 0
        val2 = stack2.pop() if stack2 else 0
        
        total = val1 + val2 + carry
        carry = total // 10
        
        new_node = ListNode(total % 10)
        new_node.next = dummy.next
        dummy.next = new_node
    
    return dummy.next

2.3 易错点警示录

1. 进位遗忘：在循环结束后忘记处理最后的进位
2. 指针移动：在while循环中漏掉l1 = l1.next这样的指针推进
3. 节点创建顺序：先创建新节点再连接，避免断链
4. 虚拟头节点：不使用dummy节点会导致头节点处理复杂
5. 数字对齐：处理不等长链表时要用0补位

3. 链表综合应用题精讲

3.1 链表排序的三种实现

归并排序是最适合链表的排序方式，时间复杂度O(nlogn)且空间复杂度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)
    
    # 合并
    dummy = ListNode()
    current = dummy
    
    while left and right:
        if left.val < right.val:
            current.next = left
            left = left.next
        else:
            current.next = right
            right = right.next
        current = current.next
    
    current.next = left if left else right
    
    return dummy.next

插入排序虽然简单但效率较低（O(n^2)），适合几乎有序的链表：

python复制def insertionSortList(head):
    dummy = ListNode()
    current = head
    
    while current:
        prev = dummy
        while prev.next and prev.next.val < current.val:
            prev = prev.next
        
        next_node = current.next
        current.next = prev.next
        prev.next = current
        current = next_node
    
    return dummy.next

3.2 复杂链表的深度拷贝

"复制带随机指针的链表"（LeetCode 138）考察对链表结构的理解：

python复制def copyRandomList(head):
    if not head:
        return None
    
    # 创建交织链表
    current = head
    while current:
        new_node = Node(current.val)
        new_node.next = current.next
        current.next = new_node
        current = new_node.next
    
    # 设置random指针
    current = head
    while current:
        if current.random:
            current.next.random = current.random.next
        current = current.next.next
    
    # 分离链表
    old = head
    new = head.next
    new_head = head.next
    
    while old:
        old.next = old.next.next
        new.next = new.next.next if new.next else None
        old = old.next
        new = new.next
    
    return new_head

4. 链表题调试技巧与性能优化

4.1 可视化调试方法

在解决复杂链表问题时，我习惯用以下方法辅助调试：

1. 图形化表示：在纸上画出指针移动过程
2. 分步打印：在关键步骤打印链表状态
3. 单元测试：为每个辅助函数编写测试用例
4. 边界测试：专门测试空链表、单节点链表等情况

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

4.2 性能优化四原则

1. 减少遍历次数：合并多次遍历为一次
2. 空间换时间：合理使用哈希表存储节点关系
3. 尾递归优化：某些递归问题可以改为迭代
4. 提前终止：满足条件时立即退出循环

以"相交链表"（LeetCode 160）为例，最优解法只需要O(1)空间：

python复制def getIntersectionNode(headA, headB):
    p1, p2 = headA, headB
    
    while p1 != p2:
        p1 = p1.next if p1 else headB
        p2 = p2.next if p2 else headA
    
    return p1

4.3 常见错误排查表

链表问题的调试往往比数组问题更困难，因为无法直接查看整个数据结构的状态。我通常会保持一个原则：每次指针操作后，立即在脑中或纸上更新链表结构图，确保所有连接关系符合预期。