LeetCode 排序链表

排序链表
问题描述：在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3

输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0

输出: -1->0->3->4->5
思路：使用归并排序，思想是分而治之。归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

/**
 * 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==NULL||head->next==NULL)
            return head;
           // 1、首先使用快慢指针slow和fast，将链表一分为二，fast指向slow的下一个结点，slow的next指针指向空，断开链表。
        ListNode *slow=head,*fast=head;
        while(slow->next!=NULL&&fast->next!=NULL&&fast->next->next!=NULL){
            slow=slow->next;
            fast=fast->next->next;
        }
        fast=slow->next;
        slow->next=NULL;
        ListNode *L1,*L2;
        L1=sortList(head);
        L2=sortList(fast);
        return merge(L1,L2);
    }
    ListNode* merge(ListNode* l1, ListNode* l2) {
        //定义一个新的头节点，用root指针指向它，指向两个链表中值小的一个，值小的链表中的指针移动到下一个结点，并且root指针移动到下一个结点
        ListNode p(0);
        ListNode *root=&p;
        if(l1==NULL) return l2;
        if(l2==NULL) return l1;
        while(l1&&l2){
            root->next=l1->val<=l2->val?l1:l2;
            if(l1->val<=l2->val)
                l1=l1->next;
            else l2=l2->next;
            root=root->next;
        }
        //当出现两个链表的其中一个为空时，root指向非空的那个链表
        root->next=l1==NULL?l2:l1;
        return p.next;
}
};