利用桶进行排序

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

求解：

利用桶。　　①准备N个数，准备N+1个桶。

　　　　　　②遍历数组找最小值min和最大值max

　　　　　　1.如果min=max，数组是一种数，差值为0；

　　　　　　2.如果min！=max：

　　　　　　　　则①最小值放在0号桶，最大值放在第N号桶，中间数值等分为N+1份放入中间的桶中。

　　　　　　　　****中间必有一个空桶。

　　　　　　　　排序后的相邻数：1.在一个桶（内部差值一定是不需要的）

　　　　　　　　　　　　　　　　2.不在一个桶（最大差值来自不同的桶，前提是桶内不止一个数（除了例子a））

例子a：

　　　　左边是非空桶有max  中间是空桶  右边是非空桶min   （空桶左右非空桶）

　　　　　　max与min的差值大于桶表示的范围

　　　　　　①找非空桶的前一个非空桶的最大值，记录相减差

　　　　　　②为什么不直接找空桶？

　　　　　　　　当空桶前后的非空桶只进入一个数值后：

　　　　　　　　　　A（10-19）　　　B（20-29）　　　　C（39-39）　　　　D（40-49）

　　　　　　　　　　　　19　　　　　　　null　　　　　　　　30　　　　　　　　49

　　　　　　　　　　这种情况下，AC相差11，CD相差19.所以不直接找空桶。

 

代码如下：

public static int maxGap(int [] nums) {
            
            if(nums==null||nums.length<2) {
                return 0;    
            }
            
            int len =nums.length;//数组长度
            int min =Integer.MAX_VALUE;//系统最大值做数组中的最小值
            int max=Integer.MIN_VALUE;//系统最小值做数组中的最大值     目的遍历找到最小值最大值
            
            for(int i=0;i<len;i++) {
                min=Math.min(min, nums[i]);
                max=Math.max(max, nums[i]);
            }
            //更新最值
            if(min==max) {
                return 0;
            }
            //长度都位N+1
            //每个桶的三组信息
            boolean[] hasNum=new boolean[len+1];
            int [] maxs=new int[len+1];
            int [] mins=new int[len+1];
            int bid =0;
            
            for(int i=0;i<len;i++) {//重新遍历整个数组
                //确定当签署属于几号桶
                bid=bucket(nums[i],len,min,max);
                //数组放入桶中后，比较更新最值
                mins[bid]=hasNum[bid]?Math.min(mins[bid], nums[i]):nums[i];
                maxs[bid]=hasNum[bid]?Math.max(maxs[bid], nums[i]):nums[i];
                //更新信息
                hasNum[bid]=true;
            }
            
            int res=0;
            int lastMax=maxs[0];
            int i=1;
            //找到每一个非空桶和左边最近的非空桶
            for(;i<len;i++) {
                //用当前最小值——前一个桶的最大值
                if(hasNum[i]){
                    //差值;
                    res=Math.max(res, mins[i]-lastMax);
                    lastMax=maxs[i];
                }
            }
            //返回差值
            return res;
        }
        
        public static int bucket(long num, long len, long min, long max) {//num  数值，len  桶的个数
            // TODO 自动生成的方法存根
            //确定来自哪个桶
            return (int) ((num-min)*len/(max-min));
        }
        
        /*
        //对数器测试
        public static int comparator(int[] nums) {
            if(nums ==null||nums.length<2) {
                return 0;
            }
            
            Arrays.sort(nums);//系统内置排序
            int gap=Integer.MIN_VALUE;
            for(int i=1;i<nums.length;i++) {
                gap=Math.max(nums[i]-nums[i-1], gap);
            }
            return gap;
        }
        
        //随机生成数组
        public static int[] generatateArray(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;
            }
            
            //复制主数组
            
            
            public static void main(String[] args) {
                int testTime=50000;
                int maxsize=100;
                int maxvalue=100;
                boolean succeed=true;
                
                for(int i=0;i<testTime;i++) {
                    int [] arr1=generatateArray(maxSize,maxValue);
                    int [] arr2=copyArray(arr1);
                    
                    if(maxGap(arr1)!=comparator(arr2)) {
                        succeed=false;
                        break;
                    }
                }
                System.out.println(succeed?"ok!":"No");
            }
        }

        private static int[] copyArray(int[] arr) {
            // TODO 自动生成的方法存根
                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 a[] = {23,45,2,78,6,88,9,10,24};
            maxGap(a);
            System.out.println(maxGap(a));
        }