双指针技巧解决链表相交问题-代码聚汇网

双指针技巧解决链表相交问题

happy最紧要

1. 相交链表问题背景与核心挑战

链表相交问题是数据结构与算法中的经典题型，也是技术面试中的高频考点。160题在LeetCode Hot100榜单中属于Easy难度，但实际解决过程中往往会让初学者感到困惑——明明题目描述简单，代码却总是写不对。

这个问题的核心在于：给定两个单链表的头节点headA和headB，找出并返回两个链表相交的起始节点。如果两个链表没有交点，则返回null。题目要求时间复杂度O(m+n)，空间复杂度O(1)。

关键难点：如何在不知道链表长度差的情况下，让两个指针同时到达交点？这就是双指针技巧的精妙之处。

2. 暴力解法与双指针思路对比

2.1 直观的暴力解法

最直接的思路是用哈希表存储其中一个链表的所有节点，然后遍历另一个链表检查是否存在重复节点。这种方法虽然简单，但需要O(m)或O(n)的额外空间，不符合题目对空间复杂度的要求。

python复制def getIntersectionNode(headA, headB):
    nodes = set()
    while headA:
        nodes.add(headA)
        headA = headA.next
    while headB:
        if headB in nodes:
            return headB
        headB = headB.next
    return None

2.2 双指针的巧妙思路

双指针解法才是本题的精髓所在。其核心思想是：让两个指针分别从headA和headB出发，当到达链表末尾时，立即切换到另一个链表的头部继续遍历。如果链表相交，这两个指针必定会在交点相遇；如果不相交，最终会同时到达null。

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

3. 双指针解法的数学证明

为什么这种方法能保证找到交点？让我们从数学角度分析：

假设链表A的非公共部分长度为a，链表B的非公共部分长度为b，公共部分长度为c。那么：

指针pA的路径总长度：a + c + b
指针pB的路径总长度：b + c + a

可以看到，无论a和b是否相等，两个指针走过的总长度相同。因此如果存在交点，它们必定会在交点处相遇；如果没有交点，最终都会走到null。

实际编码时有个常见错误：忘记处理不相交的情况。正确的循环条件应该是while pA != pB，这样当两者都为null时循环也会终止。

4. 边界条件与测试用例设计

4.1 关键边界情况

两个链表完全重合（a=0,b=0,c>0）
一个链表是另一个的真子集（如a=0,b>0,c>0）
不相交的两个链表（c=0）
其中一个链表为空
交点在第一个节点（a=0,b=0,c>0）
交点在最后一个节点

4.2 测试用例示例

python复制# 用例1：正常相交
# listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]
# 相交节点值为8

# 用例2：不相交
# listA = [2,6,4], listB = [1,5]
# 应返回None

# 用例3：一个链表为空
# listA = [], listB = [1,2,3]
# 应返回None

5. 链表问题的通用解题技巧

5.1 链表遍历的基本模式

处理链表问题时，首先要掌握几种基本遍历模式：

单指针遍历（while current:）
快慢指针（找中点或环）
前后双指针（反转链表）
分离指针（本题的交叉遍历）

5.2 调试链表代码的技巧

画图辅助：在纸上画出链表结构和指针移动路径
打印中间状态：在循环中打印指针位置和值
使用小规模测试用例：先验证简单情况
检查终止条件：特别是处理空链表时

python复制# 调试示例
def getIntersectionNode(headA, headB):
    pA, pB = headA, headB
    step = 0
    while pA != pB:
        print(f"Step {step}: pA={pA.val if pA else None}, pB={pB.val if pB else None}")
        pA = pA.next if pA else headB
        pB = pB.next if pB else headA
        step += 1
    return pA

6. 双指针技巧的扩展应用

6.1 环形链表检测（LeetCode 141）

快慢指针的经典应用：快指针每次走两步，慢指针每次走一步。如果存在环，两者必定会相遇。

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

6.2 链表中点查找

同样是快慢指针，当快指针到达末尾时，慢指针正好在中点。这在链表归并排序中非常有用。

python复制def middleNode(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

7. 链表问题的常见错误与修正

7.1 空指针引用

未检查节点是否为null就直接访问next或val属性。修正方法是在访问前添加判空检查。

python复制# 错误写法
while pA.next:  # 如果pA为None会抛出异常
    pA = pA.next

# 正确写法
while pA and pA.next:
    pA = pA.next

7.2 循环终止条件不当

特别是在处理环形链表或双指针问题时，循环条件设置不当可能导致无限循环。应该仔细考虑所有可能的终止情况。

7.3 指针移动顺序错误

在某些需要保存前驱节点的问题中（如链表反转），指针移动顺序错误会导致信息丢失。通常应该先保存必要信息再移动指针。

8. 性能优化与进阶思考

虽然双指针解法已经是最优解，但实际面试中可能会被问到进一步的优化空间：

如何减少比较次数？可以预先计算链表长度差，让长链表的指针先移动差值步数。
如果链表特别长且相交点靠近末尾，是否有优化方法？可以考虑先检查尾节点是否相同。
如果允许修改链表结构，能否用其他方法解决？比如临时反转链表。

python复制# 预先计算长度的优化版本
def getIntersectionNode(headA, headB):
    lenA = lenB = 0
    pA, pB = headA, headB
    
    # 计算长度
    while pA:
        lenA += 1
        pA = pA.next
    while pB:
        lenB += 1
        pB = pB.next
    
    # 重置指针并对齐起点
    pA, pB = headA, headB
    if lenA > lenB:
        for _ in range(lenA - lenB):
            pA = pA.next
    else:
        for _ in range(lenB - lenA):
            pB = pB.next
    
    # 同时前进找交点
    while pA != pB:
        pA = pA.next
        pB = pB.next
    return pA

9. 链表问题的系统训练方法

要真正掌握链表问题，建议按照以下顺序系统练习：

基础操作：反转、合并、删除节点
双指针技巧：相交链表、环形链表、链表中点
复杂操作：重排链表、K个一组反转、复制带随机指针的链表
综合应用：LRU缓存实现、LFU缓存实现

我个人的训练经验是：先理解每种技巧的原理，然后用小规模测试用例手动模拟指针移动，最后再写代码。这样比直接看答案效果要好得多。