LeetCode Sort List 链表的归并排序

思路：

模仿数组的归并排序：

//Merge Sort
void merge_array(int a[], int left, int mid, int right, int temp[]) {
    int i = left, j = mid + 1;
    int m = mid, n = right;
    int k = 0;
    while(i <= m && j <= n) {
        if(a[i] < a[j]) {
            temp[k++] = a[i++];
        }else {
            temp[k++] = a[j++];
        }
    }
    while(i <= m) {
        temp[k++] = a[i++];
    }
    while(j <= n) {
        temp[k++] = a[j++];
    }
    for(int i = 0; i < k; ++i) {
        a[left + i] = temp[i];
    }
}
void merge_sort(int a[], int left, int right, int temp[]) {
    if(left < right) {
        int mid = (left + right) / 2;
        merge_sort(a, left, mid, temp);
        merge_sort(a, mid + 1, right, temp);
        merge_array(a, left, mid, right, temp);
    }
}

主要步骤：

（1）递归分解（重点是找到middle node，这里参考别人的方法，通过快慢指针找到链表的middle node，注意还要断开middle node前后的两个链表）

（2）合并

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
    ListNode *getMid(ListNode *head) {
        ListNode *fast = head->next;
        ListNode *slow = head->next;
        ListNode *prev = head;
        while(true) {
            if(fast != NULL) {
                fast = fast->next;
            }else {
                break;
            }
            if(fast != NULL) {
                fast = fast->next;
            }else {
                break;
            }
            prev = slow;
            slow = slow->next;
        }
        prev->next = NULL;
        return slow;
    }
    ListNode* merge(ListNode *head1, ListNode *head2) {
        ListNode *dummy = new ListNode(-1);
        ListNode *p = dummy;
        while(head1 != NULL && head2 != NULL) {
            if(head1->val < head2->val) {
                p->next = head1;
                head1 = head1->next;
            }else {
                p->next = head2;
                head2 = head2->next;
            }
            p = p->next;
            p->next = NULL;
        }
        if(head1 != NULL) {
            p->next = head1;
        }
        if(head2 != NULL) {
            p->next = head2;
        }
        return dummy->next;
    }
public:
    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode *head1 = head;
        ListNode *head2 = getMid(head);
        head1 = sortList(head1);
        head2 = sortList(head2);
        return merge(head1, head2);
    }
};