148. 排序链表

 思路：归并排序

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        ListNode dump = new ListNode(-1);
        dump.next = head;
        return reclusive(dump).next;
    }

    static ListNode reclusive(ListNode dump) {
        if (dump == null || dump.next == null || dump.next.next == null) {
            return dump;
        }
        ListNode[] arr = partition(dump);
        ListNode l = reclusive(arr[0]);
        ListNode r = reclusive(arr[1]);
        return mergeTwoList(l, r);
    }

    static ListNode[] partition(ListNode dump) {
        ListNode cur = dump;
        int count = -1;
        while (cur != null) {
            cur = cur.next;
            ++count;
        }
        int mid = count >> 1;
        cur = dump;
        count = 0;
        while (cur != null) {
            cur = cur.next;
            ++count;
            if (count == mid) {
                break;
            }
        }
        ListNode[] res = new ListNode[2];
        res[0] = dump;
        res[1] = new ListNode(-1);
        if (cur != null) {
            res[1].next = cur.next;
            cur.next = null;
        } else {
            res[1].next = null;
        }
        return res;
    }

    static ListNode mergeTwoList(ListNode l, ListNode r) {
        ListNode cur = l, curL = l.next, curR = r.next;
        while (curL != null && curR != null) {
            if (curL.val <= curR.val) {
                cur.next = curL;
                curL = curL.next;
            } else {
                cur.next = curR;
                curR = curR.next;
            }
            cur = cur.next;
        }
        if (curL != null) {
            cur.next = curL;
        }
        if (curR != null) {
            cur.next = curR;
        }
        return l;
    }
}