Sort List

Sort List 

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

这道题我想过用直接插入，超时了。百度了一下，用的是归并排序，排序以前用的都是数组，这次用链表，不太习惯

参考：http://blog.csdn.net/worldwindjp/article/details/18986737

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if(null == head || null == head.next)
            return head;                                        //空链表和只有一个节点的链表直接返回head
        
        ListNode middle = getMiddle(head);                        //得到中点节点
        ListNode next = middle.next;
        middle.next = null;          
        
        return merge(sortList(head), sortList(next));
    }
    
    /**
     * 获取链表的中间位置节点，一个指针走一步，另一个指针走两步
     * @param head
     * @return
     */
    public ListNode getMiddle(ListNode head){
        ListNode fast = head;
        ListNode slow = head;
        
        while(null != fast.next && null != fast.next.next){
            fast = fast.next.next;
            slow = slow.next;
        }
        
        return slow;
    }
    
    /**
     * 合并两个有序链表
     * @param a
     * @param b
     */
    public ListNode merge(ListNode a, ListNode b){
        ListNode dummyHead = new ListNode(Integer.MIN_VALUE);
        ListNode cur = dummyHead;
        while(null != a && null != b){            //开始合并两个链表，放到dummyHead为头结点的链表中
            if(a.val <= b.val){
                cur.next = a;
                a = a.next;
            }
            else{
                cur.next = b;
                b = b.next;
            }
            cur = cur.next;
        }//while
        cur.next = a != null ? a : b;
        
        return dummyHead.next;
    }
}