LeetCode 腾讯精选50题--链表排序

解题思路：归并

先把链表拆开，分为两部分，一直拆到只剩一个元素后，进行合并，利用一个临时节点记录重排后的链表的起始位置

合并不难，困难点在于如何拆分链表，自己的大体思路是利用两个指针，一个一次移动两位，一个移动一位，当移动快的结束时，慢的指针指向的位置就是链表的中间位置，

将中间位置往后的进行递归切割，然后将中间位置的下一个指针指向空，即断开链表，再对左边的子链进行递归。

边界条件就是当中间位置与起始位置重合时，就返回起始链表

代码如下：

 package algorithm;

 import basic.ListNode;

 public class SortLinkList {

     public ListNode sortList(ListNode head) {

         return sort(head,null);
     }

     private ListNode sort(ListNode head,ListNode middle) {

         if(head == null && middle == null){
             return null;
         }
         if(head == middle){
             return head;
         }
         ListNode fast = head;
         ListNode slow = head;
         while (fast != null && fast != middle && fast.next != middle){
             fast = fast.next.next;
             slow = slow.next;
         }

         ListNode subNode = slow;
         ListNode r = sort(slow.next,middle);

         subNode.next = null;
         ListNode l = sort(head,subNode);

         return merge(l,r);
     }

     private ListNode merge(ListNode left ,ListNode right){

         ListNode temp = new ListNode(0);
         ListNode record = temp;
         while (left != null && right!= null){
             if(left.val < right.val){
                 record.next = left;
                 left = left.next;

             }else {
                 record.next = right;
                 right = right.next;
             }
             record = record.next;
         }
         if(left != null){
             record.next = left;
         }else if(right!= null){
             record.next = right;
         }
         return temp.next;
     }

 }

但是由于只使用了一个空节点用于记录链表，所以空间复杂度为O(1) ，由于使用归并，时间复杂度为O(NlogN)。