leetcode164- 最大间距（Arrays.sort() or 桶排序）

介绍

我的LeetCode主页，一题一题解

标签：排序

164. 最大间距
难度 困难，讲真还挺简单

164. 最大间距
https://leetcode-cn.com/problems/maximum-gap/

题目

给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。

如果数组元素个数小于 2，则返回 0。

示例 1:

输入: [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。

示例 2:

输入: [10]
输出: 0
解释: 数组元素个数小于 2，因此返回 0。

说明:

• 你可以假设数组中所有元素都是非负整数，且数值在 32 位有符号整数范围内。
• 请尝试在线性时间复杂度和空间复杂度的条件下解决此问题。

解题思路

没想到用sort在时间上还要更快一些，看来还是数据量少了啊

方法一：

直接使用Arrays.sort排序
然后再遍历一边寻找最大间隔

方法二：

使用桶排序
桶排序最适合整数的排序了
在这个题目中只用考虑桶间的排序，不用考虑桶内的排序,因为桶内最小距离绝对不会超过桶间距离
用后一个桶的最小值减前一个桶的最大值，可以得到最大间距

代码

1. 直接用sort

class Solution {
    public int maximumGap(int[] nums) {
        if(nums.length<2) return 0;
        //直接sort
        Arrays.sort(nums);

        int k=0;
        int max=-1;
        
        for(int i = 0; i < nums.length - 1; i++){
            k=nums[i+1]-nums[i];
            max=Math.max(max,k);
        }
        return max;
    }
}

sort成果

2. O(n)桶排序

class Solution {
    public int maximumGap(int[] nums) {
        if (nums.length < 2)   return 0;

        int len = nums.length;

        //寻找数组最大值与最小值
        int maxnum = nums[0];
        int minnum = nums[0];
        for (int num : nums) {
            maxnum = Math.max(num, maxnum);
            minnum = Math.min(num, minnum);
        }
        if(maxnum ==minnum) return 0;

        // 桶的尺寸
        int bucketInterval = Math.max(1, (maxnum - minnum) / (len - 1));
        // 桶的数量
        int bucketSize = (maxnum - minnum) / bucketInterval + 1;

        // 用于存放每个桶的最大值
        int[] bucketMin = new int[bucketSize];
        // 用于存放每个桶的最小值
        // 每个桶的桶内最小距离绝对不会超过桶间距离，所以桶内只保留最大的元素与最小的元素
        int[] bucketMax = new int[bucketSize];
        Arrays.fill(bucketMax, -1);
        Arrays.fill(bucketMin, -1);

        for (int num : nums) {
            // 选择桶
            int index = (num - minnum) / bucketInterval;
            // 更新桶
            if (bucketMin[index] == -1) {
                bucketMin[index] = num;
                bucketMax[index] = num;
            } 
            else {
                bucketMin[index] = Math.min(bucketMin[index], num);
                bucketMax[index] = Math.max(bucketMax[index], num);
            }
        }        

        // max存放最大距离，pre存放上一次最大元素值
        int max = 0, pre = -1;
        for (int i = 0; i < bucketSize; i++) {
            // 空桶直接跳过
            if (bucketMin[i] == -1) continue;

            if (pre != -1) {
                max = Math.max(max, bucketMin[i] - pre);
            }
            pre =bucketMax[i];
        }

        return max;

    }
}

桶排序成果