LeetCode Sort List

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

对链表进行排序，要求时间复杂度为O(n log n)，并且空间复杂度为常量。

运用归并排序的思想，每次将链表拆分成两个子链表，分别针对两个子链表进行排序，然后合并两个有序的子链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
//获取链表的中点，使用两个指针，快指针每次走两步，慢指针每次走一步，快指针到尾节点的时候慢指针对应为链表的中点
    ListNode *getMiddle(ListNode *head) {
        ListNode *slow = head;
        ListNode *fast = head;
        
        while (fast->next!=NULL && fast->next->next!=NULL) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    ListNode *sortList(ListNode *head) {
        if (head==NULL || head->next==NULL)
            return head;
        ListNode *middle = getMiddle(head);
        ListNode *next = middle->next;
        middle->next = NULL;
        return mergeLists(sortList(head), sortList(next));
    }
//合并两个有序的子链表
    ListNode *mergeLists(ListNode *a, ListNode *b) {
        ListNode *prehead = new ListNode(-1);
        ListNode *cur = prehead;
        while (a!=NULL && b!=NULL) {
            if (a->val <= b->val) {
                cur->next = a;
                a=a->next;
            }
            else {
                cur->next = b;
                b = b->next;
            }
            cur = cur->next;
        }
        if (a!=NULL)
            cur->next = a;
        else
            cur->next = b;
        cur = prehead->next;
        delete prehead;
        return cur;
    }
};