1、有一个整数数组，求出两两只差绝对值最小

/************************************************************************/
/* 1、有一个整数数组，求出两两只差绝对值最小                        */
/************************************************************************/
int iCompare(const void* lhs, const void* rhs)
{
	return *(const int *)lhs - *(const int *)rhs;
}

//使用快速排序的方法，时间复杂度O(nlogn)， 空间O(1)
int minSubBySort(int *iArr, int length)
{
	if(!iArr || length < 2)
		throw new exception("error");
	
	//从小到大排序
	qsort(iArr, length, sizeof(int), iCompare);
	
	//遍历求解最小差值
	int minSub = numeric_limits<int>::max();
	for(int i = 0; i < length - 1; ++i)
	{
		int curSub = iArr[i + 1] - iArr[i];
		if(minSub > curSub)
			minSub = curSub;
	}
	return minSub;
}


void insertSort(vector<int>& ivect)
{
	for(unsigned i = 1; i < ivect.size() ; ++i)
	{
		for(int j = i - 1; j >= 0; --j)
		{
			if(ivect[j + 1] < ivect[j])
			{
				int temp = ivect[j + 1];
				ivect[j + 1] = ivect[j];
				ivect[j] = ivect[j + 1];
			}
			else
				break;
		}
	}
}
//快速排序换成桶排序时间O(n), 空间O(n)
int minSubByBucketSort1(int * arr, int length)
{
	//一共length个桶, 每个桶步长为h = maxSub / (length - 1)， [min, min + h), [min + h, m + 2h)...
	// 找打最大最小元素
	int minVal = arr[0];
	int maxVal = arr[0];
	for(int i = 1; i < length; ++i)
	{
		if(arr[i] > maxVal)
			maxVal = arr[i];
		if(arr[i] < minVal)
			minVal = arr[i];
	}
	
	//计算h
	int h = (int)ceil((maxVal - minVal)/double(length -1));
	//length个桶，数组中元素放入桶中
	vector<int>* vectArr = new vector<int>[length];
	for(int j = 0; j < length; ++j)
	{
		int pos = (arr[j] - minVal) / h;
		vectArr[pos].push_back(arr[j]);
	}
	//对桶中元素排序
	for(int k = 0; k < length; ++k)
	{
		insertSort(vectArr[k]);
	}
	int curMin = numeric_limits<int>::max();
	int preMax = numeric_limits<int>::min();
	int curMax = numeric_limits<int>::min();
	int minSub = numeric_limits<int>::max();
	for(int l = 0; l < length; ++l)
	{
		//桶间比较
		if(vectArr[l].size() == 0)
			break;
		else
		{
			curMin = vectArr[l][0];
			curMax = vectArr[l][vectArr[l].size() - 1];
			if(preMax != numeric_limits<int>::min())
				minSub = minSub < abs(curMin - preMax) ? minSub : abs(curMin - preMax);

		}
		//桶内比较
		for(unsigned m = 0; m < vectArr[l].size() - 1; ++m)
		{
			int absSub = vectArr[l][m+1]- vectArr[l][m];
			if( absSub < minSub)
				minSub = absSub;
		}
		preMax = curMax;

	}
	//
	return minSub;
}

//桶排序方法时间O(n)， 空间O（2n），桶内元素不排序
//桶范围h：maxSub = max - min, h = maxSub / (n - 1)， [min, min + h), [min + h, m + 2h)...
//至少有一个桶中元素数量大于2，计算每个桶中的最小差值，与相邻桶最小差值（此桶最小值 - 上桶最大值）
//比较求得minSub
bool findMinSubOfVector(const vector<int>& iVect, int& result)
{
	vector<int>::const_iterator beg = iVect.begin();
	if(iVect.size() < 2)
		return false;
	result = numeric_limits<int>::max();
	while(beg != iVect.end())
	{
		vector<int>::const_iterator pIter = beg + 1;
		while(pIter != iVect.end())
		{
			if(abs(*beg - * pIter) < result)
				result = abs(*beg - *pIter);
			++pIter;
		}
		++beg;
	}
	return true;
}
int minSubByBucketSort(int * arr, int length)
{
	if(!arr || length < 2)
		throw new exception("error!");

	// 找打最大最小元素
	int minVal = arr[0];
	int maxVal = arr[0];
	for(int i = 1; i < length; ++i)
	{
		if(arr[i] > maxVal)
			maxVal = arr[i];
		if(arr[i] < minVal)
			minVal = arr[i];
	}

	//计算h
	int h = (int)ceil((maxVal - minVal)/double(length -1));
	//length个桶，数组中元素放入桶中
	vector<int>* vectArr = new vector<int>[length];
	for(int j = 0; j < length; ++j)
	{
		int pos = (arr[j] - minVal) / h;
		vectArr[pos].push_back(arr[j]);
	}
	//计算每个桶的minSub，并找到最大最小值 
	int preMax = numeric_limits<int>::min(), curMin = numeric_limits<int>::max();
	int curMax = preMax;
	int minSub = numeric_limits<int>::max();
	for(int k = 0; k < length; ++k)
	{
		if(vectArr[k].size() == 0)
			continue;
		//计算桶内的minSub
		int tempMinSub = numeric_limits<int>::max();
		if(findMinSubOfVector(vectArr[k], tempMinSub) && minSub > tempMinSub)
			minSub = tempMinSub;

		//当前桶最小值和最大值
		vector<int>::iterator beg = vectArr[k].begin();
		curMax = *beg;
		curMin =  *beg;
		while(beg != vectArr[k].end())
		{
			if(curMax < *beg)
				curMax = *beg;
			if(curMin > *beg)
				curMin = *beg;
			++beg;
		}
		
		//桶间最大最小值
		if(k > 0)
		{
			tempMinSub = curMin - preMax;
			if(minSub > tempMinSub)
			minSub = tempMinSub;
		}
		preMax = curMax;

	}

	delete[] vectArr;
	return minSub;
	
}


void testofGetMinSub()
{
	const int size = 100000;
	int arr[size];
	//随机生成size不同的数
	int rangle = size * 10;
	int selected = 0;
	for(int i = 0; i < rangle && selected < size; ++i)
	{
		if(rand() % (rangle - i) < size - selected)
			arr[selected++] = i; 
	}
	
	//showArr(arr, size);

	DWORD start = GetTickCount();

		cout << "minsub = " << minSubBySort(arr, size) << endl;

	DWORD end = GetTickCount();
	cout << end - start << endl;

	start = GetTickCount();
	cout << "minsub = " << minSubByBucketSort(arr, size) << endl;
	end = GetTickCount();
	cout << end - start << endl;

	start = GetTickCount();
	cout << "minsub = " << minSubByBucketSort1(arr, size) << endl;
	end = GetTickCount();
	cout << end - start << endl;
	
}