【Leet Code】148. Sort List---Medium

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

思路：

借助2-路归并排序实现。

基本思想：

归并排序（Merging Sort）法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

时间复杂度：O(nlog(n))，空间复杂度：O（n）。稳定排序算法。

归并排序示例：

2－路归并排序：

核心操作：将一维数组中前后相邻的两个有序序列归并为一个有序序列。

Note：在实现该算法中，对于排序使用了递归。对于非linkList，可以实现非递归，可以参考博客：http://blog.csdn.net/lili616/article/details/47701447

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
ListNode* mergeList(ListNode* beg1, ListNode* beg2)
{
    if (!beg1 && !beg2 || beg1 && !beg2) return beg1;
    if (!beg1 && beg2 ) return beg2;

    ListNode* p1 = beg1;
    ListNode* p2 = beg2;
    ListNode* result = beg1;

    if (p1->val > p2->val)
    {
        result = p2;
        p2 = p2->next;
    }
    else
        p1 = p1->next;

    ListNode* curInsert = result;
    while (p1 && p2)
    {
        while (p1 && p1->val <= p2->val)
        {
            curInsert->next = p1;
            curInsert = p1;
            p1 = p1->next;
        }
        while (p1 && p2 && p2->val <= p1->val)
        {
            curInsert->next = p2;
            curInsert = p2;
            p2 = p2->next;
        }
    }

    while (p1)
    {
        curInsert->next = p1;
        curInsert = p1;
        p1 = p1->next;
    }
    while (p2)
    {
        curInsert->next = p2;
        curInsert = p2;
        p2 = p2->next;
    }

    curInsert->next = NULL;
    return result;
}

ListNode* sortListRecur(ListNode* head)
{
    if (!head || !head->next) return head;

    ListNode* q = head;
    ListNode* p = head->next;

    // split the list to two lists
    while (p && p->next)
    {
        q = q->next;
        if (p->next)
            p = p->next->next;
    }
    ListNode* head2 = q->next;
    q->next = NULL;

    // sort the two list first
    ListNode* result1 = sortListRecur(head);
    ListNode* result2 = sortListRecur(head2);

    // merge list head1 with list head2
    result1 = mergeList(result1, result2);
    return result1;
}

ListNode* sortList(ListNode* head) {
    if (!head) return head;

    head = sortListRecur(head);
    return head;
} };