编程之美读书笔记2.10—寻找数组中的最大值和最小值

1.先扫描一遍数组找到最大值，然后再扫描一遍找到最小值，共2*N次

2.把数组分成两部分，然后从这两部分中分别找出最大值和最小值。

首先相邻的两个数分子啊同一组中，例如{5,6,8,3,7,9}，分为5 6， 8 3， 7,9

然后偶数位调换为较大的数，相应的奇数位为较小值     6 5， 8 3，  9,7     需0.5次

最后比较偶数位得到最大值9 ，比较奇数位得到最小值3，需要2*0.5N次

共1.5*N次

3.将数组中的元素分组，按顺序将数组中相邻的两个数分在同一组，用Max和Min来存储最大值和最小值，同一组比较完之后，较小的数与当前的最小值比较，如该数小于当前最小值，更新Min，较大的数与当前的最大值比较，若该数大于当前最大值，更新Max。Max初始化为数组前两个数中较大值，Min初始化为数组前两个组中较小值。不对数组进行调换，利用两个变量max,min,初始化为数组前两位，共1.5*N次

第二种和第三种方法.cpp

#include<iostream>
using namespace std;
void FindMaxMin1(int arr[],int len)
{
	for(int i=0;i<len;i=i+2)
	{
		if(arr[i]<arr[i+1])
			swap(arr[i],arr[i+1]);

	}

	for(int i=0;i<len;i=i+2)
	{
		if(arr[0]<arr[i+2])
			swap(arr[0],arr[i+2]);
		if(arr[1]>arr[i+1])
			swap(arr[1],arr[i+1]);
     }
	 cout<<"max= "<<arr[0]<<" , "<<"min= "<<arr[1]<<endl;;
}
void FindMaxMin2(int arr[],int len)
{
	int  max=arr[0],min=arr[1];
	
	for(int i=0;i<len;i=i+2)
	{
		if(arr[i]>arr[i+1])
		{
			if(arr[i]>max)
				max=arr[i];
			if(arr[i+1]<min)
				min=arr[i+1];
		}
		else
		{
			if(arr[i+1]>max)
				max=arr[i+1];
			if(arr[i]<min)
				min=arr[i];
		}
    }
    cout<<"max= "<<max<<" , "<<"min= "<<min<<endl;
}

int main()
{
	int a[]={5,6,8,3,7,9};
	int len=sizeof(a)/sizeof(int);
	FindMaxMin1(a,len);
	FindMaxMin2(a,len);
	return 0;
}

4.分治法，在N个数中求最小值Min和最大值Max，我们只需要求出前后N/2个数的Min和Max，然后取较小的Min和较大的Max即可。这种方法比较的次数是1.5N次

#include<iostream>
using namespace std;
void arrMaxMin(int a[], int begin, int end, int *max, int *min)  
{  
    if(end - begin <= 1) 
	{  
        if(a[end] > a[begin]) {  
            *max = a[end];  
            *min = a[begin];  
        }  
        else {  
            *max = a[begin];  
            *min = a[end];  
        }  
        return;  
    }  
    int maxL, maxR;  
    int minL, minR;  
    arrMaxMin(a, begin, begin + (end - begin)/2, &maxL, &minL);  
    arrMaxMin(a, begin + (end - begin)/2 + 1, end, &maxR, &minR);  
    *max = maxL > maxR ? maxL : maxR;  
    *min = minL > minR ? minR : minL; 
}  
int main()
{
	int a[]={5,6,8,3,7,9};
	int len=sizeof(a)/sizeof(int);
	int min, max;  
    arrMaxMin(a, 0, len - 1, &max, &min); 
	cout<<"max= "<<max<<" , "<<"min= "<<min<<endl;;
	return 0;
}

扩展问题：  如果需要找出N个数组中第二大数们需要比较多少次呢？是否可以使用类似的分治思想来降低比较次数呢？

1.先找到本数组中的最大数X，需要n-1次比较，再在剩下的数组中去找最大数X’,需要n-2次比较

则X’就是第二大的数，这需要(n-1) + (n-2)次比较

2.我们也可以在数组中，两数结合，分别求出最大值 和 次大值，之后每两个数结合求出的最值 在相互比较，得到最值得最大值 和 次大值

   比较次数：共有N/2组，每组需要比较倆次得出本组的最大数和第二大数；共需比较N/2 * 2次。

#include<iostream>
using namespace std;
void FindMaxMin(int arr[],int len)
{
	int  Max=arr[0],secMax=arr[1];
	for(int i=0;i<len;i=i+2)
	{
		if(arr[i]>arr[i+1])
		{
			if(arr[i]>Max)
			{
				secMax=Max;
				Max=arr[i];
                        }
			else if(arr[i]>secMax)
				secMax=arr[i];
		}
		else
		{
			if(arr[i+1]>Max)
			{
				secMax=Max;
				Max=arr[i+1];
                        }
			else if(arr[i+1]>secMax)
				secMax=arr[i+1];
		}
    }
	cout<<"max= "<<Max<<" , "<<"min= "<<secMax<<endl;
}

int main()
{
	int a[]={5,6,8,3,7,9};
	int len=sizeof(a)/sizeof(int);
	FindMaxMin(a,len);
	return 0;
}

3.初始化最大值为a[0]，次大值为a[1]，遍历一次，每次比较并更新最大值和次大值，最后就可以得到次大值。

#include<iostream>
using namespace std;
void FindMaxMin(int arr[],int len)
{
	int  Max=arr[0],secMax=arr[1];
	for(int i=0;i<len;i++)
	{
		if(arr[i]>Max)
	    {
			secMax=Max;
			Max=arr[i];
        }
		else if(arr[i]>secMax)
				secMax=arr[i];
		
	}
	cout<<"max= "<<Max<<" , "<<"min= "<<secMax<<endl;
}

int main()
{
	int a[]={5,6,8,3,7,9};
	int len=sizeof(a)/sizeof(int);
	FindMaxMin(a,len);
	return 0;
}

4.分治法

把数组分成两部分，其最大数和第二大数分别是:Fleft，Sleft，Fright，Sright。合并时的情况可能为：

1、Fleft > Fright，最大数是Fleft；若Sleft>Fright，则第二大数是Sleft，否则第二大数是Fright；

2、Fleft < Fright，最大数是Fright；若Fleft>Sright，则第二大数Fleft，否则第二大数是Sright。

#include<iostream>
using namespace std;
void arrMaxMin(int a[], int begin, int end, int *max, int *secmax)  
{  
    if(end - begin <= 1) 
	{  
        if(a[end] > a[begin]) {  
            *max = a[end];  
            *secmax = a[begin];  
        }  
        else {  
            *max = a[begin];  
            *secmax = a[end];  
        }  
        return;  
    }  
    int maxL, maxR;  
    int secmaxL, secmaxR;  
    arrMaxMin(a, begin, begin + (end - begin)/2, &maxL, &secmaxL);  
    arrMaxMin(a, begin + (end - begin)/2 + 1, end, &maxR, &secmaxR); 
	cout<<"maxL= "<<maxL<<" ,  secmaxL="<<secmaxL<<"  ,  maxR="<<maxR<<"  ,  secmaxR="<<secmaxR<<" ,"<<endl;
	if(maxL>maxR)
	{
		*max=maxL;
		if(secmaxL>maxR  && secmaxL!=maxL)
			*secmax=secmaxL;
		else
			*secmax=maxR;

	}
	else
	{   
		*max=maxR;
		if(secmaxR>=maxL && secmaxR!=maxR)
			*secmax=secmaxR;
		else
			*secmax=maxL;
	}
	
}
int main()
{
	int a[]={5,6,13,12,8,3,7,9,10,14,11};
	int len=sizeof(a)/sizeof(int);
	int min, max;  
    arrMaxMin(a, 0, len - 1, &max, &min); 
	cout<<"max= "<<max<<" , "<<"min= "<<min<<endl;;
	return 0;
}