排序链表-力扣

给你链表的头结点 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 = []
输出：[]

提示：

• 链表中节点的数目在范围 [0, 5 * 104] 内
• -105 <= Node.val <= 105

要解决这个问题，我们需要对给定的链表进行排序。我们可以通过使用归并排序来实现，因为它对链表的排序非常有效。在归并排序中，我们可以将链表分割为两半，递归地对这两部分进行排序，然后再将它们合并在一起。

下面是用 Java 编写的代码来实现这个功能：

// Definition for singly-linked list.
class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

public class Solution {
    public ListNode sortList(ListNode head) {
        // 如果链表为空，或只有一个节点，则直接返回
        if (head == null || head.next == null) {
            return head;
        }

        // 找到链表的中点
        ListNode mid = getMiddle(head);
        ListNode nextToMid = mid.next;
        mid.next = null; // 断开链表

        // 递归排序左右部分
        ListNode left = sortList(head);
        ListNode right = sortList(nextToMid);

        // 合并已排序的链表
        return merge(left, right);
    }

    // 获取链表的中点
    private ListNode getMiddle(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode slow = head, fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    // 合并两个已排序链表
    private ListNode merge(ListNode left, ListNode right) {
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;

        // 合并两个链表
        while (left != null && right != null) {
            if (left.val <= right.val) {
                current.next = left;
                left = left.next;
            } else {
                current.next = right;
                right = right.next;
            }
            current = current.next;
        }

        // 连接剩余节点
        if (left != null) {
            current.next = left;
        } else {
            current.next = right;
        }

        return dummy.next; // 返回头节点
    }

    public static void main(String[] args) {
        // 创建一个链表 [4,2,1,3]
        ListNode head = new ListNode(4);
        head.next = new ListNode(2);
        head.next.next = new ListNode(1);
        head.next.next.next = new ListNode(3);

        Solution solution = new Solution();
        ListNode sortedList = solution.sortList(head);

        // 打印排序后的链表
        while (sortedList != null) {
            System.out.print(sortedList.val + " ");
            sortedList = sortedList.next;
        }
    }
}

1. **ListNode 类**: 定义链表节点的结构，包括节点值 `val` 和下一个节点 `next`。
  
2. **sortList 方法**: 
   - 首先检查链表是否为空或只有一个节点，如果是，直接返回这个节点。
   - 找到链表的中间节点（使用快慢指针方法）。
   - 递归地对左半部分和右半部分进行排序。
   - 合并两个已排序的部分，并返回合并后的链表。

3. **getMiddle 方法**: 
   - 使用快慢指针寻找链表的中点（slow 为慢指针，fast 为快指针）。
   
4. **merge 方法**: 
   - 负责合并两个已排序的链表。

5. **main 方法**: 
   - 测试代码，创建一个示例链表并调用 `sortList` 方法，最后打印排序后的链表。

这种方法的时间复杂度是 O(n log n)，空间复杂度是 O(log n)，是高效的链表排序方法。

将链表转换成数组也是一个解决问题的方法

将链表转换为数组，进行排序后再转换回链表也是一种有效的解决方案。这个方法虽然不如归并排序直接在链表上进行高效，但实现起来更为简单直观，尤其是对于小规模的数据。以下是使用这种方法的步骤：

1. 遍历链表，将节点的值存入数组。
2. 使用数组的排序功能排序该数组。
3. 创建一个新的链表，按排序后的数组元素填充链表。

下面是使用 Java 实现此方法的代码：

import java.util.Arrays;

// Definition for singly-linked list.
class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

public class Solution {
    public ListNode sortList(ListNode head) {
        // 如果链表为空或只有一个节点，直接返回链表
        if (head == null || head.next == null) {
            return head;
        }

        // 第一步：将链表节点的值存入数组
        int size = 0;
        ListNode current = head;
        while (current != null) {
            size++;
            current = current.next;
        }

        int[] array = new int[size];
        current = head;
        for (int i = 0; i < size; i++) {
            array[i] = current.val;
            current = current.next;
        }

        // 第二步：对数组进行排序
        Arrays.sort(array);

        // 第三步：根据排序后的数组构建新的链表
        ListNode dummy = new ListNode(0); // 虚拟头节点
        ListNode tail = dummy;
        for (int val : array) {
            tail.next = new ListNode(val);
            tail = tail.next;
        }

        return dummy.next; // 返回排序后的链表头节点
    }

    public static void main(String[] args) {
        // 创建一个链表 [4,2,1,3]
        ListNode head = new ListNode(4);
        head.next = new ListNode(2);
        head.next.next = new ListNode(1);
        head.next.next.next = new ListNode(3);

        Solution solution = new Solution();
        ListNode sortedList = solution.sortList(head);

        // 打印排序后的链表
        while (sortedList != null) {
            System.out.print(sortedList.val + " ");
            sortedList = sortedList.next;
        }
    }
}

代码解释

1. ListNode 类: 和之前一样定义链表的节点结构。

2. sortList 方法:

   • 先检查链表是否为空或只有一个节点，如果是，直接返回。
   • 遍历链表，计算链表的长度，并将每个节点的值添加到一个数组中。
   • 使用 Arrays.sort() 方法对数组进行排序。
   • 然后根据排序后的数组创建一个新的链表，并返回新的链表的头节点。

3. main 方法: 测试代码创建一个例子链表，调用 sortList 方法，并打印排序后的链表。

复杂度分析

• 时间复杂度: O(n log n) 主要取决于数组的排序。
• 空间复杂度: O(n) 用于存储链表节点的值。

这种方法在链表长度较小的情况下是完全可行的，并且实现相对较为简单，尽管它没有利用链表的特性进行原地排序。对于大型链表，仍然推荐使用原地排序的方法（如归并排序）。