Sort List

1，题目要求

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

Example 1:
Input: 4->2->1->3
Output:1->2->3->4

Example 2:
Input: -1->5->3->4->0
Output: -1->0->3->4->5

使用常量空间复杂度在O（nlogn）时间内对链表进行排序。

2，题目思路

对于这道题，题目是对一个单链表进行排序。其中，时间复杂度在nlogn，存储空间使用常数空间。

因为题目有时间复杂度的要求，而对于排序算法的时间复杂度，我们有：

经典排序算法的总结（转）
而时间复杂度为为nlogn的排序算法，就是图中的希尔排序、归并排序、快速排序以及堆排序。

而针对链表的特性：线性的、无法通过下表索引，于是，我们选择归并排序来实现一个链表的排序。

---

归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但是表现比选择排序好很多。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效有效的排序算法。这个算法是采用了分治法（Divide and Conquer） 的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列：

• 先使得每个子序列有序，再使得子序列有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述

• 将长度为n的输入序列分成长度为n/2的子序列；
• 把这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

动图演示
代码实现

vector<int> merge(vector<int> left, vector<int> right)
{
    vector<int> res (left.size()+right.size(), 0);
    for(int index = 0, i = 0, j = 0; index < res.size();index++)
    {
        if(i >= left.size())            //左边的遍历完了
            res[index] = right[j++];
        else if(j >= right.size())      //右边的遍历完了
            res[index] = left[i++];
        else if(left[i] > right[j])     //左边的当前元素比右边的大
            res[index] = right[j++];
        else                            //右边的当前元素比左边的大
            res[index] = left[i++];
    }
    
    return res;
}

vector<int> mergeSort(vector<int> nums)
{
    if(nums.size() < 2)
        return nums;
    int mid = (int)nums.size()/2;
    vector<int> left (nums.begin(), nums.begin()+mid);
    vector<int> right (nums.begin()+mid, nums.end());
    return merge(mergeSort(left), mergeSort(right));
}

---

从归并排序算法的步骤看，如果对链表进行归并排序：

• 需要对链表划分成两部分——划分成两半，构成两个单链表。
• 递归地对两个单链表合并。

而如何对单链表归并排序，我们可以使用之前的合并两个有序的单链表的方法，来实现merge。

之所以是有序的单链表，因为base是以null或单个节点，所以一开始是合并两个节点，然后分别在2、2合并，而每一次，单链表都是有序的。

3，代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

int x = []() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    return 0;
}();

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head == nullptr || head->next == nullptr)
            return head;    //base
        
        //step1：
        //利用快慢指针法找到中间节点
        //将链表划分成两个单链表
        ListNode* leftPartEnd = nullptr;
        ListNode* slow = head;
        ListNode* fast = head;
        
        while(fast != nullptr && fast->next != nullptr){
            leftPartEnd = slow;
            slow = slow->next;
            fast = fast->next->next;
        }
        
        //断开左侧的链表
        leftPartEnd->next = nullptr;
        
        //step2：
        //递归的左右进行排序
        ListNode* l = sortList(head);
        ListNode* r = sortList(slow);
        
        //step3：
        //将l和r进行合并
        return mergeTwoLists(l, r);
    }
    
    //将两个已经有序的单链表合并
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2){
        ListNode res(-1);   //设置一个头结点
        ListNode* res_tail = &res;
        
        while(l1 != nullptr && l2 != nullptr){
            if(l1->val <= l2->val){
                res_tail->next = l1;
                l1 = l1->next;
            }
            else{
                res_tail->next = l2;
                l2 = l2->next;
            }
            res_tail = res_tail->next;
        }
        
        if(l1 == nullptr)
            res_tail->next = l2;
        else
            res_tail->next = l1;
        return res.next;
    }
};