LeetCode -- Sort List

题目描述如下：

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

----------------------------------------------------------------------------------------

题目咋一看似乎很简单，只是给一个链表排序，但是要求却不一样：要在O(nlogn)时间给链表排序，并且是常量的空间复杂度。

回顾基于比较的排序算法：插入排序显然不行，快速排序似乎也不合适，以前在严蔚敏的数据结构上看到过合并两个有序链表的算法，额外的空间复杂度并不是O(n)，而是常量的空间复杂度，因此考虑用归并排序来做。

归并排序的首先要写一个merge函数，来合并两个有序的链表，然后要找到链表中间的位置来切分链表。那么如何从中间切分一个链表呢？可以考虑用快慢指针：一个指针每次往前走一步，另一个指针每次走两步，这样第二个指针走到尽头的时候，第一个指针正好就在中间位置，从这个位置把链表切分成两个链表，然后用递归排序。

代码如下：

/**
 * 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)
            return NULL;
        else if(!head->next)
            return head;
        ListNode *p1 = head, *p2 = head->next->next;
        int cnt1 = 1, cnt2 = 3;
        while(p2 != NULL)
        {
            p1 = p1->next;
            ++cnt1;
            p2 = p2->next;
            ++cnt2;
            if(p2){
                p2 = p2->next;
                ++cnt2;
            }else
                break;
        }
        --cnt2;
        p2 = p1->next;
        p1->next = NULL;
        p1 = head;
        p1 = sortList(p1);
        p2 = sortList(p2);
        return merge(p1, p2);
    }
    ListNode *merge(ListNode *p1, ListNode *p2)
    {
        ListNode *head = NULL, *p = NULL;
        while(p1 && p2)
        {
            if(p1->val <= p2->val){
                if(head == NULL){
                    head = p1;
                    p = p1;
                }else{
                    p->next = p1;
                    p = p->next;
                }
                p1 = p1->next;
            }else{
                if(head == NULL){
                    head = p2;
                    p = p2;
                }else{
                    p->next = p2;
                    p = p->next;
                }
                p2 = p2->next;
            }
        }
        if(p1){
            if(head == NULL)
                head = p1;
            else
                p->next = p1;
        }
        if(p2){
            if(head == NULL)
                head = p2;
            else
                p->next = p2;
        }
        return head;
    }
};

由于链表没有头结点，处理起来会比较麻烦。后面又考虑增加头结点，这样代码就简洁多了：

/**
 * 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 || !head->next)
            return head;
        ListNode *p1 = head, *p2 = head->next;
        while(p2->next && p2->next->next){
            p1 = p1->next;
            p2 = p2->next->next;
        }
        p2 = p1->next;
        p1->next = NULL;//the end of part one
        p1 = sortList(head);
        p2 = sortList(p2);
        return merge(p1, p2);
    }
    ListNode *merge(ListNode *la, ListNode *lb)
    {
        ListNode *p = new ListNode(0);
        ListNode *q = p;
        while(la && lb){
            if(la->val <= lb->val){
                p->next = la;
                la = la->next;
            }else{
                p->next = lb;
                lb = lb->next;
            }
            p = p->next;
        }
        if(la)p->next = la;
        if(lb)p->next = lb;
        return q->next;
    }
};