链表+归并排序+非递归 148. 排序链表

最新推荐文章于 2020-11-23 15:49:12 发布

原创最新推荐文章于 2020-11-23 15:49:12 发布 · 465 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 同时被 3 个专栏收录

189 篇文章

订阅专栏

链表

18 篇文章

订阅专栏

分治

13 篇文章

订阅专栏

本篇博客介绍如何在O(n log n)时间复杂度和常数级空间复杂度下，使用非递归的归并排序算法对链表进行排序。详细解题过程包括递归方法和非递归方法，重点讲解如何找到链表中间点、截断链表以及进行有效的链表归并操作。

148. 排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

解题
复杂度nlogn即为归并排序；

递归方法
分为merge和mergesort两步；
（1）merge
dummyhead维护归并后的链表，并返回；
（2）mergesort
重点在于找到链表中间点并截断；
快慢指针条件：

 while(slow&&fast&&fast->next&&fast->next->next){
            slow=slow->next;
            fast=fast->next->next;
        }

偏左的截断（奇数个截断左边）；

因为用了递归，所以额外空间不止常数个；

/**
 * 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) return head;
        return mergesort(head);
    }
private:
    ListNode* merge(ListNode* a,ListNode *b){
        ListNode dummyhead;
        ListNode *p=&dummyhead;

        while(a&&b){
            if(a->val<b->val){
                p->next=a;
                a=a->next;
            }
            else {
                p->next=b;
                b=b->next;
            }
            p=p->next;
        }
        if(a) p->next=a;
        else p->next=b;
        return dummyhead.next;
    }

    ListNode *mergesort(ListNode *head){
        if(!head->next) return head;

        ListNode *slow=head;
        ListNode *fast=head;
        while(slow&&fast&&fast->next&&fast->next->next){
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode *tmp=slow->next;
        slow->next=NULL;
        return merge(mergesort(head),mergesort(tmp));
    }
};

非递归
先得到链表总长度；
size从1开始，没此*2，归并每size长度的链表；

注意点
进行merge两端链表前，先要把两端链表从总链表内断开；
归并后，需要用dummyhead把每一段链表都连起来，准备下一次归并；

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head) return head;
        //先算出整个链表的长度
        int n=0;
        ListNode *tmp=head;
        while(tmp){
            tmp=tmp->next;
            n++;
        }
        ListNode dummyhead(0);
        dummyhead.next = head;
        ListNode* p=head;

        for(int size=1;size<n;size<<=1){  //每次*2
            ListNode* cur=dummyhead.next;
            ListNode* tail=&dummyhead;
            while(cur){
                auto left=cur;
                auto right=cut(left,size);
                cur=cut(right,size);  //left断掉，right也要断掉
                tail->next=merge(left,right);
                while(tail->next) tail=tail->next;
            }
        }
        return dummyhead.next;
    }
private:
    ListNode* merge(ListNode* a,ListNode *b){
        ListNode dummyhead;
        ListNode *p=&dummyhead;

        while(a&&b){
            if(a->val<b->val){
                p->next=a;
                a=a->next;
            }
            else {
                p->next=b;
                b=b->next;
            }
            p=p->next;
        }
        if(a) p->next=a;
        else p->next=b;
        return dummyhead.next;
    }

ListNode * cut(ListNode *head,int n){  //把head分成两半，返回head另一半的头指针
    auto p=head;
    while(--n&&p) p=p->next;
    if(!p) return NULL;  //后半部分无需归并
    ListNode* next=p->next;
    p->next=NULL;  //把head断掉
    return next;
}
};