Problem Description:

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

分析：对链表进行排序，思考排序算法时间复杂度为O(nlogn)的只有归并，快排和堆排序，应用到链表上的归并比较合适，这里利用快慢指针找到链表的中间节点，然后分别对两边递归归并排好序后将两边归并即可得到最终有序序列。具体代码如下：

/**
 * 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 *p=head,*q=head,*r=NULL,*newhead=NULL;

        while(q&&q->next!=NULL)
        {
            r=p;
            p=p->next;
            q=q->next->next;
        }
        
        q=r->next;//找到另一半的起始节点
        r->next=NULL;
        p=head;
        
        p=sortList(p);
        q=sortList(q);
        
        if(p&&q)
        {
            if(p->val<=q->val)//先初始化头结点
            { 
                newhead=r=p; 
                p=p->next; 
            }
            else 
            { 
                newhead=r=q; 
                q=q->next; 
            }
        
            //merge p and q
            while(p&&q)
            {
            if(p->val<=q->val)
            {
                r->next=p;
                r=p;
                p=p->next;
            }
            else
            {
                r->next=q;
                r=q;
                q=q->next;
            }
            }
        } 
        
        if(p)
            r->next=p;
        if(q)
            r->next=q;

        return newhead;
    }
};