LeetCode 148. Sort List(C++版)

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

思路分析：

对数组而言，能够有O(n lgn)时间复杂度的算法为，快速排序，堆排序，归并排序，三者的空间复杂度分别为O(1), O(N),O(N)

快速排序最坏时间复杂度为O(n^2)。

通常而言，也就是针对数组而言，归并排序的空间复杂度为O(N), 你需要开出O(N)的额外空间来容纳数组，来表示归并后的顺序。但是，对于链表而言，可以省下这部分空间的开销，你只需要改变节点的next指针的指向，就可以表示新的归并后的顺序了，所以空间复杂度陡然降到了O(1)。

/**
 * 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, *fast = head;
        while(fast -> next != NULL && fast -> next -> next != NULL){
            slow = slow -> next;
            fast = fast -> next -> next;
        }
        //slow即中间结点
        //断开中间结点的连接
        ListNode *midnext = slow -> next;
        slow -> next = NULL;
        
        ListNode * l1 = sortList(head);
        ListNode * l2 = sortList(midnext);
        return mergeTwoLists(l1, l2);
    }
    //合并两个有序链表
    ListNode * mergeTwoLists(ListNode *l1, ListNode *l2){
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        
        ListNode *dummy_head = new ListNode(-1);//避免讨论head是不是空
        ListNode *tail = dummy_head;
        while(l1 != NULL && l2 != NULL){
            if(l1 -> val < l2 -> val){
                tail -> next = l1;
                l1 = l1 -> next;
            }
            else{
                tail -> next = l2;
                l2 = l2 -> next;
            }
            tail = tail -> next;
            tail -> next = NULL;//不要忘了
        }
        if(l1 != NULL){
            tail -> next = l1;
        }
        if(l2 != NULL){
            tail -> next = l2;
        }
        ListNode *newhead = dummy_head -> next;
        delete [] dummy_head;
        return newhead;
    }
};