链表重排算法：LeetCode 143题三步解法详解-代码聚汇网

链表重排算法：LeetCode 143题三步解法详解

菩提风

1. 链表重排问题概述

LeetCode第143题"Reorder List"是一个经典的链表操作问题，要求在不改变节点值的情况下重新排列链表结构。具体来说，给定一个单链表L: L0→L1→...→Ln-1→Ln，需要将其重新排列为L0→Ln→L1→Ln-1→L2→Ln-2→...的形式。这个问题在2023年亚马逊、微软等大厂的面试中出现频率排名前20%，是检验候选人链表操作能力的试金石。

我第一次遇到这个问题时，尝试直接用双指针从两端向中间遍历，但很快发现单链表无法反向遍历的特性让这个思路行不通。后来通过拆解问题发现，这实际上需要组合三个基本链表操作：寻找中点、链表反转和链表合并。掌握这个问题的解法，对理解链表类问题的解题范式非常有帮助。

2. 解法思路拆解与算法选择

2.1 暴力解法的时间复杂度分析

最直观的暴力解法是每次找到链表末尾节点，将其插入到相应位置。对于一个长度为n的链表，每次查找末尾节点需要O(n)时间，总共需要进行n/2次这样的操作，因此总时间复杂度为O(n²)。空间复杂度虽然是O(1)，但这样的性能在面试中显然无法过关。

2.2 最优解法的三步走策略

经过分析，我们可以将问题分解为三个关键步骤：

使用快慢指针找到链表中点
反转链表的后半部分
合并两个链表

这种解法的时间复杂度为O(n)，空间复杂度O(1)，是最优解。我在实际面试中验证过，面试官通常期望候选人能够给出这个解法。

提示：在面试场景中，建议先说明暴力解法及其缺陷，再引出优化思路，这能展示你的分析能力。

3. 关键步骤实现细节

3.1 快慢指针找中点的实现技巧

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

这里有几个易错点需要注意：

循环条件必须是fast and fast.next，不能只检查fast.next，否则当fast为None时会抛出异常
对于偶数长度链表，slow会停在后半部分的第一个节点。例如1->2->3->4，slow停在3
在实际操作中，我们需要将前半部分与后半部分断开，因此需要记录slow的前驱节点

3.2 链表反转的迭代与递归实现

迭代法是面试中的首选，因为空间复杂度更低：

python复制def reverse_list(head):
    prev = None
    curr = head
    while curr:
        next_temp = curr.next
        curr.next = prev
        prev = curr
        curr = next_temp
    return prev

递归实现虽然简洁，但在面试中可能会被追问空间复杂度：

python复制def reverse_list_recursive(head):
    if not head or not head.next:
        return head
    p = reverse_list_recursive(head.next)
    head.next.next = head
    head.next = None
    return p

3.3 链表合并的指针操作

合并两个链表时需要仔细处理指针：

python复制def merge_lists(l1, l2):
    while l1 and l2:
        l1_next = l1.next
        l2_next = l2.next
        
        l1.next = l2
        l2.next = l1_next
        
        l1 = l1_next
        l2 = l2_next

特别注意：

必须先保存下一个节点的引用，否则会丢失链表连接
循环条件是两个链表都不为空
最后不需要处理剩余节点，因为链表长度最多相差1

4. 完整代码实现与边界处理

4.1 整合各步骤的完整解法

python复制def reorderList(head):
    if not head or not head.next:
        return
    
    # Step 1: Find the middle
    slow = fast = head
    while fast and fast.next:
        prev = slow
        slow = slow.next
        fast = fast.next.next
    
    # Split the list into two halves
    prev.next = None
    
    # Step 2: Reverse the second half
    second_half = reverse_list(slow)
    
    # Step 3: Merge the two halves
    merge_lists(head, second_half)

4.2 边界条件处理

在实际编码中需要特别注意以下边界情况：

空链表或单节点链表直接返回
链表长度为2时不需要任何操作
奇数长度链表合并后会自动处理，不需要特殊操作

5. 复杂度分析与优化空间

5.1 时间复杂度分解

查找中点：O(n/2) ≈ O(n)
反转链表：O(n/2) ≈ O(n)
合并链表：O(n/2) ≈ O(n)
总时间复杂度为O(n)，已经是最优解。

5.2 空间复杂度优化

这个解法只使用了常数级别的额外空间（几个指针变量），空间复杂度为O(1)。如果使用递归实现反转，空间复杂度会升至O(n)，因此不推荐。

6. 常见错误与调试技巧

6.1 指针操作常见错误

链表未断开：在找到中点后忘记将前半部分的尾节点next置为None，导致合并时出现环
指针丢失：在反转或合并时没有先保存next节点，导致链表断裂
循环条件错误：合并时循环条件设置不当，导致提前退出或无限循环

6.2 调试建议

当链表操作出现问题时，可以：

打印链表内容辅助调试
使用小规模测试用例（长度3-5）逐步验证
检查每个步骤后的链表状态是否符合预期

7. 变种问题与扩展思考

7.1 类似问题推荐

判断回文链表（LeetCode 234）：同样需要找中点和反转链表
旋转链表（LeetCode 61）：需要处理链表成环和断开
交换相邻节点（LeetCode 24）：更简单的指针操作练习

7.2 实际应用场景

这种链表重排技术在以下场景中有实际应用：

内存受限环境下优化数据结构存储
某些特定算法（如多项式乘法）的预处理步骤
嵌入式系统中优化内存访问模式

8. 面试技巧与答题策略

8.1 面试回答框架

明确问题要求：确认输入输出和边界条件
提出暴力解法并分析复杂度
提出优化思路并解释关键步骤
编写代码时同步解释
用测试用例验证

8.2 可能追问的问题

面试官可能会问：

如何证明快慢指针能找到中点？
如果不允许修改原链表怎么做？
如果链表有环怎么处理？

9. 不同语言实现差异

9.1 Java实现注意事项

java复制public void reorderList(ListNode head) {
    if (head == null || head.next == null) return;
    
    // Find middle
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    
    // Reverse second half
    ListNode prev = null, curr = slow;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    
    // Merge
    ListNode first = head, second = prev;
    while (second.next != null) {
        ListNode temp1 = first.next;
        ListNode temp2 = second.next;
        
        first.next = second;
        second.next = temp1;
        
        first = temp1;
        second = temp2;
    }
}

注意Java中需要显式检查null，且节点访问需要用.next而不是直接像Python那样判断。

9.2 C++实现内存管理

在C++中需要特别注意指针操作和内存安全：

cpp复制void reorderList(ListNode* head) {
    if (!head || !head->next) return;
    
    // Find middle
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    
    // Reverse second half
    ListNode *prev = nullptr, *curr = slow;
    while (curr) {
        ListNode *nextTemp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextTemp;
    }
    
    // Merge
    ListNode *first = head, *second = prev;
    while (second->next) {
        ListNode *temp1 = first->next;
        ListNode *temp2 = second->next;
        
        first->next = second;
        second->next = temp1;
        
        first = temp1;
        second = temp2;
    }
}

10. 性能优化与测试用例设计

10.1 极端情况测试

空链表：应该不做任何操作
单节点链表：保持不变
双节点链表：保持不变
长链表（1000+节点）：验证性能
奇数长度链表：验证中点处理

10.2 性能测试建议

对于链表问题，性能测试主要关注：

时间复杂度是否符合预期
是否有不必要的内存分配
指针操作是否高效

在实际开发中，可以用长度为1e5的链表进行压力测试。