最大间距(maxgap,leetcode,hard)

最新推荐文章于 2024-03-16 21:21:08 发布

caigen001

最新推荐文章于 2024-03-16 21:21:08 发布

阅读量504

点赞数 1

CC 4.0 BY-SA版权

分类专栏： 4.算法设计与分析文章标签： leetcode hard maxgap 最大间距算法分析

本文链接：https://blog.youkuaiyun.com/caigen0001/article/details/88753135

4.算法设计与分析专栏收录该内容

5 篇文章

订阅专栏

博客围绕找出无序数组排序后相邻元素最大间距的问题展开。直接排序复杂度不满足要求，故采用桶排序方法，包括找最大最小数据、等分区间成桶、将数放入桶并调整数据、求最大间隙等步骤，运行平台为Eclipse Java语言。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

示例 1:

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

示例 2:

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

说明:

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

算法思想：

这道题最直接的解法是，先排序，得到有序数组，然后再对相邻元素作差，找出差最大的。一般排序算法的最有复杂度为O(nlogn)，不满足题意。

故采取桶排序的方法：

1. 找到n个数据中最大和最小数据maxx和minx；

2. 用n-2个点等分区间[minx,maxx]，即将[minx,maxx]等分为n-1个区间（前闭后开区间），将这些区间看做桶，编号为1,2,...,n-2,n-1，且桶i的上界和桶i+1的下届相同，即每个桶的大小相同；

每个桶的大小为：avergap=(maxx-minx)/(n-1)

编程实现中，用以下数据结果存放有关桶的数据：

int *count=new int[n]; //实际分到每个桶的数据个数

double *low=new double[n]; //实际分到每个桶的最小数据

double *high=new double[n]; //实际分到每个桶的最大数据

3. 将n个数放入n-1个桶中：

3.1 按如下规则将x[i]分配到某个桶(编号index)中： index=int((x[i]-minx)/avergap)+1；

若x[i]=minx，则被分到第1个桶中(minx即为桶1的下界)；

若x[i]=桶j的下界(也是桶j-1的上界)，则被分到桶j中(j>=1)；

若x[i]=maxx，则被分到桶n中(max为桶n的下界桶n-1的上界)，但没有桶n，解决办法：

可人为将其移入桶n-1中或者再加一个桶，这并不影响求其最大间隙；

3.2 调整分到该桶的最大最小数据；

4. 求最大间隙：

除最大最小数据maxx和minx以外的n-2个数据被放入n-1个桶中，由鸽巢原理可知至少有一个桶是空的；

又因每个桶的大小相同，所以最大间隙不会在同一桶中出现；

一定是某个桶的上界(High)和其后某个桶的下界(Low)之间隙，且该两桶之间的桶(即编号在该两桶编号之间的桶)一定是空桶；

即最大间隙在桶i的上界和桶j的下界之间产生(j>=i+1)；

###################################################################################

运行平台：Eclipse Java语言

public class MaxGap
{

	public static void main(String[] args)
	{
		int[] num = {3,6,9,1};
//int[] num = {10};//测试
//int[] num = {1, 1, 1, 1, 1, 5, 5, 5, 5, 5};//测试
    	System.out.println(getMaxGap(num));
	}
	
	public static int getMaxGap(int[] num) 
	{
		int len = num.length;
		if(num == null || len < 2) 
			return 0;
		int maxx = num[0];
		int minx = num[0];
		
		for(int i : num)
		{
			maxx = Math.max(maxx, i);
			minx = Math.min(minx, i);
		}
		
		if(maxx == minx)
			return 0;
		
		boolean[] hasNum = new boolean[len+1];
		int[] maxB = new int[len+1];
		int[] minB = new int[len+1];
		
		for(int i = 0; i < len+1; i++)
		{
			hasNum[i] = false;
			maxB[i] = minx;
			minB[i] = maxx;
			
		}
		
		for(int i = 0; i < len; i++)
		{
//double lenB = (maxx - minx)/(len - 1); //这里double没有任何效果，两个整数（5，1）相除为0
//int index = (int)((num[i] - minx)/lenB); //这里不应该将lenB分开，虽然易读，但是结果精度丢失
			//特别注意浮点运算，容易发生精度丢失			
			int index = (int)((num[i] - minx)*1.0/(maxx - minx)*(len-1));	
			maxB[index] = hasNum[index] ? Math.max(maxB[index], num[i]) : num[i];
			minB[index] = hasNum[index] ? Math.min(minB[index], num[i]) : num[i];
			hasNum[index] = true;
		}
		
		int tmp = 0, lastMax = maxB[0];
		for(int i = 1; i < len; i++)
		{
			if(hasNum[i])
			{
				tmp = Math.max(tmp, minB[i] - lastMax);
				lastMax = maxB[i];		
			}
		}
		return tmp;
	}
}

参考资料：

https://blog.youkuaiyun.com/caigen0001/article/details/88749156

https://blog.youkuaiyun.com/jiyanfeng1/article/details/39312011

http://blog.youkuaiyun.com/u012162613/article/details/41936569