【LeetCode 148】排序链表

在 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(n log n)时间复杂度下进行排序，选择归并排序

 思路：在整个链表进行排序过程中，先利用快慢指针不断进行递归划分，划分成两个链表进行排序，之后进行sort过程，借用两个链表指针指向划分后链表，进行遍历；在sort排序时，创建一个新链表，用一个指针指向新链表，比较划分好的l1和l2链表，哪个值小就放入新链表，直到结束 [PS：要对l1遍历结束，但l2还未结束；l2遍历结束，但l1还未结束的情况进行讨论]

/**
 * 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 *slow = head;
        ListNode *fast = head;
        while(slow->next != NULL && fast->next != NULL && fast->next->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode *last = slow->next;
        slow->next = NULL; //断开链表 //构成两个链表进行排序
        ListNode *pre = sortList(head);  //pre指向以head为头节点的链表//递归划分
        ListNode *las = sortList(last);  //las指向以last为头节点的链表//递归划分
        return sort(pre,las);
    }
    //直接传递两个链表的指针
    ListNode* sort(ListNode* l1,ListNode* l2)
    {
        ListNode *ans = new ListNode(0);  //头节点为空的链表
        ListNode *ptr = ans;  //ptr指向ans
        while(l1 != NULL && l2 != NULL) //排序过程
        {
            if(l1->val > l2->val)
            {
                ptr->next = l2;
                l2 = l2->next;
                ptr = ptr->next;
            }
            else
            {
                ptr->next = l1;
                l1 = l1->next;
                ptr = ptr->next;
            }
        }
        if(l1 != NULL) //l2已结束，但l1还有剩余链表
        {
            ptr->next = l1;
            ptr = ptr->next;
            l1 = l1->next;
        }
        if(l2 != NULL)
        {
            ptr->next = l2;
            ptr = ptr->next;
            l2 = l2->next;
        } 
        return ans->next;
    }
};