Leetcode_148. 排序链表以及归并排序的复习

148. 排序链表

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表
进阶：
你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
题目要求时间空间复杂度分别为O(nlogn)和O(1)，根据时间复杂度我们自然想到二分法，从而联想到归并排序

首先先复习一下

归并排序

就是利用归并的思想实现的排序方法，假设初始记录含有n个记录，则可以看成n个有序的子序列，每个子序列长度为1，然后两两归并，得到不小于[n/2]的最小整数个长度为2或1的有序子序列，再两两归并…如此重复，直到得到一个长度为n的有序序列为止，这种称为2路归并排序

伪代码实现

void MergeSort(SqList *L)
{
    MSort(L->r,L->r,1,L->length);
}

void MSort(int unorder[],int ordered[],int start,int end )
{
    int m;
    int temp[MAXSIZE+1];;
    if(start==end) //表示数组元素只有一个 
        ordered[start]=unorder[start];
    else
    {
        mid=(start+end)/2;
        MSort(unorder,temp,start,mid);//将左半边归并为有序的temp数组
        MSort(unorder,temp,mid+1,end);//右半边同理
        Merge(temp,ordered,start,mid,end);//合并两半
    }
}
void Merge(int unorder[],int ordered[],int start,int mid,int end)
{
    int j,k,l;
    for(j=mid+1,k=start;start<=mid&&j<=end;k++)//k表示ordered数组起始处 
    {
        if(unorder[start]<unorder[j])
            ordered[k]=unorder[start++];//比较 把小的放前面 从小到大
        else
            ordered[k]=unorder[j++];
    }
    //接下来就是归并剩下的数组数据，移动到ordered数组的后面
    if(start<=mid)
    {
        for(l=0;l<=mid-start;l++)
            ordered[k+1]=unorder[start+1];
    }
    if(j<=end)
    {
        for(l=0;l<=end-j;l++)
            ordered[k+1]=unorder[j+1];

    }
}

Java实现

public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        Mergesort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void Mergesort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        Msort(arr,0,arr.length-1,temp);
    }
    private static void Msort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            Msort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            Msort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

而现实如何快速找到归并中点，可使用快慢指针来实现，快指针一次走两步，慢指针一次走一步，当快指针走完时，慢指针即是终点，但这里注意区分题目要求，来决定快指针是走到null为止还是走到数组最后一个元素为止
这里可以参考 Leetcode 876题 求链表的中间结点

回到这道题 排序链表
代码实现如下

class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null)
            return head;
        //快慢指针求中点
        ListNode fast = head.next, slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode temp = slow.next;
        slow.next = null;
        ListNode left = sortList(head);
        ListNode right = sortList(temp);
        ListNode h = new ListNode(0);
        ListNode ans = h;
        while (left != null && right != null) {
            if (left.val < right.val) {
                h.next = left;
                left = left.next;
            } else {
                h.next = right;
                right = right.next;
            }
            h = h.next;
        }
        h.next = left != null ? left : right;
        return ans.next;
    }
}