归并排序（递归，非递归）java

package day03;

public class Sun01mergeSort {
    /*
    * 归并排序
    * 思路：分治法
    * 递归版，非递归版
    * */
    //递归版
    public static void mergeSort(int[] arr,int left,int right){
        //当left和right相等就截止计算
        if(left == right){
            return;
        }
        //mid的值是中间值
        int mid = left + ((right - left)>>1);
        //先递归左半边，一直递归到left == right，相当于merge首先执行的是left=0，mid=0，right=1
        mergeSort(arr,left,mid);
        mergeSort(arr,mid + 1,right);
        merge(arr,left,mid,right);
    }
    public static void merge(int[] arr,int left,int mid,int right){
        //L,R相当于两段的指针，因为left，right作为标志不方便动，所以需要这俩指针
        int L = left;
        int R = mid + 1;
        //****这行我总是错，注意：help的长度必须取决于这次的right和left的值，所以每次都不相同，这是为了使把help有数的地方赋给arr
        //若是int[arr.lenght]则会报错，因为最后一行代码，便利help会将help后面空的值赋给arr，报错
        //help作用：将排好序的数组先放到help数组，之后将他重新赋给arr数组，直到最后一次赋值arr中的数都排好序了
        int[] help = new int[right-left+1];
        //计数用的，方便给help数组赋值
        int count = 0;
        //只要L《mid或者R《right就是没到头，就一直到其中一个到头，两块才全部比较完成
        while(L <= mid && R <= right){
            //比较大小，小的放在help数组中
            if(arr[L] <= arr[R]){
                help[count++] = arr[L++];
            }else{
                help[count++] = arr[R++];
            }
        }
        //上一个循环跳出肯定会有一个条件没有满足，即两个指针中的一个没有到头，继续将其后面的所有数赋给help数组（后面的数肯定是排好顺序的）
        while(L <= mid){
            help[count++] = arr[L++];
        }
        while(R <= right){
            help[count++] = arr[R++];
        }
        //注意千万不能写成i《arr.length
        for (int i = 0; i < help.length; i++) {
            //****注意：arr[left+i] ,原因是left每次传进来是变化的，因为得一段一段比较，所以在比较右面的部分，排好序后肯定不能直接赋给arr[i]
            arr[left + i] = help[i];
        }
    }

    //非递归版
    public static void mergeSort2(int[] arr,int left,int right){
        if(arr == null || arr.length == 1){
            return;
        }
        //定义步长
        int size = 1;
        int N = arr.length;
        //如果步长小于数组长度就循环
        while(size < N){
            //定义左端指针
            int L = 0;
            //如果左端指针小于数组长度
            while(L < N) {
                int mid = L + size -1;
                //对于两端分不了一半，即奇数，即会多出一块，不会影响，但是不会计算右端，若是正常mid肯定《=N，若是mid》N则肯定是这种情况，直接break不算
                if(mid > N){
                    break;
                }
                //也有一种情况是可以比较，就是右端的数不够，所以R的值不是+size，而是加上N-1-mid，判断这两种情况那种小，正常一样大
                int R = mid + Math.min(size,N-1-mid);
                //merge
                merge(arr,L,mid,R);
                //比较完一对比较下一对，直接L=R+1
                L = R + 1;
            }
            //防止溢出
            if(size > N/2){
                break;
            }
            //步长乘2
            size = size<<1;
        }
    }

    public static void again(int[] arr,int left,int right){
        int size = 1;
        int N = arr.length;
        while(size < N){
            int L = 0;
            while (L < N){
                //和上面mid》N都行，但是上面的更好，L+size和mid就差1，而这个一都属于多出来的都可不比较
                if(L +size>N){
                    break;
                }
                int mid = L + size - 1;
                int R = mid + Math.min(size,N-1-mid);
                merge(arr,L,mid,R);
                L = R + 1;
            }
            if(size > N/2){
                break;
            }
            size = size*2;
        }
    }
    public static int[] random(int size,int value){
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = (int)(Math.random()*value+1) - (int)(Math.random()*value);
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] arr = {12,3,4,3,41,31,23,1212,4,34};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        mergeSort2(arr,0,9);
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        arr = random(10,200);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        mergeSort(arr,0,9);
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println("\n测试开始：");
        int num = 1000000;
        for (int i = 0; i < num; i++) {
            arr = random(10,(int)(Math.random()*1000+1));
            int[] arr2 = arr;
            mergeSort(arr,0,9);
            again(arr2,0,9);
            for (int j = 0; j < arr.length; j++) {
                if(arr[j] != arr2[j]){
                    System.out.println("出错！");
                }
            }
        }
        System.out.println("测试结束");
    }
}