Leetcode | Sort List

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

merge sort、heap sort和quick sort都是O(nlgn)，但是mergesort和quicksort都是递归的，不是constant space的，heapsort需要有随机访问才行。

mergesort的bottom up实现是可以常数空间的。也适用于链表。

如果是数组，还可以用heapsort。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    // merge two list, and return last element (not NULL)
    ListNode* merge(ListNode *nh, ListNode *p1, ListNode *p2) {
        while (p1 || p2) {
            if (p1 && (p2 == NULL || p1->val < p2->val)) {
                nh->next = p1;
                p1 = p1->next;
            } else {
                nh->next = p2;
                p2 = p2->next;
            }
            nh = nh->next;
        }
        return nh;
    }
    
    // get length of list
    int getLength(ListNode *head) {
        int n = 0;
        while (head) {
            n++;
            head = head->next;
        }
        return n;
    }
    
    ListNode *sortList(ListNode *head) {
        int n = getLength(head);
        ListNode *p1, *p2, *tmp, *newH1, *tail;
        
        // merge sort, bottom up
        for (int l = 1; l < n; l *= 2) {
            p1 = head;
            tail = head = NULL; // head of the whole list
            while (p1) {
                p2 = p1;
                for (int i = 1; i < l && p2; ++i) {
                    p2 = p2->next;
                }
                if (!p2) break;
                tmp = p2->next;
                p2->next = NULL; // set tail of list 1 to NULL
                p2 = tmp; 
                for (int i = 1; i < l && tmp; ++i) {
                    tmp = tmp->next;
                }
                if (tmp) {
                    newH1 = tmp->next; // get next head of list 1
                    tmp->next = NULL; // set tail of list 2 to NULL
                } else {
                    newH1 = NULL;
                }
                ListNode h(0);
                ListNode *last = merge(&h, p1, p2);
                if (tail) tail->next = h.next; // connect the sorted part with the current two list
                if (!head) head = h.next;
                tail = last;
                last->next = newH1;
                p1 = newH1;
            }
        }
        return head;
    }
};