每日一题：链表排序（归并排序实现）

问题描述

给你链表的头结点 head，请将其按升序排列并返回排序后的链表。（常数空间）

示例 1：

输入：head = [4,2,1,3]
输出：[1,2,3,4]

问题分析

这是一个经典的链表排序问题，要求时间复杂度为 O(nlogn)，空间复杂度为 O(1)。由于链表不支持随机访问，传统的快速排序不太适用，而归并排序特别适合链表结构。使用迭代而不是递归，常数空间需要。

难点分析：

1. 链表不支持随机访问，需要特殊的分割方法
2. 需要原地排序，空间复杂度要求高
3. 指针操作复杂，容易产生错误

解题思路

方法：自底向上的归并排序

采用自底向上的归并排序算法，避免递归带来的栈空间开销：

1. 计算长度：首先遍历链表获取总长度
2. 分治处理：从最小子数组开始（步长=1），逐步合并
3. 分割合并：每次取出两段等长的子链表进行合并
4. 重复过程：不断扩大步长，直到整个链表有序

算法步骤：

ListNode* sortList(ListNode* head) {
    if (!head || !head->next) return head;
    
    // 1. 计算链表长度
    int length = 0;
    ListNode* curr = head;
    while (curr) {
        length++;
        curr = curr->next;
    }
    
    // 2. 设置虚拟头节点
    ListNode dummy(0);
    dummy.next = head;
    
    // 3. 自底向上归并排序
    for (int step = 1; step < length; step *= 2) {
        ListNode* prev = &dummy;
        curr = dummy.next;
        
        while (curr) {
            // 分割出两个子链表
            ListNode* left = curr;
            ListNode* right = split(left, step);
            curr = split(right, step);
            
            // 合并两个有序链表
            ListNode* merged = mergeTwoLists(left, right);
            
            // 连接到已排序部分
            prev->next = merged;
            while (prev->next) {
                prev = prev->next;
            }
        }
    }
    
    return dummy.next;
}

关键子函数：

1. 分割函数 split()

ListNode* split(ListNode* head, int step) {
    if (!head) return nullptr;
    ListNode* curr = head;
    for (int i = 1; i < step && curr->next; i++) {
        curr = curr->next;
    }
    ListNode* rest = curr->next;
    curr->next = nullptr; // 切断链表
    return rest;
}

2. 合并函数 mergeTwoLists()

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(0);
    ListNode* curr = &dummy;
    while (l1 && l2) {
        if (l1->val < l2->val) {
            curr->next = l1;
            l1 = l1->next;
        } else {
            curr->next = l2;
            l2 = l2->next;
        }
        curr = curr->next;
    }
    curr->next = l1 ? l1 : l2;
    return dummy.next;
}

复杂度分析

• 时间复杂度：O(nlogn)，归并排序的标准复杂度
• 空间复杂度：O(1)，只使用了常数级别的额外空间

知识总结

1. 指针操作技巧

虚拟头节点技巧：

ListNode dummy(0);        // 创建虚拟头节点
dummy.next = head;        // 连接原链表
// ... 各种操作 ...
return dummy.next;        // 返回真正的头节点

指针移动模式：

ListNode* curr = &dummy;  // curr指向dummy
curr->next = newNode;     // 修改dummy的next指针
curr = curr->next;        // 移动curr指针

2. 链表分割技巧

分割链表时需要注意：

• 遍历到指定位置后切断链表
• 保存剩余部分的头指针
• 正确处理边界情况（链表长度不足）

3. 归并排序应用

归并排序特别适合链表的原因：

• 不需要随机访问，只需要顺序遍历
• 合并操作可以原地进行
• 天然的分治结构适合链表特性

4. 常见错误避免

1. 野指针问题：始终初始化指针
2. 空指针解引用：每次访问前检查是否为null
3. 链表断裂：确保每次操作后链表连接正确
4. 内存泄漏：合理管理内存分配

拓展思考

1. 如何修改算法实现降序排序？
2. 如果链表中有重复元素，算法是否仍然有效？
3. 如何优化算法减少指针操作次数？

这道题很好地考察了指针操作、链表处理和分治算法的综合应用能力，是面试中的经典题目。掌握这个算法有助于理解更复杂的链表问题。

题目来源：牛客网