题目:
给定一个数组,求如果排序之后,相邻两数的最大差值,要求时间复杂度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!");
}
}
总共使用了三次循环,
第一次循环:得出提供数组中元素的最大值和最小值
第二次循环:把数组元素中的值放入桶的对应位置内并得到 含值桶中元素的最大值和最小值
第三次循环:将本次遍历到含值桶的值与上一个含值桶的最大值作差(实际上,上一个桶的最大值和下一个桶的最小值即为相邻元素),若大于上一次记录的差值,则刷新相邻元素的最大差值。