笔记 | Java 数据结构——归并排序

 代码解读

· 当没有给出merge（）的时候，就是在不断地拆分，如果此时输出数组，还是【8,4,5,7,1,3,6,2】
· 当给出了merge（）的时候，首先把这个数组拆分成了【8，4   5，7，1，3，6，2】（意思就是只是把8，4拆分了，剩下的部分并没有拆分）
  这里需要注意一下，拆的时候我们想象成拆到8  4  5  7  1  3  6  2，但实际上真的如此吗？ 其实拆到8，4   5，7  1，3  6，2的时候，已经可以开始对8，4进行排序了（此时left=0，right=1，mid=0）
  此时mergeSort方法就执行到了merge（），开始对8，4进行排序变成【4，8，   5,7,1,3,6,2】
  那么就会产生了疑问，5，7 什么时候拆分呢？
  在我们对4，8排序完了之后就会跳转到mergeSort（），因为刚刚已经把merge（）执行完了，所以mergeSort（）就会退出，根据递归的原则，他会返回上一层，此时left=0，right=3，mid=1
  因为我们刚刚已经执行完了这一层中的mergeSort(arr,left,mid,temp); 所以会继续向下执行mergeSort(arr,mid+1,right,temp);那么就会对5，7进行拆分
  然后一直执行到了merge（），对5，7进行排序，排序完成后，变成了4，8，5，7，1，3，6，2
  然后又会回到这一层（left=0，right=3，mid=1），刚刚我们已经把mergeSort(arr,left,mid,temp);和mergeSort(arr,mid+1,right,temp);执行完毕
  会继续向下执行merge（），完成对4，8，5，7进行排序->【4，5，7，8，1，3，6，2】
  这一步执行完之后，这一层（left=0，right=3，mid=1）执行完毕
  根据递归的原则，他会返回上一层，此时left=0，right=7，mid=3。因为我们已经把这一层的mergeSort(arr,left,mid,temp);所以会继续向下执行mergeSort(arr,mid+1,right,temp);
  进行对这个数组右半部分的拆分，然后一直拆分到1   3，然后对1，3，进行排序。。。。。
  以此类推。

  归并排序的难点主要是“分”和“治”的过程过长、过多，并且使用了两个递归，很容易让人蒙圈。
  强烈建议用debug耐心一步一步走！！！！

  一开始让我十分疑惑的就是，我认为程序所谓的“分”是类似我们日常当中的分成一块一块，实际上并不是。其实就是他让left和right之间的距离不断地缩小。
  “分”只是我们抽象意义上的。

代码实现

import java.util.Arrays;


/*
· 当没有给出merge（）的时候，就是在不断地拆分，如果此时输出数组，还是【8,4,5,7,1,3,6,2】
· 当给出了merge（）的时候，首先把这个数组拆分成了【8，4   5，7，1，3，6，2】（意思就是只是把8，4拆分了，剩下的部分并没有拆分）
  这里需要注意一下，拆的时候我们想象成拆到8  4  5  7  1  3  6  2，但实际上真的如此吗？ 其实拆到8，4   5，7  1，3  6，2的时候，已经可以开始对8，4进行排序了（此时left=0，right=1，mid=0）
  此时mergeSort方法就执行到了merge（），开始对8，4进行排序变成【4，8，   5,7,1,3,6,2】
  那么就会产生了疑问，5，7 什么时候拆分呢？
  在我们对4，8排序完了之后就会跳转到mergeSort（），因为刚刚已经把merge（）执行完了，所以mergeSort（）就会退出，根据递归的原则，他会返回上一层，此时left=0，right=3，mid=1
  因为我们刚刚已经执行完了这一层中的mergeSort(arr,left,mid,temp); 所以会继续向下执行mergeSort(arr,mid+1,right,temp);那么就会对5，7进行拆分
  然后一直执行到了merge（），对5，7进行排序，排序完成后，变成了4，8，5，7，1，3，6，2
  然后又会回到这一层（left=0，right=3，mid=1），刚刚我们已经把mergeSort(arr,left,mid,temp);和mergeSort(arr,mid+1,right,temp);执行完毕
  会继续向下执行merge（），完成对4，8，5，7进行排序->【4，5，7，8，1，3，6，2】
  这一步执行完之后，这一层（left=0，right=3，mid=1）执行完毕
  根据递归的原则，他会返回上一层，此时left=0，right=7，mid=3。因为我们已经把这一层的mergeSort(arr,left,mid,temp);所以会继续向下执行mergeSort(arr,mid+1,right,temp);
  进行对这个数组右半部分的拆分，然后一直拆分到1   3，然后对1，3，进行排序。。。。。
  以此类推。

  归并排序的难点主要是“分”和“治”的过程过长、过多，并且使用了两个递归，很容易让人蒙圈。
  强烈建议用debug耐心一步一步走！！！！

  一开始让我十分疑惑的就是，我认为程序所谓的“分”是类似我们日常当中的分成一块一块，实际上并不是。其实就是他让left和right之间的距离不断地缩小。
  “分”只是我们抽象意义上的。
 */
public class MergetSort {
    public static void main(String[] args) {
        int arr[]={8,4,5,7,1,3,6,2};
        int []temp=new int[arr.length];
        mergeSort(arr,0, arr.length-1,temp);
        System.out.println("归并排序后="+ Arrays.toString(arr));
    }

    public static void mergeSort(int []arr,int left,int right,int []temp){
        if(left<right){
            int mid=(left+right)/2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }

    public 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];
                i++; t++;
            }else{
                temp[t]=arr[j];
                j++;t++;
            }
        }

        while(i<=mid){
            temp[t]=arr[i];
            i++; t++;
        }
        while(j<=right){
            temp[t]=arr[j];
            t++;j++;
        }

        t=0;
        int tempLeft=left;
        while(tempLeft<=right){
            arr[tempLeft]=temp[t];
            t++;tempLeft++;
        }
    }
}

 备注：个人笔记，方便查阅。