力扣148题：排序链表

力扣148题：排序链表

一. 题目内容

给定一个链表的头结点 head，要求将其进行升序排序，并返回排序后的链表。

示例 1：

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

示例 2：

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

示例 3：

输入：head = []
输出：[]

二. 解题思路——归并排序

那要怎么做呢？既然要求 O(NlogN) 的时间复杂度和常数级空间复杂度，很容易就能想到使用 归并排序。归并排序的核心思想就是：先拆分，再合并

综上所述

• 步骤一： 找到链表的中间节点，将链表分成两部分。
• 步骤二： 对左右两部分分别进行递归排序。
• 步骤三： 合并两个有序的子链表，得到最终排序结果。

四. 代码实现

public ListNode sortList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    
    ListNode middle = findMiddle(head);
    ListNode left = head;
    ListNode right = middle.next;
    middle.next = null;
    
    ListNode sortedLeft = sortList(left);
    ListNode sortedRight = sortList(right);
    
    return merge(sortedLeft, sortedRight);
}

private ListNode findMiddle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head.next;
    
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    
    return slow;
}

private ListNode merge(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(-1);
    ListNode current = dummy;
    
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            current.next = l1;
            l1 = l1.next;
        } else {
            current.next = l2;
            l2 = l2.next;
        }
        current = current.next;
    }
    
    if (l1 != null) {
        current.next = l1;
    } else {
        current.next = l2;
    }
    
    return dummy.next;
}

代码详解

首先，假设有一个未排序的链表：5 -> 2 -> 9 -> 1 -> 7 -> 6 -> 3 -> 8

1. sortList 函数会找到链表的中间节点，即 middle 节点：5 -> 2 -> 9 -> 1 和 7 -> 6 -> 3 -> 8。

2. 然后，递归调用 sortList 函数对左半部分和右半部分进行排序。

3. 对于左半部分，继续进行递归调用，分成更小的子问题：5 -> 2 和 9 -> 1。

4. 对于右半部分，同样进行递归调用，分成更小的子问题：7 -> 6 和 3 -> 8。

5. 在 merge 函数中，将已经排序好的子链表进行合并。比如，对于左侧的子链表 5 -> 2 和 9 -> 1，合并后得到 1 -> 2 -> 5 -> 9。

6. 对于右侧的子链表 7 -> 6 和 3 -> 8，合并后得到 3 -> 6 -> 7 -> 8。

7. 最后，将合并好的左侧链表 1 -> 2 -> 5 -> 9 和右侧链表 3 -> 6 -> 7 -> 8 进行最终的合并，得到完全有序的链表：1 -> 2 -> 3 -> 5 -> 6 -> 7 -> 8 -> 9。

整个过程中，排序的关键在于 merge 函数，它将两个已排序的子链表按照大小顺序合并成一个有序链表。sortList 函数则通过递归将链表分解成更小的子问题，然后通过 merge 函数合并解决子问题得到的有序子链表，最终完成整个链表的排序。

五. 总结与复杂度分析

归并排序是一种高效稳定的排序算法，对链表进行排序时尤其适用。它的时间复杂度为 O(n log n)，因为每次归并操作都需要线性时间来合并两个有序链表。在实际应用中，归并排序在处理链表排序问题上具有重要价值。其空间复杂度为 O(log n)，由于递归使用了额外的栈空间。