400. 最大间距

400. 最大间距

 

给定一个未经排序的数组, 请找出这个数组排序之后的两个相邻元素之间最大的间距.

如果数组中少于 2 个元素, 返回 0.

样例

样例 1:

输入: [1, 9, 2, 5]

输出: 4

解释: 排序之后的数组是 [1, 2, 5, 9], 最大的间距是在 5 和 9 之间.

样例 2:

输入: [1]

输出: 0

解释: 数组中的元素少于 2 个.

挑战

直接排序很容易, 但是时间复杂度是 O(nlogn), 尝试使用线性时间和空间复杂度的方法解决这个问题.

注意事项

可以假定数组中的所有要素都是非负整数，且最大不超过 32 位整数。

 

 

1、基数排序 + 遍历比较 O(kn) k为最大元素的位数

  public int maximumGap(int[] nums) {

        // write your code here

        if (nums == null || nums.length < 2) {

            return 0;

        }

        radixSort(nums);

        int ans = nums[1] - nums[0];

        for (int i = 1; i < nums.length; i++) {

            ans = Math.max(ans, nums[i] - nums[i - 1]);

        }

        return ans;

    }

    //基数排序 O(kn) k为最大元素的位数

    private void radixSort(int[] nums) {

        //用10个list存中间元素

        List<List<Integer>> lists = new ArrayList<>();

        for (int i = 0; i < 10; i++) {

            lists.add(new ArrayList<>());

        }

        //找到最大数字

        int max = nums[0];

        for (int i = 0; i < nums.length; i++) {

            max = Math.max(max, nums[i]);

        }

        //记录当前位数

        int exp = 1;

        //从右往左一位一位比较

        while (max > 0) {

            for (int i = 0; i < 10; i++) {

                lists.set(i, new ArrayList<Integer>());

            }

            for (int i = 0; i < nums.length; i++) {

                lists.get(nums[i] / exp % 10).add(nums[i]);

            }

            int index = 0;

            for (int i = 0; i < 10; i++) {

                for (int j = 0; j < lists.get(i).size(); j++) {

                    nums[index++] = lists.get(i).get(j);

                }

            }

            max /= 10;

            exp *= 10;

        }

    }

2、桶排序 O(n)

  public int maximumGap(int[] nums) {

        // write your code here

        if (nums == null || nums.length < 2) {

            return 0;

        }

        int len = nums.length;

        int min = nums[0];

        int max = nums[0];

        for (int num : nums) {

            max = Math.max(max, num);

            min = Math.min(min, num);

        }

        if (max == min) {

            return 0;

        }

        //算出每个箱子的范围

        int interval = (int)Math.ceil((double)(max - min) / (len - 1));

        //建n-1个桶

        int[] bucketMin = new int[len - 1];

        int[] bucketMax = new int[len - 1];

        //初始化桶的最小值和最大值

        Arrays.fill(bucketMin, Integer.MAX_VALUE);

        Arrays.fill(bucketMax, -1);

        

        for (int i = 0; i < len; i++) {

            //最小数和最大数不考虑

            if (nums[i] == min || nums[i] == max) {

                continue;

            }

            //当前数字所在桶编号

            int index = (nums[i] - min) / interval;

            //更新桶的最小值和最大值

            bucketMin[index] = Math.min(nums[i], bucketMin[index]);

            bucketMax[index] = Math.max(nums[i], bucketMax[index]);

        }

        

        int maxGap = 0;

        //初始化前一个桶的最大值记录为min

        int prevMax = min;

        for (int i = 0; i < len - 1; i++) {

            //空桶跳过

            if (bucketMax[i] == -1) {

                continue;

            }

            //更新最大gap

            maxGap = Math.max(bucketMin[i] - prevMax, maxGap);

            //更新前一个桶的最大值记录

            prevMax = bucketMax[i];

        }

        //特殊处理max

        maxGap = Math.max(max - prevMax, maxGap);

        return maxGap;

    }