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);
    }
};

java code:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }

        ListNode prev = null, slow = head, fast = head;

        while(fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;// cut the list to two list

        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);

        // merge two list
        return merge(l1, l2);
    }

    public ListNode merge(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;

        ListNode res = new ListNode(0);
        ListNode p = res;

        while(l1 != null && l2 != null) {
            if(l1.val <= l2.val) {
                p.next = l1;
                l1 = l1.next;
            }else {
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }

        if(l1 != null) {
            p.next = l1;
        }
        if(l2 != null) {
            p.next = l2;
        }

        return res.next;
    }
}