算法：归并排序（Java）

思路展示：

归并排序算法讲解

（本视频来自网络,仅供个人观赏学习交流,请勿转载或商用。）

---

Java代码实现：

import java.util.Arrays;

public class mergeSort {
    //主方法
    public static void main(String[] args){
        int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for(int i = 0; i < testTime; i++){
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            if(!isEqual(arr1, arr2)){
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice~" : "Fucking fucked!");
    }
    //归并排序
    public static void mergeSort(int[] arr){//归并的入口
        int[] temp = new int[arr.length];
        msort(arr, temp, 0, arr.length-1);//默认对整个数组进行排序
    }
    //划分
    public static void msort(int[] arr, int[] temp, int left, int right){
        //只有一个元素就不需要再划分
        if(left < right){
            //找中间点
            int mid = (left + right)/2;
            //递归划分
            msort(arr, temp, left, mid);
            msort(arr, temp, mid+1, right);
            //划分完后再重新合并
            merge(arr, temp, left, mid, right );
        }
    }
    //合并
    public static void merge(int[] arr, int[] temp, int left, int mid ,int right){
        //标记左半区第一个未排序的元素
        int l = left;
        //标记右半区第一个未排序的元素
        int r = mid + 1;
        //临时数组元素的下标
        int cur = left;
        //合并（左右都不越界）
        while(l <= mid && r <= right){
            //左半组的元素较小
            if(arr[l] < arr[r]){
                temp[cur] = arr[l];//将较小的元素先放入临时数组中去
                l++;
            }else{
                //右半组的元素较小或者两者想通过的情况
                temp[cur] = arr[r];
                r++;
            }
            cur++;
        }
        //合并（左越界，右不越界）
        while(l > mid && r <=right){
            temp[cur] = arr[r];
            cur++;
            r++;
        }
        //合并（左不越界，右越界）
        while(l <= mid && r>right){
            temp[cur] = arr[l];
            cur++;
            l++;
        }
        //把临时数组元素中合并后的元素复制回原来的数组
        while(left <= right){
            arr[left] = temp[left];
            left++;
        }
    }
    //随机素组生成器
    public static int[] generateRandomArray(int maxSize, int maxValue){
        int[] arr = new int[maxSize * ((int)Math.random() + 1)];
        for(int i = 0; i < arr.length; i++){
            arr[i] = maxValue * (int)Math.random() - (maxValue * (int)Math.random());
        }
        return arr;
    }
    //数组复制器
    public static int[] copyArray(int[] arr){
        if(arr == null){
            return null;
        }
        return arr;
    }
    //比对
    public static boolean isEqual(int[] arr1, int[] arr2){
        if(arr1 == null && arr2 != null || arr1 != null && arr2 == null){
            return false;
        }
        if(arr1 == null && arr2 == null){
            return true;
        }
        for(int i = 0; i < arr1.length; i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
    //对数器
    public static void comparator(int[] nums){
        Arrays.sort(nums);
    }
}