回文链表与相交链表的最优解法解析

小猪佩琪168

1. 项目概述

链表操作是数据结构与算法面试中的高频考点，其中回文链表和相交链表这两类问题更是各大技术面试的"常客"。作为面试官，我见过太多候选人在这些问题上栽跟头——不是解法时间复杂度不达标，就是代码冗长难以维护。今天我就来分享这两个问题的黄金解法模板，这些方法都是我在实际面试评判和代码评审中验证过的最优方案。

回文链表（LeetCode 234）要求判断一个单链表是否为回文结构，最优解法需要达到O(n)时间复杂度和O(1)空间复杂度。相交链表（LeetCode 160）则需要找出两个链表的相交节点，同样有严格的空间复杂度限制。这两个问题看似简单，但要写出既高效又优雅的代码，需要掌握链表操作的核心技巧。

2. 回文链表的最优解法

2.1 暴力解法与优化方向

新手最常见的思路是将链表值复制到数组，然后用双指针判断回文。这种方法虽然直观，但需要O(n)额外空间：

python复制def isPalindrome(head):
    vals = []
    while head:
        vals.append(head.val)
        head = head.next
    return vals == vals[::-1]

面试官期待的解法应该在不使用额外空间的情况下完成判断。这就需要我们掌握链表的"原地修改"技巧。

2.2 快慢指针找中点

最优解法的核心在于：

使用快慢指针找到链表中点
反转后半部分链表
比较前后两部分
恢复链表原状（重要）

python复制def isPalindrome(head):
    if not head or not head.next:
        return True
    
    # 找中点
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    
    # 反转后半部分
    prev = None
    while slow:
        nxt = slow.next
        slow.next = prev
        prev = slow
        slow = nxt
    
    # 比较前后两部分
    left, right = head, prev
    while right:  # 后半部分可能比前半部分短1个节点
        if left.val != right.val:
            return False
        left = left.next
        right = right.next
    
    return True

注意：在实际面试中，如果面试官要求保持链表原状，还需要添加链表恢复的代码。这是一个常被忽略但很重要的细节。

2.3 复杂度分析与边界情况

时间复杂度：O(n) —— 三次线性遍历
空间复杂度：O(1) —— 只用了几个指针变量

边界情况处理：

空链表：视为回文
单节点链表：视为回文
链表长度为奇数：中间节点不参与比较

3. 相交链表的最优解法

3.1 哈希表解法与局限

最直观的方法是使用哈希表存储一个链表的所有节点，然后遍历另一个链表查找相交点：

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

这种方法虽然简单，但需要O(n)额外空间，不符合最优解要求。

3.2 双指针走位法

最优解法利用了一个精妙的数学原理：两个指针分别遍历两个链表，当到达末尾时切换到另一个链表头部继续遍历，最终会在相交点相遇。

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

这个解法之所以有效，是因为：

如果两链表相交，这种走法会让两个指针同时到达相交点（路程相同）
如果两链表不相交，两个指针会同时到达None（相当于走了m+n步）

3.3 复杂度与正确性证明

时间复杂度：O(m+n) —— 最多遍历两遍两个链表
空间复杂度：O(1) —— 只用了两个指针

正确性证明：
设链表A独有部分长度为a，链表B独有部分长度为b，公共部分长度为c。

指针A的路径：a + c + b
指针B的路径：b + c + a
两者路径长度相同，必定在相交点或None处相遇。

4. 双模板实战应用

4.1 回文链表模板

python复制def isPalindrome_template(head):
    # 边界判断
    if not head or not head.next:
        return True
    
    # 找中点（模板）
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    
    # 反转后半部分（模板）
    prev = None
    while slow:
        nxt = slow.next
        slow.next = prev
        prev = slow
        slow = nxt
    
    # 业务逻辑：比较前后部分
    left, right = head, prev
    result = True
    while right:
        if left.val != right.val:
            result = False
            break
        left = left.next
        right = right.next
    
    # 恢复链表（可选）
    # ...
    
    return result

4.2 相交链表模板

python复制def getIntersectionNode_template(headA, headB):
    # 初始化双指针
    pA, pB = headA, headB
    
    # 双指针走位（模板）
    while pA != pB:
        pA = pA.next if pA else headB
        pB = pB.next if pB else headA
    
    # 返回相遇点（可能是None）
    return pA