[Leetcode] Sort List

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

Solution:

O(nlgn)的排序算法没几个，无非就是quick sort， heap sort和merge sort. 对于链表排序来说，难点之一就是如何O(1)定位节点。如果是数组，那么可以通过下标直接找到节点，但是对于链表，很明显没有下标这个东西可以用，如果需要定位到第k个元素，只能从节点头部顺序的访问K次，但是，如果排序中每一个定位操作都要这样做的话，就太慢了。
所以，问题其实就是，如何能够节省链表节点的定位时间。如果采用merge sort的话，就可以通过递归的特性来避免这个时间损耗。

/**
 * 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(head==null||head.next==null)
            return head;
        ListNode fast=head, slow=head;
        while(fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        fast=slow.next;
        slow.next=null;
        fast=sortList(fast);
        slow=sortList(head);
        return merge(fast,slow);
    }

    private ListNode merge(ListNode fast, ListNode slow) {
        // TODO Auto-generated method stub
        ListNode result=new ListNode(-1);
        result.next=null;
        ListNode cur=result;
        while(fast!=null&&slow!=null){
            if(fast.val<slow.val){
                cur.next=fast;
                fast=fast.next;
            }else{
                cur.next=slow;
                slow=slow.next;
            }
            cur=cur.next;
        }
        if(fast!=null){
            cur.next=fast;
        }
        if(slow!=null){
            cur.next=slow;
        }    
        return result.next;
    }
}