LeetCode Sort List Java版本

题目描述：

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

题目分析：

时间复杂度要求O(n log n)，符合这个要求的排序算法有快速排序、堆排序和归并排序。

但这个是链表，又要求是常数空间，所以不太好解决。

看的别人的解法，归并排序（分而治之），感觉做的很好，因此写在这里分享一下。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeList(ListNode h1, ListNode h2){
        if(h1==null)
            return h2;
        if(h2==null)
            return h1;
        
        if(h1.val < h2.val){
            h1.next = mergeList(h1.next, h2);
            return h1;
        }
        else{
            h2.next = mergeList(h1, h2.next);
            return h2;
        }
        
    }
    
    public ListNode sortList(ListNode head) {
        if(head==null)
            return head;
        if(head.next==null)
            return head;
        
        ListNode p = head;
        ListNode q = head;
        ListNode pre = head;
        
        while(q!=null && q.next!=null){
            pre = p;
            p = p.next;
            q = q.next.next;
        }
        pre.next = null;
        
        ListNode h1 = sortList(head);
        ListNode h2 = sortList(p);
        
        return mergeList(h1,h2);
        
    }
}

也有人说这种解法会消耗O(logn)的栈空间，所以可能这不是最好的解法。