[leetcode]Sort List-链表排序 java

注意一下几项

1. nlogn时间复杂度，稳定的算法是堆排序和归并排序

2. 常数地址空间，堆排序不合适，考虑归并排序的变种

3. 注意链表查找中间节点的小算法

 

/**
 * 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) {
        return mergeSort(head);        
    }
    
    private ListNode mergeSort(ListNode head) {
        if(head == null){
            return null;
        }
        if(head.next == null){
            return head;
        }
        ListNode center = head;
        ListNode tail = head;
        while (tail.next!=null){
            if(tail.next.next==null){
                break;
            }
            tail = tail.next.next;
            center = center.next;
        }
        ListNode pre = center.next;
        center.next=null;
        ListNode head1 = mergeSort(head);
        ListNode head2 = mergeSort(pre);
        return merge(head1, head2);
    }

    private ListNode merge(ListNode head1, ListNode head2){
        ListNode head = new ListNode(0);
        ListNode p = head;
        ListNode temp = null;
        while (head1!=null && head2!=null){
            if(head2.val < head1.val){
               p.next=head2;
               if(head2.next != null){
                   temp = head2.next;
                   p.next.next = null;
                   head2 = temp;
               }else {
                   head2 = null;
               }

            }else {
                p.next=head1;
                if(head1.next != null){
                    temp = head1.next;
                    p.next.next = null;
                    head1 = temp;
                }else {
                    head1 = null;
                }

            }
            p=p.next;
        }
        if(head1!=null){
            p.next = head1;
        }
        if(head2!=null){
            p.next = head2;
        }
        return  head.next;
    }
}