java用桶思想比较相邻元素最大差值【高频考点】

题目：

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

 

什么是非基于比较的排序？

如桶排序、计数排序、基数排序等

1、非基于比较的排序，与被排序的样本的实际数据状况很有关系，实际中并不经常使用
2、时间复杂度O(N)，额外空间复杂度O(N)
3、稳定的排序

 

核心思想：

上一个(含值)桶的最大值和下一个(含值)桶的最小值即为相邻元素，这要得到的最大差值比相同桶内相邻元素的差值更大。当对n个数字进行排序计算相邻两数的最大差值时，创建n+1个桶，至少含有一个空桶的目的是为了证明：最大差值一定不来自于相同桶内的数。注意：但无法确定空桶两侧非空桶的数一定是最大值。

桶内需要记录的数据：每个桶中最大值、最小值、boolean的桶中是否存在数[考虑使用三个数组实现]

先遍历数组，得到数组中的最大值和最小值【为了分割桶内的范围】，如果最小值==最大值，返回0。

当某数x进桶【如3号桶】后，桶内boolean应该改为true，如果x是第一个进桶的元素，则该桶的最大值和最小值都为x，其他数进桶也如此。

当遇到数y同样进【3号】桶， 比较当前的最小值或最大值并更新即可。

当数组遍历完后，从1号桶开始遍历，找前一个非空桶(boolean变量为true)的最大值和当前遍历到桶的最小值的差值用全局变量max记录，以此循环，直到遍历到末尾。

 

代码：

import java.util.Arrays;
/*给定一个数组，求如果排序之后，相邻两数的最大差值，要求： 时间复杂度O(N)，且要求不能用非基于比较的排序。*/
public class MaxGap {

	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;
		}

                //len个数字,创建len+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++) {
                        //得到arr[i]对应放入桶的位置bid
			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) {
		return (int) ((num - min) * len / (max - min));
	}

	// for test
	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;
	}

	// for test
	public static int[] generateRandomArray(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;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		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;
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			if (maxGap(arr1) != comparator(arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
	}

}

 

总共使用了三次循环，

第一次循环：得出提供数组中元素的最大值和最小值

第二次循环：把数组元素中的值放入桶的对应位置内并得到 含值桶中元素的最大值和最小值

第三次循环：将本次遍历到含值桶的值与上一个含值桶的最大值作差(实际上，上一个桶的最大值和下一个桶的最小值即为相邻元素)，若大于上一次记录的差值，则刷新相邻元素的最大差值。