LeetCode 148. Sort List

原题链接在这里：https://leetcode.com/problems/sort-list/

题目：

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

题解：

divide and conquer. 从中点开始把原list段成两个list. 一直拆到只有一个点，再按照Merge Two Sorted Lists给合并回来。

与Insertion Sort List类似。

Time Complexity: O(nlogn). Space: O(logn), 用了logn层stack.

AC Java:

/**
 * 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 mid = findMiddle(head); //找到中点
        ListNode secondHead = mid.next; //中点后一个点最为另一个head.
        mid.next = null;    //断开
        return mergeTwoSortedLists(sortList(head), sortList(secondHead)); //divide and conquer 的merge sort
    }
    private ListNode findMiddle(ListNode head){
        ListNode walker = head;
        ListNode runner = head;
        while(runner.next != null && runner.next.next != null){
            walker = walker.next;
            runner = runner.next.next;
        }
        return walker;
    }
    private ListNode mergeTwoSortedLists(ListNode l1, ListNode l2){
        if(l1 == null){
            return l2;
        }
        if(l2 == null){
            return l1;
        }
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            }else{
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        if(l1 != null){
            cur.next = l1;
        }
        if(l2 != null){
            cur.next = l2;
        }
        return dummy.next;
    }
}