148. 排序链表（归并排序）

用归并排序给链表排序
快慢指针，慢一步快两步，快到终点了，慢也到终点或者中点的左边了。
设置一个tmp为切分点（slow）下一个，将slow的next设为空，相当于把链表一分为二。左链表等于递归排序左边，将head传进去即可，右链表递归右边传入tmp。定义一个h为当前链表头=cur，cur一直往前，左小于等于右，就插入左到cur后面，反之右。最后结束后一定有一边没遍历完，将整条链表插在cur后面，cur指向非空的头即可。最后返回h->next

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        //鲁棒性
        if(head == nullptr || head->next == nullptr) return head;
        //O(nlogn)就是二分查找，而二分对应的排序算法就是归并排序（递归），因为是链表所以不用辅助数组
        ListNode* fast, *slow;
        slow = head;
        fast = head->next;
        while(fast != nullptr && fast->next != nullptr){
            slow = slow->next;
            fast = fast->next->next;
        }
        //此时slow就是链表中点，用它切割链表
        ListNode* tmp = slow->next;
        slow->next = nullptr;
        ListNode* left = sortList(head);
        ListNode* right = sortList(tmp);
        ListNode* cur = new ListNode(0);
        ListNode* h = cur;
        while(left != nullptr && right != nullptr){
            //等于也将左边先放进去，这样才能保证归排的稳定性
            if(left->val <= right->val){
                cur->next = left;
                left = left->next;
            }
            else{
                cur->next = right;
                right = right->next;
            }
            cur = cur->next;
        }
        cur->next = left!=nullptr?left:right;
        return h->next;
    }
};

很棒的题

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        //nlogn快排，堆排，归排，常数级空间不让用归排，链表的归排不用辅助数组
        //当切分到一个结点的时候就可以开始merge了
        //链表怎么切分非常重要，不能通过left+right然后/2来取中点了，通过快慢指针找到中点
        if(head == nullptr || head->next == nullptr) return head;//切到0个结点或者1个结点就切完
        ListNode* slow = head;
        ListNode* fast = head->next;
        while(fast!= nullptr && fast->next !=nullptr){
            slow = slow->next;
            fast = fast->next->next;
        }
        //如果是奇数个结点的话，slow刚好在中点，如果是偶数个的话，slow在中点靠左一个
        //然后将链表断开，因为是切分要有点切分的样子
        ListNode* tmp = slow->next;
        slow->next = nullptr;
        ListNode* leftList = sortList(head);
        ListNode* rightList = sortList(tmp);

        ListNode* h = new ListNode(0);
        ListNode* cur = h;
        //然后开始merge
        //不用新建结点，来一个哨兵和cur即可
        while(leftList !=nullptr && rightList !=nullptr){
            if(leftList->val <= rightList->val){
                cur->next = leftList;
                leftList = leftList->next;
            }
            else{
                cur->next = rightList;
                rightList = rightList->next;
            }
            cur = cur->next;
        }
        cur->next = (leftList == nullptr ? rightList : leftList);
        return h->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        //O(nlogn)三大排序，常数级空复，链表的常数级空复，直接归并
        //链表排序直接上归并，链表的归并排序难的就是怎么找中间结点，用快慢指针找就完事了
        //按照中间结点断开，然后对两边进行继续切分，切分到一个结点后开始归并
        if(head == nullptr || head->next == nullptr) return head;
        ListNode* slow = head, *fast = head->next;
        //快慢指针，当fast或者fast的下一个为null时，slow就是中点或者偏左
        while(fast != nullptr && fast->next != nullptr){
            slow = slow->next;
            fast = fast->next->next;
        }
        fast = slow->next;
        slow->next = nullptr;
        //拿两个结点来接一下归并回来的链表
        slow = sortList(head);
        fast = sortList(fast);
        ListNode* h = new ListNode(0);
        head = h;
        while(slow != nullptr && fast != nullptr){
            if(slow->val <= fast->val){
                head->next = slow;
                head = head->next;
                slow = slow->next;
            }
            else{
                head->next = fast;
                head = head->next;
                fast = fast->next;
            }
        }
        head->next = (slow == nullptr)?fast:slow;
        return h->next;
    }
};