LeetCode Sort List

Sort List

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

排序，时间复杂度为n(logn)，

 

我们知道堆排序，归并排序即使在最坏的情况下时间复杂度为n(logn)。

 

这里使用链表的归并排序实现。

 

/**
 * 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)
    		return null;
    	if(head.next==null)
    		return head;
    	ListNode p = head;
        ListNode q = head;
        while(q.next!=null&&q.next.next!=null)
        {
        	p=p.next;
        	q=q.next.next;
        }
        q=p.next;
        p.next=null;
        p=head;
        p=sortList(p);
        q=sortList(q);
        return merge(p,q);
    }
    
    public ListNode merge(ListNode p,ListNode q)
    {
        ListNode r = new ListNode(0);
        ListNode res = r;
        while(p!=null||q!=null)
        {
        	int a,b;
            if(p==null)
            	a = Integer.MAX_VALUE;
            else 
            	a=p.val;
            if(q==null)
            	b = Integer.MAX_VALUE;
            else 
            	b=q.val;
            if(a<=b)
            {
            	r.next=p;
            	p=p.next;
            }
            if(a>b)
            {
            	r.next=q;
            	q=q.next;
            }
        	r=r.next;
        }
        return res.next;
    }
}

 再来熟悉下排序的时间复杂度：