LeetCode：sort list

题目描述：

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

题目解析：

使用O(nlogn)的算法排序数组。O(nlogn)的排序算法有快速排序，归并排序，堆排序。这里使用归并排序。

归并排序的一般步骤为：

（1）将待排序链表，取中点，一分为二；

（2）递归地对左半部分进行归并排序；

（3）递归地对右半部分进行归并排序；

（4）将两个半部分进行合并，得到结果。

解这道题可以分为以下几步：

（1）找链表的中点：使用快慢指针，快指针一次走两步，满指针一次走一步，在快指针走到链表末尾的时候，慢指针走到链表的中间。对于有奇数个节点，走到中间节点；对于有偶数个节点，走到中间两个结点其中偏左的位置。

（2）将链表一分为二，分别对左右两边进行归并排序。

（3）合并左右两边的链表。

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) {
        if(head == NULL || head->next == NULL)
            return head;
        //找中点：偶数节点，中点是偏左
        ListNode* fast = head->next;
        ListNode* slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        
        //将链表一分为2，分别对左右两部分进行归并排序
        ListNode* right = sortList(slow->next);
        slow->next = NULL;
        ListNode* left = sortList(head);
        
        return Merge(left,right);
    }
    
    ListNode* Merge(ListNode* left,ListNode* right)
    {
        ListNode* newHead = new ListNode(-1);
        ListNode* cur = newHead;
        while(left && right)
        {
            if(left->val < right->val)
            {
                cur->next = left;
                left = left->next;
            }
            else{
                cur->next = right;
                right = right->next;
            }
            cur = cur->next;
        }
        if(left)
            cur->next = left;
        if(right)
            cur->next = right;
        return newHead->next;
    }
};

(*^▽^*)