数组中最大值和最小值(《编程珠玑(续)》第15章)

找出给定数组中的最大值和最小值，一般有三种方法，一下程序的1,2,3分别对应三种方法。

第一种是递归分治，不断把数组分成两部分，然后分别找出两部分中的最大值和最小值，然后显然最终的最大值就是两个最大值中较大的，最小值就是两个较小的值中最大的最好情况下的比较次数是1.5N次，这个在下面会详细讨论。

第二种是顺序搜索，用两个值来保存当前的最大值和最小值，对每个元素比较两次，先和当前最大值进行比较，如果大于最大值就更新最大值，然后和当前最小值进行比较，如果小于当前的最小值就把当前最小值进行跟新，比较次数为2N次。

第三种搜索也是顺序搜索，不同的是这个算法每次扫描两个相邻元素，先比较大小，然后用大值和当前的最大值进行比较，如果大于当前最大值就更新最大值，用小值和当前的最小值进行比较，如果小于当前最小值就更新最小值。这样相当于每两个元素比较了3次，因此是严格的1.5N次比较。

#include<iostream>
#include<algorithm>
#include<ctime>
using namespace std;

void maxAndMin1(int A[],int &maxValue,int &minValue,int first,int last,int &count)
{
//	++count;
	if(first+1>=last)
	{
		++count;
		if(A[first]>A[last])
		{
			maxValue=A[first];
			minValue=A[last];
		}
		else
		{
			maxValue=A[last];
			minValue=A[first];
		}
		return ;
	}
	int N=last-first;
	int maxL,minL,maxR,minR;
	maxAndMin1(A,maxL,minL,first,first+(N>>1),count);
	maxAndMin1(A,maxR,minR,first+(N>>1)+1,last,count);
	++count;
	maxValue=max(maxL,maxR);
	++count;
	minValue=min(minL,minR);
}

pair<int,int> maxAndMin2(int A[],int N,int &count)
{
	int maxValue=INT_MIN,minValue=INT_MAX;
	for(int i=0;i<N;i++)
	{
		++count;
		if(A[i]<minValue)
		{
			minValue=A[i];
		}
		else
		{
			++count;
			if(A[i]>maxValue)
			{
				++count;
				maxValue=A[i];
			}
		}
	}
	return pair<int,int>(maxValue,minValue);
}

pair<int,int> maxAndMin3(int A[],int N,int &count)
{
	if(N==0)
		return pair<int,int>(0,0);
	if(N==1)
		return pair<int,int>(A[0],A[0]);
	int maxValue=INT_MIN,minValue=INT_MAX;
	int tempMax,tempMin;
	for(int i=1;i<N;i++,i++)
	{
		++count;
		if(A[i]<A[i-1])
		{
			tempMax=A[i-1];
			tempMin=A[i];
		}
		else
		{
			tempMax=A[i];
			tempMin=A[i-1];
		}
		++count;
//		maxValue=max(maxValue,tempMax);如果用这个函数代替，N=10000000则会多500ms
		if(maxValue<tempMax)
		{
			maxValue=tempMax;
		}
		++count;
//		minValue=min(minValue,tempMin);
		if(minValue>tempMin)
		{
			minValue=tempMin;
		}
	}
	++count;
	if(N&1==1)//N是奇数，最后一个数单独考虑
	{
		if(maxValue<A[N-1])
			maxValue=A[N-1];
		else if(minValue>A[N-1])
			minValue=A[N-1];
	}
	return pair<int,int>(maxValue,minValue);
}

int retRand()
{
	return (rand()<<15)|rand();
}

int main()
{
	const int N=1048576;//当N是2的x次方时，递归比较算法几乎能够达到1.5N次比较，当然这是在不计算屏蔽掉的那次比较
	int maxValue=INT_MIN,minValue=INT_MAX,count=0;
	int *A=new int[N];
	srand(time(NULL));
	generate(A,A+N,retRand);
	clock_t start,end;
	start=clock();
	maxAndMin1(A,maxValue,minValue,0,N-1,count);
	end=clock();
	cout<<"********递归比较*******"<<endl;
	cout<<"最大值："<<maxValue<<"	"<<"最小值："<<minValue<<endl;
	cout<<"运行时间："<<end-start<<"ms"<<"	比较次数："<<count<<endl;

	count=0;
	pair<int,int> p;
	start=clock();
	p=maxAndMin2(A,N,count);
	end=clock();
	cout<<"********常规比较*******"<<endl;
	cout<<"最大值："<<p.first<<"	"<<"最小值："<<p.second<<endl;
	cout<<"运行时间："<<end-start<<"ms"<<"	比较次数："<<count<<endl;

	count=0;
	start=clock();
	p=maxAndMin3(A,N,count);
	end=clock();
	cout<<"********两两比较*******"<<endl;
	cout<<"最大值："<<p.first<<"	"<<"最小值："<<p.second<<endl;
	cout<<"运行时间："<<end-start<<"ms"<<"	比较次数："<<count<<endl;

	system("pause");
	return 0;
}

运行结果如下：

对于递归比较的算法，运行时间很长，这个可以理解为递归调用的时间开销，此时 比较次数为1.5N，因为可以从程序中看到，刚进入函数的一次比较给屏蔽掉了，这样比较次数的地推关系就变成了F(1)=F(2)=0，F(n)=2F(n/2)+2，由此得到的FN)=1.5N。但是如果加上第一行的++count，则比较次数会增加很多，这里也耗费不少时间。此时由于去N=1048576=2^20，因此递归调用结束时，都是两两元素进行比较，即为偶数个，这样就能减少比较次数，而如果N不是2的整数次幂，则到递归结束时，有可能只有一个元素，此时比较次数就增加了，下面一个示例将会说明这个问题，当N=10^9时，比较次数已经接近于2N了。其实由于第一行的比较必须执行，因此这个递归的算法可以说是三种里面比较次数最多的，执行效率也是最慢的。

常规的比较算法比较简单，效率也较高，没有什么问题。

最后一种两两比较的算法，比较次数是1.5N，这是很严格的，但是效率却没有第二种方法高，这个我原来以为是赋值的语句太多了，但是即使把赋值语句都去掉，也没有第二个快，还是差20%左右。至今不得其解。

在最后一种算法的测试时，发现了一个比较奇葩的问题，就是可以看到屏蔽的部分原来我是用max和min函数来代替比较的，此时当N=10^7时，和if-else的时间相比，时间居然差了500ms。这个点，也没有想明白。。。

下面是当N=10^8时的运行结果，可以看出此时递归的比较次数和常规算法的比较次数几乎一样了，这是因为每次都对半分，导致到最后只剩下一个数的情况比较多导致的。