LeetCode 148. Sort List(java)

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

思路：由于linkedlist是一个不回头的只向下走的数据结构，因此，我们在考虑多种排序方式时，会发现快排需要双指针找pivot，因此不合适，而merge sort不需要回头，只需要找mid切断，再merge起来即可，并且时间复杂度较好，达到要求。因此，这里我们使用merge sort的思想来sort linkedlist.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode slow = head, fast = head, pre = null;
        //注意，这里不能写成while (fast.next != null && fast.next.next != null)，因为，在只有两个node的情况下fast和slow指针还是需要向下走，否则无法分解成一个node.
        while (fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        //note: 这里需要一个pre指针来保存slow的上一个node，因为需要把上一个node的next设为null.
        pre.next = null;
        //merge的时候，参数是两个sort好的linkedlist的head，需要使用sortList的返回值。
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        return merge(l1, l2);
    }
    public ListNode merge(ListNode head, ListNode head2) {
        ListNode dummy = new ListNode(-1), p = dummy;
        while (head != null && head2 != null) {
            if (head.val < head2.val) {
                p.next = head;
                head = head.next;
            } else {
                p.next = head2;
                head2 = head2.next;
            }
            p = p.next;
        }
        if (head != null) {
            p.next = head;
        }
        if (head2 != null) {
            p.next = head2;
        }
        return dummy.next;
    }
}