leetcode----在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
      不带头节点
     思路：采用归并排序的方法。其时间复杂度为O（nlog2n）
         1.先找到链表的中点，将链表分成两部分。
         2.对两部分 递归排序
     */
    public ListNode sortList (ListNode head) {
        
        // 1.递归出口
        if(head==null || head.next==null){
            return head;
        }
        //2.确定链表的中点，将链表分成两部分
        ListNode mid = getMid(head);//中间节点
        ListNode first = head;//前部分链表
        ListNode second = mid.next; //后部分链表
        mid.next=null;
        //3.对链表进行归并排序
        return Merge(sortList(first),sortList(second));//对前后两个链表排序后，再合并
        
    }
    //一、确定中点节点
    public ListNode getMid(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        //快慢指针
        ListNode slow = head;
        ListNode quick = head;
        //快指针结束，慢指针到达中点
        while (quick.next != null && quick.next.next!= null) {
            slow = slow.next;
            quick = quick.next.next;
        }
        return slow;
    }


    //二、归并排序（每次将两个链表中值较小的节点加入）
    public ListNode Merge(ListNode aa,ListNode bb){
        ListNode ll = new ListNode(0);//初始化链表，存放排序后的节点
        ListNode a = aa;
        ListNode b = bb;
        ListNode l = ll;
        while(a!=null && b!=null){
            if(a.val<b.val){
                l.next=a;
                a = a.next;
            }else{
                l.next=b;
                b=b.next;
            }
            l=l.next;
        }//while
        if(a!=null){
            l.next=a;
        }
        if(b!=null){
            l.next=b;
        }
        return ll.next;
    }
    
    
    
}