sort-list 归并排序链表

题目：

在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

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

示例;

输入：{3,2,4}　　　　输出：{2,3,4}

代码：

/**
 * struct ListNode {
 *    int val;
 *    struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* FindMiddleNode(ListNode* head) {
        ListNode* fast = head; //利用快慢指针找到当前中间节点
        ListNode* slow = head;
        while(fast->next != NULL && fast->next->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    ListNode* MergeList(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        ListNode* result; //结果
        ListNode* newhead; //头节点
        auto first = l1->next; //表示归并排序中的两个分区
        auto second = l2->next;
        if(l1->val > l2->val){ //l1较小则为头节点，反之则头节点为l2
            result = newhead = l2;
            first = l1;
        }
        else{
            result = newhead = l1;
            second = l2;
        }
        while(first != NULL || second != NULL){
            if(second == NULL){ //当第二块为空
                result->next = first; break;
            }
            else if(first == NULL){ //当第一块为空
                result->next = second; break;
            }
            // 归并排序，较小的先插入result的尾部，由于这里在sort函数中有将右末尾结点设为NULL所以会停止循环
            if(first->val > second->val){
                result->next = second;
                second = second->next;
                result = result->next;
            }
            else{
                result->next = first;
                first = first->next;
                result = result->next;
            }
        }
        return newhead;
    }
    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* mid = FindMiddleNode(head);
        ListNode* midnext = mid->next;
        mid->next = NULL; //将链表划分
        return MergeList(sortList(head), sortList(midnext));
    }
};

我的笔记：

由于本函数的要求时间复杂度为O(nlogn)，故使用归并排序法。

leetcode官网详解：https://leetcode-cn.com/problems/sort-list/solution/148-pai-xu-lian-biao-bottom-to-up-o1-kong-jian-by-