算法经典题型 图解分析+代码不能再详细了！——给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序。

给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序。

​

代码​

package Ashier.arithmetic.my_exercise;

import java.util.Arrays;

/**
 * 给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序
 *
 * @author shierS
 * @date 2021/4/2
 */
public class MaxGap {

    /**
     * 我们写的方法
     * @param arr 目标数组
     * @return 返回所求结果
     */
    static int myMaxGap(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        int length = arr.length;//数组长度
        int subtract;//最大值-最小值
        //获取数组最大值和最小值
        int min = arr[0];
        int max = arr[0];
        for (int i = 1; i < length; i++) {
            min = Math.min(arr[i], min);
            max = Math.max(arr[i], max);
        }
        subtract = max - min;
        if (subtract == 0) { //差值为0，说明所有元素相同，最大差肯定为0
            return 0;
        }

        //创建length+1个桶，并将元素放入桶中
        int index;//数组中元素应该放在哪个桶的下标
        int[] bucketmin = new int[length + 1]; //桶中最小元素
        int[] bucketmax = new int[length + 1]; //桶中最大元素
        boolean[] buckethave = new boolean[length + 1]; //桶中是否有值
        for (int i = 0; i < length; i++) {//遍历桶
            index = getindex(arr[i], min, length, subtract);//获取元素在桶的下标
//            if(buckethave[index]){//如果桶中放过元素
//                bucketmin[index] = Math.min(arr[i],bucketmin[index]); //覆盖最小值
//                bucketmax[index] = Math.max(arr[i],bucketmax[index]); //覆盖最大值
//            }else {
//                buckethave[index] = true; //标记桶中放过元素
//                bucketmin[index] = arr[i]; //最小值为它
//                bucketmax[index] = arr[i]; //最大值也为它
//            }
            //上面if else可以改写为以下
            bucketmin[index] = buckethave[index] ? Math.min(arr[i], bucketmin[index]) : arr[i];
            bucketmax[index] = buckethave[index] ? Math.max(arr[i], bucketmax[index]) : arr[i];
            buckethave[index] = true;
        }

        //遍历桶找出答案
        int result = 0; //结果，相邻元素最大差值
        int lastmax = bucketmax[0]; //上一个非空桶中的最大值
        for (int i = 0; i < length + 1; i++) {
            if (buckethave[i]) {//如果桶中有元素
                int num = bucketmin[i] - lastmax; //获取差值
                result = Math.max(num, result); //差值比较取最大值
                lastmax = bucketmax[i]; //将该桶最大值赋给lastmax以供下一个非空桶比较
            }
        }
        return result;
    }

    /**
     * 获取元素在桶中的下标
     * @param arri 需要判断的某一个元素
     * @param min 数组最小元素
     * @param length 数组长度
     * @param subtract 数组最大值-最小值差值
     * @return 返回该元素所在桶的下标
     */
    static int getindex(int arri, int min, int length, int subtract) {
        return (int) (((arri - min) * length) / subtract);
    }

    /**
     * 使用绝对正确的方法获取结果（不限要求）与我们自己写的方法结果作比较验证我们的结果是否正确
     * @param arr 传入我们复制过的数组
     * @return 返回正确答案
     */
    public static int comparator(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        Arrays.sort(arr);
        int gap = Integer.MIN_VALUE;
        for (int i = 1; i < arr.length; i++) {
            gap = Math.max(arr[i] - arr[i - 1], gap);
        }
        return gap;
    }


    /**
     * 生成随机数组
     * @param maxSize 数组大小
     * @param maxValue 数组元素最大值
     * @return 返回随机数组
     */
    static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    /**
     * 复制一份一模一样的数组供另一个方法使用，相互不影响
     * @param arr 目标数组
     * @return 返回复制的新数组
     */
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    public static void main(String[] args) {
        int testTime = 10000; //循环验证次数
        int maxSize = 20; //指定数组长度
        int maxValue = 1000; //指定元素最大值
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize,maxValue); //生成随机数组
            int[] arr2 = copyArray(arr); //复制目标数组
            int myresult = myMaxGap(arr); //自己写的方法返回值
            int tureresult = comparator(arr2); //绝对正确的返回值
            if (myresult == tureresult) {
                System.out.println("没毛病铁子！");
            } else {
                System.out.println("完了，又出bug了");
                for (int item: arr) {
                    System.out.print(item + ",");
                }
                System.out.println("你求的结果：" + myresult);
                System.out.println("正确的结果：" + tureresult);
                break;
            }
        }

    }
}