Sort List

Sort List

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

正常思路用Merge Sort，但是递归所消耗的空间不满足 constant space complexity 的要求

而快排对于链表不太适用

所以我们需要自己写非递归的Merge Sort

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
    void myMerge(ListNode *head, ListNode *p, ListNode *q)
    {
        while (p && q)
        {
            if (p->val < q->val)
            {
                head->next = p;
                p = p->next;
                head = head->next;
            }
            else
            {
                head->next = q;
                q = q->next;
                head = head->next;
            }
        }
        if (p) head->next = p;
        if (q) head->next = q;
    }
    
public:
    ListNode *sortList(ListNode *head) {
        if (!head) return NULL;
        int n, i, j, k;
        ListNode *dummy = new ListNode(0);
        dummy->next = head;
        ListNode *p = head;
        ListNode *q = head;
        ListNode *pt = dummy;
        ListNode *qt = dummy;
        ListNode *pdummy = dummy;
        ListNode *qdummy = dummy;
        for (n = 1; p->next; n++)
            p = p->next;
        for (k = 1; k < n; k <<= 1)
        {
            pdummy = dummy;
            qdummy = dummy->next;
            while (qdummy)
            {
                p = qdummy;
                pt = p;
                for (i = 0; i < k; i++)
                {
                    qt = pt;
                    pt = pt->next;
                    if (pt == NULL)
                        break;
                }
                if (pt == NULL)
                {
                    pdummy->next = qdummy;
                    break;
                }
                qt->next = NULL;
                q = pt;
                for (i = 0; i < k; i++)
                {
                    qt = pt;
                    pt = pt->next;
                    if (pt == NULL)
                        break;
                }
                qdummy = pt;
                qt->next = NULL;
                
                myMerge(pdummy, p, q);
                if (qdummy)
                {
                    for (i = 0; i < 2*k; i++)
                        pdummy = pdummy->next;
                }
            }
        }
        return dummy->next;
    }
};