Sort List

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

/**

 * 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) 

    {

        ListNode* left;

        ListNode* right;

        quicksort(head,left,right);

        return left;

    }

    

    void quicksort(ListNode* head,ListNode*& left,ListNode*& right)

    {

        if(head==NULL)

        {

            left=NULL;right=NULL;

            return;

        }

        if(head->next==NULL)

        {

            left=head;

            right=head;

            return;

        }

        

        ListNode* headsmall=NULL;

        ListNode* smallp;

        

        ListNode* pre=head;

        ListNode* p=head->next;

        int val=head->val;

        

        bool issame=true;

        while(p!=NULL)

        {

            while(p!=NULL)

            {

                if(p->val!=val) issame=false;

                if(p->val<val) break;

                pre=p;

                p=p->next;

            }

            if(p!=NULL)

            {

                pre->next=p->next;

                if(headsmall==NULL) 

                {

                    headsmall=p;

                }

                else

                {

                    smallp->next=p;

                }

                smallp=p;

                p=p->next;

                smallp->next=NULL;

            }

        }

        //all the same

        if(issame && headsmall==NULL)

        {

            left=head;

            right=pre;

            return;

        }

        

        ListNode* headbig=head->next;

        head->next=NULL;

        

        ListNode* bigleft;

        ListNode* bigright;

        ListNode* smallleft;

        ListNode* smallright;

        

        if(headsmall!=NULL && headbig!=NULL)

        {

            quicksort(headbig,bigleft,bigright);

            quicksort(headsmall,smallleft,smallright);

            smallright->next=head;

            head->next=bigleft;

            left=smallleft;

            right=bigright;

        }

        else if(headsmall==NULL)

        {

            quicksort(headbig,bigleft,bigright);

            head->next=bigleft;

            left=head;

            right=bigright;

        }

        else if(headbig==NULL)

        {

            quicksort(headsmall,smallleft,smallright);

            smallright->next=head;

            left=smallleft;

            right=head;

        }

    }

};