无序数组排序后的最大相邻差
- 先排序，在一个一个求差，找出最大的差
- 解法2(计数排序变体)
- 第一步
- 第二步
- 第三步
- 第四步
- 例子
- JAVA实现
- 解法3(桶排序变体)
- 第一步
- 第二步
- 第三步
- 例子
- JAVA实现
有一个无序整型数组，如何求出该数组排序后的任意两个相邻元素的最大差值？要求时间和空间复杂度尽可能低。
先排序，在一个一个求差，找出最大的差
使用任意一种时间复杂度为O（nlogn）的排序算法（如快速排序）给原数组排序，然后遍历排好序的数组，并对每两个相邻元素求差，最终得到最大差值。
该解法的时间复杂度是O（nlogn），在不改变原数组的情况下，空间复杂度是O(n)。
解法2(计数排序变体)
借用计数排序思想。
适用范围：数组元素差值不很悬殊的时候，确实效率很高。
第一步
利用计数排序的思想，先求出原数组的最大值max与最小值min的区间长度k（k=max-min+1），以及偏移量d=min。
第二步
创建一个长度为k的新数组Array。
第三步
遍历原数组，每遍历一个元素，就把新数组Array对应下标的值+1。例如原数组元素的值为n，则将Array[n-min]的值加1。遍历结束后，Array的一部分元素值变成了1或更高的数值，一部分元素值仍然是0。
第四步
遍历新数组Array，统计出Array中最大连续出现0值的次数+1，即为相邻元素最大差值。
例子
{ 2, 6, 3, 4, 5, 10, 9 }
判断0值最多连续出现的次数，计算出最大相邻差
JAVA实现
public static int countSortransformer(int[] array){
//取数列的最大值
int max = array[0];
for (int i = 1;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
}
//取数列的最小值
int min = array[0];
for (int i = 1;i<array.length;i++){
if(array[i]<min){
min = array[i];
}
}
//求区间长度
int k = max-min+1;
//偏移量
int d = min;
//用于统计统计数组中重复0的个数
int count = 0;
//创建一个长度为k的新数组countArray,用于计数。
int[] countArray = new int[k];
/**
* 遍历原数组，每遍历一个元素，就把新数组Array对应下标的值+1。例如原
* 数组元素的值为n，则将Array[n-min]的值加1。遍历结束后，Array的一部分元素
* 值变成了1或更高的数值，一部分元素值仍然是0。
*/
//遍历数组，统计个数，并填充统计数组countArray
for (int i=0;i<array.length;i++){
countArray[array[i]-d]++;
}
System.out.println("计数数组为： "+Arrays.toString(countArray));
for (int e:countArray){
if(e==0){
count++;
}
}
if(count!=0){
count++;
System.out.println("相邻元素最大差值为"+count);
}else {
System.out.println("相邻元素最大差值为1");
}
return count;
}
测试方法
public static void main(String[] args) {
int[] aray = new int[]{2,6,3,4,5,10,9};
countSortransformer(aray);
}
解法3(桶排序变体)
第一步
利用桶排序的思想，根据原数组的长度n，创建出n个桶，每一个桶代表一个区间范围。
其中第1个桶从原数组的最小值min开始，
第二步
遍历原数组，把原数组每一个元素插入到对应的桶中，记录每一个桶的最大和最小值。
第三步
遍历所有的桶，统计出每一个桶的最大值，和这个桶右侧非空桶的最小值的差，数值最大的差即为原数组排序后的相邻最大差值
例子
{ 2, 6, 3, 4, 5, 10, 9 }
遍历所有的桶，找出最大相邻差。
每一个桶的最大值和这个桶右侧非空桶的最小值的差
不需要像标准桶排序那样给每一个桶内部进行排序，只需要记录桶内的最大和最小值即可，所以时间复杂度稳定在O(n)。
JAVA实现
我自己构建了一组计数桶bucketList2
/**
* 桶排序变体
* @param array
* @return
*/
public static int getMaxSortedDistance(int[]array){
//1.得到数列的最大值和最小值
int max = array[0];
int min = array[0];
for (int i =1;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
if(array[i]<min){
min = array[i];
}
}
int d = max - min;
if(d==0){
//如果max 和min 相等，说明数组所有元素都相等，返回0
return 0;
}
//2.初始化桶
//桶的数量等于数组长度
int bucketNum = array.length;
//所有的桶都保存在ArrayList集合中，每一个桶都被定义成一个链表（LinkedList<Double>），这样便于在尾部插入元素
ArrayList<LinkedList<Integer>> bucketList = new ArrayList<LinkedList<Integer>>(bucketNum);
for (int i = 0;i<bucketNum;i++){
bucketList.add(new LinkedList<Integer>());
}
//在创建一组桶，用于保存每个桶的最大和最小元素。。。
ArrayList<LinkedList<Integer>> bucketList2 = new ArrayList<LinkedList<Integer>>(bucketNum);
for (int i = 0;i<bucketNum;i++){
bucketList2.add(new LinkedList<Integer>());
bucketList2.get(i).add(0,null);
bucketList2.get(i).add(1,null);
}
//3.遍历原始数组，将每个元素放入桶中,并确定最大值和最小值
for (int i=0;i<array.length;i++){
//(array[i]-min)*(bucketNum-1)/d这个公式可以将当前元素找到对应的桶下标num
int num = (int)((array[i]-min)*(bucketNum-1)/d);
bucketList.get(num).add(array[i]);
if(bucketList2.get(num).get(0)==null||bucketList2.get(num).get(0)>array[i]){
//空的计数桶,或者有更小的值
//链表第0位存最小值
bucketList2.get(num).add(0,array[i]);
}
if(bucketList2.get(num).get(1)==null||bucketList2.get(num).get(1)<array[i]){
//空的计数桶,或者有更大的值
//链表第1位存最大值
bucketList2.get(num).add(1,array[i]);
}
}
//有个小BUG,就是我一开始写代码，leftMax没有更新。。。。。
//4.遍历桶，找到最大差值
//第一个桶的最小值
int leftMax = bucketList2.get(0).get(1);
int maxDistance = 0;
for (int i=1;i<bucketNum;i++){
//在去找右边的最小值
if(bucketList2.get(i).get(0)==null){
//直到找到，才跳出循环
continue;
}
if(bucketList2.get(i).get(0)-leftMax>maxDistance){
maxDistance = bucketList2.get(i).get(0)-leftMax;
}
//这个更新leftMax很重要
leftMax = bucketList2.get(i).get(1);
}
//查看桶中最大和最小元素
for (int j = 0;j<bucketNum;j++){
System.out.println("第"+(j+1)+"个桶最小值和最大值");
System.out.println(bucketList2.get(j).get(0));
System.out.println(bucketList2.get(j).get(1));
}
return maxDistance;
}
测试类：
public static void main(String[] args) {
int[] aray = new int[]{2,6,3,4,5,10,9};
System.out.println("最大元素间隔为： "+getMaxSortedDistance(aray));
}
还可以简化桶的构建和存储结构，用类定义桶。
/**
* 桶类
*/
private static class MyBucket{
Integer min;
Integer max;
}
/**
* 优化桶结构的构建了。。 MyBucket类定义桶
* @param array
* @return
*/
public static int getMaxSortedDistance2(int[]array){
//1.得到数列的最大值和最小值
int max = array[0];
int min = array[0];
for (int i =1;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
if(array[i]<min){
min = array[i];
}
}
int d = max - min;
if(d==0){
//如果max 和min 相等，说明数组所有元素都相等，返回0
return 0;
}
//2.初始化桶
//桶的数量等于数组长度
int bucketNum = array.length;
//定义一个MyBucket类别的数组。。。。。。。
MyBucket[] buckets = new MyBucket[bucketNum];
for (int i =0;i<bucketNum;i++){
//在数组中赋值
buckets[i] = new MyBucket();
}
//3.遍历原始数组，确定每个桶的最大最小值
for (int i = 0;i<array.length;i++){
//确定数组元素所归属的桶下标
int index = ((array[i]-min)*(bucketNum-1)/d);
//最小值
if(buckets[index].min==null||buckets[index].min>array[i]){
buckets[index].min=array[i];
}
//最大值
if(buckets[index].max==null||buckets[index].max>array[i]){
buckets[index].max=array[i];
}
}
//4.遍历桶，找到最大差值
int leftMax= buckets[0].max;
int Distance = 0;
for (int i =1;i<buckets.length;i++){
if(buckets[i].min==null){
continue;
}
if(buckets[i].min-leftMax>Distance){
Distance = buckets[i].min-leftMax;
}
leftMax = buckets[i].max;//更新很关键
}
//查看桶中最大和最小元素
for (int j = 0;j<bucketNum;j++){
System.out.println("第"+(j+1)+"个桶最小值和最大值");
System.out.println(buckets[j].max);
System.out.println(buckets[j].min);
}
return Distance;
}
测试方法：
public static void main(String[] args) {
int[] aray = new int[]{2,6,3,4,5,10,9};
System.out.println("最大元素间隔为： "+getMaxSortedDistance2(aray));
}
![洛谷千题详解 | P1022 [NOIP2000 普及组] 计算器的改良【C++、Python、Java语言】](https://img-blog.csdnimg.cn/96a9ce7c1ec8452c9b9777fffad9743b.png)
