leetcode--sort-list（归并排序）

最新推荐文章于 2023-11-03 20:02:04 发布

second24

最新推荐文章于 2023-11-03 20:02:04 发布

阅读量295

点赞数

CC 4.0 BY-SA版权

分类专栏： LintCode 文章标签：归并排序

本文链接：https://blog.youkuaiyun.com/second24/article/details/79318998

LintCode 专栏收录该内容

53 篇文章

订阅专栏

本文介绍了一种使用常数空间复杂度，在O(nlogn)时间内完成链表排序的方法。通过快慢指针找到中点，将链表分成两部分进行递归排序，最后合并两个已排序的链表。

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

sort-list

描述

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

代码

设置两个指针，一个步长为1，一个步长为2，当快指针到达尾结点时，慢指针指向中间结点，时间复杂度为O(N)；

平分为左链表L1和右链表L2，递归分裂，直到链表为空或者只有一个结点；

将链表L2的每个结点插入到链表L1中，时间复杂度为O(m+n)，m、n分别为两条链表的长度。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode merge(ListNode left,ListNode right){
        ListNode head=new ListNode(-1);
        head.next=left;
        ListNode p=head;
        while(left!=null&&right!=null){
            if(left.val>=right.val){
                ListNode pr=right;
                right=right.next;
                pr.next=p.next;
                p.next=pr;
                p=pr;
            }else{
                p=left;
                left=left.next;
            }
        }
        if(right!=null){
            p.next=right;
        }
        return head.next;
    }
    public ListNode sortList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode fast=head,slow=head;
        while(slow.next!=null&&fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        ListNode rightHead=slow.next;
        ListNode leftHead=head;
        slow.next=null;
        leftHead=sortList(leftHead);
        rightHead=sortList(rightHead);
        return merge(leftHead,rightHead);
    }
}