sort-list

最新推荐文章于 2020-03-30 10:45:16 发布

Cassie曹

最新推荐文章于 2020-03-30 10:45:16 发布

阅读量210

点赞数

CC 4.0 BY-SA版权

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

本文链接：https://blog.youkuaiyun.com/baidu_32157201/article/details/56482076

leetcode 专栏收录该内容

17 篇文章

订阅专栏

本文介绍了一种在O(nlogn)时间内使用常数空间复杂度对链表进行排序的方法，利用归并排序的思想，通过查找链表中点、拆分链表、递归排序两部分链表以及合并两个有序链表实现。

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

题目描述

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

IDEA

要求空间复杂度为常数，时间复杂度O(nlogn)

归并排序：空间复杂度O(n)，时间复杂度O(nlogn)

1.首先找到list的中点，用连个指针，一个慢，一个快，慢的每次走一个node，快的每次走两个node，当快的走到list末尾，则慢的走到list中点

2.将list一分为二，head到mid和mid->next到结尾，递归

2.merge排序两个list，需要借助一个tmp链表存储排序结果。分别遍历两个list，存储最小的node到tmp，最终但会tmp->next

CODE

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head==NULL||head->next==NULL)
            return head;
        ListNode* mid=findMid(head);
        ListNode* right=sortList(mid->next);
        mid->next=NULL;
        ListNode* left=sortList(head);
        return merge(left,right);
    }
    ListNode* findMid(ListNode *head){
        ListNode* p=head;
        ListNode* q=head->next;
        while(q&&q->next){
            p=p->next;
            q=q->next->next;
        }
        return p;
    }
    ListNode* merge(ListNode* left,ListNode* right){
        ListNode* tmp=new ListNode(0);
        ListNode* p=tmp;
        while(left&&right){
            if(left->val<right->val){
                p->next=left;
                left=left->next;
            }else{
                p->next=right;
                right=right->next;
            }
            p=p->next;            p=p->next;

        }
        if(left)
            p->next=left;
        if(right)
            p->next=right;
        return tmp->next;
    }
};