Leetcode 148. Sort List

题目描述：

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

我们知道对一个数组进行排序的时候， 时间复杂度取为O(nlogn)的一般就三种， 快排， 归并， 堆排序ps：这里盗用各种排序算法时间复杂度和空间复杂度表 博客中的一张图片， 描述的是以数组为基础的排序算法的时间和空间复杂度，以及稳定性表示情况。

于是， 我们本能的想到使用快速排序的思想。
我们首先设定一个privot变量， 然后在遍历链表的过程中， 如果得到的数据比privot大就不动他， 而如果比他小，我们就把他放到链表的起始位置处去， 这个和算法导论中介绍的快排的思想非常相似。
然后， 根据privot所在的位置， 将链表分割成了两个待排序的子问题， 至此问题得到解决。

代码如下：

/**
 * 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) {
        return _sortList(head, nullptr);
    }

private:
    ListNode * _sortList(ListNode * start, ListNode * stop){
        if (start == stop)
            return start;

        ListNode myhead(0);
        ListNode * pre = &myhead;
        ListNode * ppre = pre;
        myhead.next = start;

        int privot = start->val;
        ListNode * pprivot = start;

        while (start != stop){
            if (start->val >= privot){
                start = start->next;
                ppre = ppre->next;
            }               
            else{
                // 删去该节点
                ListNode * pcur = start;
                ppre->next = pcur->next;
                pcur->next = nullptr;
                start = ppre->next;

                // 头插
                pcur->next = pre->next;
                pre->next = pcur;
            }
        }

        ListNode * res = pre->next;
        ListNode * head1 = _sortList(pre->next, pprivot);
        ListNode * head2 = _sortList(pprivot->next, stop);

        pprivot->next = head2;

        return head1;
    }
};

满心欢喜以为通过了， 结果， 提交的时候出现了TLE， 我们知道快排最差情况下的时间复杂度会升到O(n^2), 这里显然遇到比较差的情况了。
为了解决这个问题， 算法导论上一般是采用随机快速排序的方案。然而， 这里我们不太希望将这个问题复杂化， 于是， 我们想到了在冒泡排序的优化算法中， 采用了一个flag标记本轮扫描是否有数据交换， 如果没有直接结束。那么， 我们这里其实也可以借助这个思想， 在链表遍历的过程中， 如果数据已经是排序过的状态了， 那么我们就不在需要对子序列递归调用了！！！于是， 我们得到了我们的AC代码：

/**
 * 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) {
        return _sortList(head, nullptr);
    }

private:
    ListNode * _sortList(ListNode * start, ListNode * stop){
        if (start == stop)
            return start;

        ListNode myhead(0);
        ListNode * pre = &myhead;
        ListNode * ppre = pre;
        myhead.next = start;

        int privot = start->val;
        ListNode * pprivot = start;

        bool NeedChanged = false;
        int incre = privot;
        while (start != stop){
            if (start->val >= privot){      
                // 判断链表是不是递增的
                if (!NeedChanged && start->val >= incre){
                    incre = start->val;
                }
                else{
                    NeedChanged = true;
                }

                start = start->next;
                ppre = ppre->next;
            }               
            else{
                NeedChanged = true;

                // 删去该节点
                ListNode * pcur = start;
                ppre->next = pcur->next;
                pcur->next = nullptr;
                start = ppre->next;

                // 头插
                pcur->next = pre->next;
                pre->next = pcur;
            }
        }

        if (NeedChanged){
            ListNode * res = pre->next;
            ListNode * head1 = _sortList(pre->next, pprivot);
            ListNode * head2 = _sortList(pprivot->next, stop);
            pprivot->next = head2;

            return head1;
        }
        else{
            // 如果数据是递增的就不需要在处理了
            return myhead.next;
        }

    }
};

提交完毕后， 我们看到leetcode上更多的一种方案是采用归并排序， 因为数组不容易移动， 所以空间复杂度为O(n)， 但是， 链表容易移动， 空间复杂度可以降到O(1).

下面给出大神们的代码：

class Solution {
public:
    ListNode* merge( ListNode* head1 , ListNode * head2){
        ListNode* d = new ListNode (0);            // dummy node
        ListNode* e = d;
        while(head1||head2){
            if(head1 && (!head2 || head1->val <= head2 -> val) ){
                e=e->next= head1 ; 
                head1 = head1 -> next;
            }
            if(head2 && (!head1 || head2->val < head1 -> val) ){
                e=e->next= head2 ; 
                head2 = head2 -> next;
            }
        }
        e->next = NULL;
        return d->next;
    }
   ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode* slow = head;
        ListNode* fast =head->next;
         while(fast && fast->next){         // to find middle node     
            fast= fast->next->next;
            slow = slow->next;
        }
        ListNode* headb = slow->next;     // headb is start of 2nd half of list
        slow->next = NULL;                 
        return merge(sortList(head) , sortList(headb));
        }
};