leetcode 148. Sort List

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

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

Example 3:

Input: head = []
Output: []

Constraints:

• The number of nodes in the list is in the range [0, 5 * 104].
• -105 <= Node.val <= 105

题目难度：简单（递归式归并），中等（非递归归并）

题目大意：给一个链表排序，并要求常数空间复杂度$O(1)$，$O(nlogn)时间复杂度$

思路：常用的快排和归并排序，快排在有些情况下的时间复杂度是$(n^2)$，在链表情况下不方便。选择第一个节点为枢纽值。

归并排序时间复杂度是$O(nlogn)$，用递归方法实现的方法，空间复杂度是O(logn)（栈）。所以按照提议应该选择迭代式的归并排序，可以实现$O(1)$空间复杂度（由于是链表，在归并的时候可以不用先new数组作为辅助）。

---

版本一：递归式的归并排序C++代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
private:
    //合并两个有序链表
    ListNode* mergeList(ListNode *front, ListNode *rear) {
        ListNode *res = new ListNode(0), *tail = res;
        ListNode *tmp1 = front, *tmp2 = rear;
        while ((nullptr != tmp1) && (nullptr != tmp2)) {
            if (tmp1->val <= tmp2->val) {
                tail->next = tmp1;
                tail = tmp1;
                tmp1 = tmp1->next;
            } else {
                tail->next = tmp2;
                tail = tmp2;
                tmp2 = tmp2->next;
            }
            tail->next = NULL;
        }
        if (nullptr != tmp1)
            tail->next = tmp1;
        else
            tail->next = tmp2;
        return res->next;
    }
    //找到后一半链表，并返回后一半链表的头指针，同时将前一半链表的尾结点指针指向NULL。
    ListNode* splitList(ListNode *head) {
        ListNode *midPrev = head, *fast = head->next;
        //采用快慢指针的方法找到链表中点
        while ((nullptr != fast) && (nullptr != fast->next)) {
            fast = fast->next->next;
            midPrev = midPrev->next;
        }
        ListNode *mid = midPrev->next;
        midPrev->next = nullptr;
        return mid;
    }
    // void printList(ListNode *head) {
    //     if (nullptr == head) return;
    //     cout << head->val;
    //     ListNode *tmp = head->next;
    //     while (nullptr != tmp) {
    //         cout << "->" << tmp->val;
    //         tmp = tmp->next;
    //     }
    //     cout << endl;
    // }
public:
    ListNode* sortList(ListNode* head) {
        if ((head == nullptr) || (head->next == nullptr)) return head;
        ListNode *rear = splitList(head); //找到后一半链表
        // printList(head);
        // printList(rear);
        ListNode *head1 = sortList(head); //将前一半链表排好序
        // printList(head1);
        ListNode *head2 = sortList(rear); //将后一半链表排好序
        // printList(head2);
        return mergeList(head1, head2); //合并两个排好序的链表，并返回。
    }
};

---

版本二：迭代式的归并排序C++代码：

class Solution {
private:
    ListNode* split(ListNode *start, int size) {
        ListNode* midPrev = start;
        ListNode* end = start->next;
        for (int index = 1; index < size && (midPrev->next || end->next); ++index) {
            if (end->next) {
                end = (end->next->next) ? end->next->next : end->next;
            }
            if (midPrev->next) {
                midPrev = midPrev->next;
            }
        }
        ListNode *mid = midPrev->next;
        nextSubList = end->next;
        midPrev->next = nullptr;
        end->next = nullptr;
        return mid;
    }
    
    //合并两个有序链表
    void mergeList(ListNode *front, ListNode *rear) {
        ListNode *res = new ListNode(0), *newTail = res;
        ListNode *tmp1 = front, *tmp2 = rear;
        while ((nullptr != tmp1) && (nullptr != tmp2)) {
            if (tmp1->val <= tmp2->val) {
                newTail->next = tmp1;
                newTail = tmp1;
                tmp1 = tmp1->next;
            } else {
                newTail->next = tmp2;
                newTail = tmp2;
                tmp2 = tmp2->next;
            }
            newTail->next = NULL;
        }
        if (nullptr != tmp1)
            newTail->next = tmp1;
        else
            newTail->next = tmp2;
        while (newTail->next) {
            newTail = newTail->next;
        }
        tail->next = res->next;
        tail = newTail;
    }
    int gCount(ListNode *head) {
        int cnt = 0;
        ListNode *tmp = head;
        while (nullptr != tmp) {
            ++cnt;
            tmp = tmp->next;
        }
        return cnt;
    }
    // void printList(ListNode *head) {
    //     if (nullptr == head) return;
    //     cout << head->val;
    //     ListNode *tmp = head->next;
    //     while (nullptr != tmp) {
    //         cout << "->" << tmp->val;
    //         tmp = tmp->next;
    //     }
    //     cout << endl;
    // }
public:
    ListNode *tail = new ListNode(); //用于始终指向已排序部分的尾结点
    ListNode *nextSubList = new ListNode(); //始终指向待排序部分的头结点
    
    ListNode* sortList(ListNode* head) {
        if (!head || !head->next) return head;
        int sz = gCount(head);
        ListNode *start = head;
        ListNode *dummyHead = new ListNode(0);
        for (int size = 1; size < sz; size = size * 2) {
            tail = dummyHead;
            while (start) {
                if (!start->next) {
                    tail->next = start;
                    break;
                }
                ListNode *mid = split(start, size);
                mergeList(start, mid);
                start = nextSubList;
            }
            start = dummyHead->next;
        }
        return dummyHead->next;
    }   
};