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

package com.main;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

public class Main {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        //平分結點，分成兩個分支
        ListNode cur = null, slow = head, fast = head;
        while (fast != null && fast.next != null) {//如果是奇數個結點，多出來的一個結點放在了後面的部分
            cur = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        cur.next = null;
        //每個分支都要排序，然後按序合併
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        //按序合併，子分支和大分支都在這裡合併
        return merge(l1, l2);
    }//sortList

    public ListNode merge(ListNode l1, ListNode l2) {
        ListNode res = new ListNode(0), p = res;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                res.val = l1.val;
                p.next = l1;//這一句別忘了
                l1 = l1.next;
            } else {
                res.val = l2.val;
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }//while

        if (l1 != null) {
            p.next = l1;
        }
        if (l2 != null) {
//            p.next = l2.next;不能是p.next = l2.next
            p.next = l2;
        }
        return res.next;// ListNode res = new ListNode(0)因為第一個結點是0，所以這裡是 res.next,而不是res
    }//merge

    public static void main(String[] args) {
        ListNode A = new ListNode(6);
        A.next = new ListNode(2);
        A.next.next = new ListNode(4);
        A.next.next.next = new ListNode(3);
        A.next.next.next.next = new ListNode(5);

        Main main = new Main();
        ListNode C = main.sortList(A);
        System.out.println(C);
    }
}
 

以下為遞迴執行流程，分別是2個結點和4個結點的情況

15 / 15 test cases passed.
Status: Accepted
Runtime: 8 ms
T(n) = O(nlogn)