漫画算法：无序数组排序后的最大相邻差值

一、题目：

有一个无序整型数组，如何求出这个数组排序后的任意两个相邻元素的最大差值？要求时间和空间复杂度尽可能低。
例如：无序数组 2,3,1,4,6，排序后是1,2,3,4,6，最大差值是6-4=2。

解法一：

解法一：用一种较快的稳定排序算法（比如归并算法，时间复杂度NlogN）给原数组排序，然后遍历排好序的数组，每两个相邻元素求差，最终得到最大差值。
**注：该解法的时间复杂度是O（NlogN），在不改变原数组的情况下，空间复杂度是O（N）。**

解法二：

1. 利用计数排序的思想，先求出原数组的最大值Max与最小值Min的区间长度k（k=Max-Min+1）。
2. 创建一个长度为k的新数组Array。
3. 遍历原数组，把原数组每一个元素插入到新数组Array对应的位置，比如元素的值为n，则插入到Array[n-min]当中。此时Array的部分位置为空，部分位置填充了数值。
4. 遍历新数组Array，统计出Array中最大连续出现空值的次数+1，即为相邻元素最大差值。例如给定无序数组 { 2, 6, 3, 4, 5, 10, 9 }，处理过程如下图：（注：图来自于掘金用户：https://juejin.im/post/5a44acaa6fb9a0451d41c850）
   
   注：该解法的时间复杂度为O（n+k），空间复杂度同样是O（n+k）。缺点：当数组中元素悬殊很大时，如1、100000000，则需要构造一个长度是100000000的新数组Array，则该方法不是最优解。

解法三：

1. 利用桶排序的思想，先求出原数组从最小值Min到最大值Max的单位区间长度d，d=(Max-Min)/n。算出d的作用是为了后续确定各个桶的区间范围划分。
2. 创建一个长度是N+1的数组Array，数组的每一个元素都是一个List，代表一个桶。
3. 遍历原数组，把原数组每一个元素插入到新数组Array对应的桶当中，进入各个桶的条件是根据不同的数值区间（数值区间如何划分，看后面的图就明白了）。由于桶的总数量是N+1，所以至少有一个桶是空的。
4. 遍历新数组Array，计算每一个空桶右端非空桶中的最小值，与空桶左端非空桶的最大值的差，数值最大的差即为原数组排序后的相邻最大差值。例如给定无序数组 { 0, 6, 3, 16, 7, 10, 9, 11, 20, 18 }，处理过程如下图：
   
   注：该解法的时间复杂度为O（n），空间复杂度同样是O（n）。

方法三的桶排序java实现

import java.util.*;

public class MaxDivision {
    public int findMaxDivision(int[] A, int n) {
        // write code here
        if(A == null || A.length<2){
            return 0;
        }
        //先找最大值和最小值
        int max = A[0];
        int min = A[0];
        for(int i=1;i<A.length;i++){
            if(A[i] > max){
                max = A[i];
            }else if(A[i] < min){
                min = A[i];
            }
        }
        //创建N+1个桶
        int N = A.length;
        int[] buckets = new int[N+1];
        //每个桶放的区间大小
        int d = (max - min)/(N);
        //存储每个桶中的最大值和最小值
        int[] bucketMax = new int[N+1];
        int[] bucketMin = new int[N+1];
        //标识桶中是否存在元素
        boolean[] hasNum = new boolean[N + 1];
        //桶号
        int bucketNum =0;
        //将元素分配到桶
        for(int i=0;i<N;i++){
            bucketNum = getBucketNum(A[i], N, min, max);
            if(hasNum[bucketNum]){
                bucketMax[bucketNum] = Math.max(bucketMax[bucketNum],A[i]);
                bucketMin[bucketNum] = Math.min(bucketMin[bucketNum],A[i]);
            }else{
                bucketMax[bucketNum] = A[i];
                bucketMin[bucketNum] = A[i];
                hasNum[bucketNum] = true;
            }
        }
        //寻找最大相邻差值
        int maxGap = bucketMax[0] - bucketMin[0];
        for(int i=1;i<N+1;i++){
            if(!hasNum[i]){
                int startNoNumIndex = i;
                while(!hasNum[i]){
                    i++;
                }
                int endNoNumIndex = i;
                int gap = bucketMin[endNoNumIndex] - bucketMax[startNoNumIndex-1];
                maxGap = Math.max(maxGap, gap);
            }
        }
        return maxGap;
    }
    //计算桶号,使用long类型是为了防止相乘时溢出
    public int getBucketNum(long value,long N,long min, long max){
        return (int)((value-min)*N/(max-min));
    }
}

在牛客中的运行结果截图如下：