最大间距(maxgap,leetcode,hard)

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

如果数组元素个数小于 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.csdn.net/caigen0001/article/details/88749156

https://blog.csdn.net/jiyanfeng1/article/details/39312011

http://blog.csdn.net/u012162613/article/details/41936569