Leetcode--Sort List

Problem Description:

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

分析：

我们知道数组和链表的最大不同就是：数组支持随机访问，而链表不支持，只能顺序访问。这就导致很多需要随机访问的排序算法在链表上应用效果不好，例如堆排序，经常需要计算并访问父/子节点的下标。这里利用归并排序，把链表断开然后重新连接上，每次从n/2处断开，分别排序后再链接起来。

/**
 * 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) return NULL;
        int length=0,flag=1;
        if(head->next==NULL)
            return head;
        ListNode *p=head,*q,*r=NULL,*newhead=NULL;
        while(p)
        {
            length++;
            p=p->next;
        }
        p=head;
        while(flag<length/2)
        {
            flag++;
            p=p->next;
        }
        q=p->next;
        p->next=NULL;
        
        p=head;
        p=sortList(p);
        q=sortList(q);
        newhead=r;
        
        if(p&&q)
        {
            if(p->val<=q->val)
                { r=newhead=p; p=p->next; }
            else { r=newhead=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;
    }
};

不过这里有个问题就是这里如果把栈空间算上的话还是需要O(logn)的空间的。。。