LeetCode 4 Sort List

最新推荐文章于 2025-05-22 22:16:20 发布

原创最新推荐文章于 2025-05-22 22:16:20 发布 · 816 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#递归 #归并排序 #链表

LeetCode 同时被 2 个专栏收录

151 篇文章

订阅专栏

LeetCode OJ

10 篇文章

订阅专栏

本文介绍了一种利用归并排序算法对链表进行排序的方法，通过快慢指针寻找链表中点，递归地对链表前后两部分进行排序，最后合并两个有序链表。该方法的时间复杂度为O(nlogn)，空间复杂度为常数级。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Sort a linked list in O(nlogn) time using constant space complexity.

分析：

快速排序要求交换元素，对链表不适用，则考虑用归并排序。

技巧及注意：

1，快慢指针法找链表中间点；

2，递归的技巧，不要试图演绎递归的流程，只要能列出 a，所有子问题，b，递归终止条件，c，当前解与子问题解的关系，递归就是正确的。

3，如果发现递归有重复子问题，则考虑使用表记录中间结果以降低复杂度，即动态规划。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    //利用归并排序
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null)
            return head;
        //快慢指针法找到链表的中间点
        ListNode slow = head;
        ListNode fast = head.next.next;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //分别对前半部分和后半部分链表进行归并排序
        ListNode l2 = sortList(slow.next);
        slow.next = null;
        ListNode l1 = sortList(head);
        //合并两部分已排序链表
        return merge(l1, l2);
    }
    private ListNode merge(ListNode l1, ListNode l2){
        //个人喜欢建立一个伪头结点，可以避免很多判断
        ListNode newHead = new ListNode(0);
        ListNode tail = newHead;
        ListNode p1 = l1;
        ListNode p2 = l2;
        while(p1 != null && p2 != null){
            if(p1.val <= p2.val){
                tail.next = p1;
                p1 = p1.next;
            }else{
                tail.next = p2;
                p2 = p2.next;
            }
            tail = tail.next;
        }
        //处理没有走到尾部的节点
        if(p1 == null){
            tail.next = p2;
        }else if(p2 == null){
            tail.next = p1;
        }
        return newHead.next;
    }
}