桶排序

桶排序：不基于比较的排序，与被排序的样本的实际状况很有关系，所以实际中并不经常使用

   时间复杂度O(n),额外空间复杂度O(n)

   稳定的排序

计数排序：实现了桶排序

一道实例：

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

（借用了桶概念，但没有进行桶排序）

（1）如果数组中有n个数，就准备n+1个桶，先遍历整个数组，找到最小值和最大值

（2）如果最小值和最大值相等，那么最大差值就是0

（3）每个桶中有三个值：标记数组是否有值，桶中最大值，桶中最小值

（4）将数组中的数平均的分在每个桶中，并找到每个数组中的最大值和最小值

（5）遍历所有桶，

         如果桶中有数，那么最大差值=该桶的最小值-前一个桶中的最大值

         如果桶中没数，那么就到下一个有数的桶，最大差值=该桶的最小值-前一个有数的桶中的最大值

代码实现：

package basic_class_01;

//桶排序
//1）数组中有n个数，设 n+1个桶，先遍历整个数组，找到最小值和最大值
//2）每个桶中有三个值:标记，最大值，最小值
//3）将数组中的数平均的放在桶中，并求出每个桶的最大值和最小值
//4）遍历所有桶，如果桶中有数，就最大值=该桶的最小值-前一个桶的最大值
//               如果桶中没数，就跳到下一个桶，最大值=下一个有数的桶的最小值-上一个有数桶的最大值
public class MaxGap {
    public static int maxGap(int[] nums) {
        if (nums == null || nums.length < 2) {
            return 0;
        }
        int len = nums.length;//长度设为数组的长度
        int max = Integer.MIN_VALUE;//最大值设为整数的最大值
        int min = Integer.MAX_VALUE;//最小值设为整数的最小值
//        找到数组中的最大值和最小值
        for (int i = 0; i < len; i++) {
            min = Math.min(min, nums[i]);
            max = Math.max(max, nums[i]);
        }
        if (max == min) {
            return 0;
        }
//        设三个数组，一个是桶是否有数的数组，一个是最大值的数组，一个是最小值的数组
        boolean[] hasNum = new boolean[len + 1];//桶数组（设为长度+1）
        int[] mins = new int[len + 1];
        int[] maxs = 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];//设变量为前一个桶的最大值

        for (int i = 1; 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) {

        return (int) ((num - min) * len / (max-min));//设置桶的边界
    }

    public static void main(String[] args) {
        int[] a = {99, 98, 89, 65, 43, 21, 1};
        int result = maxGap(a);
        System.out.println(result);
    }
}