分治算法求最大值c语言

❶ c语言求最大值怎么写

temp=(((a[0]>a[1])?a[0]:a[1])>a[2]?:((a[0]>a[1])?a[0]:a[1]):a[2]);
temp就是最大值
不好意思，上面那个多谢了一个冒号，当时没有验证就直接写了，现在已经验证完毕：
具体代码：
#include

int
main()
{
int
a[3];
a[0]=1;
a[2]=3;
a[1]=2;
int
temp=(((a[0]>a[1])?a[0]:a[1])>a[2]?((a[0]>a[1])?a[0]:a[1]):a[2]);
printf("%d",temp);
return
0;
}

❷ c语言：采用分治法递归求含n个数的某个序列的最大元素和次大元素。

high -low 为奇数，这个mid是小数。

（1）数组个数为n，还用a[n]

（2）还不如直接用个for循环，将max=0

#include <stdio.h>

#define N 21

int max(int a,int b){

if(a>b)

return a;

return b;

}

int getM(int * a,int l,int u){

if(u==l)

return a[u];

else{

return max(getM(a,l,(u+l)/2),getM(a,(u+l)/2+1,u) );

}

}

int main()

{

int a[N]={1,2,3,4,5,6,7,8,9,21,11,12,13,14,15,16,17,18,19,20,17};

printf("max=%d",getM(a,0,N-1));

return 0;

}

(2)分治算法求最大值c语言扩展阅读：

任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。

n=2时，只要作一次比较即可排好序。n=3时只要作3次比较即可。

而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。

分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

❸ 我的分治法求最大值与最小值错在哪（C语言）

----------------------
好象你在找到最大和最小值后忘了退出了.
----------------------

#include <stdio.h>

int a[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
/*调试用的变量,防止进入死循环*/
static long int tmp=1;

void maxmin(int i,int j,int *fmax,int *fmin)
{
int mid,hmax,hmin,gmax,gmin;

/*输出调试信息*/
printf("enter the maxmin()! [%d]tmes!\n",tmp);
tmp++;
/*如果调用此函数超过1000次则退出程序*/
if(tmp>=1000){
printf("The program mabye dead!\n");
exit(0);
}

if(i==j){
printf("the i=j\n");
*fmax=a[i]; *fmin=a[i];
return;/*此语句可以在找到最大值和最小值时退出继续运行*/
}
if(i==j-1){
printf("the i=j-1\n");
if(a[i]>a[j]){
*fmax=a[i]; *fmin=a[j];
return;/*此语句可以在找到最大值和最小值时退出继续运行*/
}else{
*fmax=a[j]; *fmin=a[i];
return;/*此语句可以在找到最大值和最小值时退出继续运行*/
}
}else{
printf("the i!=j and i!=j-1\n");
mid=(i+j)/2;
maxmin(i,mid,&gmax,&gmin);
maxmin(mid+1,j,&hmax,&hmin);
*fmax=gmax>hmax? gmax:hmax;
*fmin=gmin<hmin? gmin:hmin;
}
}

void main()
{
int max,min;
maxmin(0,19,&max,&min);
printf("max=%d,min=%d",max,min);
}


❹ 算法导论，分治法求最大子数组，求一个c语言代码

这题的思想是书上的（《算法导论》），代码当然也是按照书上伪码写出的；
#include<stdio.h>

intFind_Max_Crossing_SubArray(intA[],intlow,intmid,inthigh)
{
intleft_sum=-0xff;
intsum=0;
for(inti=mid;i>=low;i--)
{
sum+=A[i];
if(sum>left_sum)
{
left_sum=sum;
}
}
intright_sum=-0xff;
sum=0;
for(intj=mid+1;j<=high;j++)
{
sum+=A[j];
if(sum>right_sum)
{
right_sum=sum;
}
}
returnleft_sum+right_sum;
}

intFind_Maximum_SubArray(intA[],intlow,inthigh)
{
intleft_sum,right_sum,cross_sum;
if(high==low)
{
returnA[low];
}
else
{
intmid=(low+high)/2;
left_sum=Find_Maximum_SubArray(A,low,mid);
right_sum=Find_Maximum_SubArray(A,mid+1,high);
cross_sum=Find_Max_Crossing_SubArray(A,low,mid,high);
if(left_sum>=right_sum&&left_sum>=cross_sum)
{
returnleft_sum;
}
elseif(right_sum>=left_sum&&right_sum>=cross_sum)
{
returnright_sum;
}
else
{
returncross_sum;
}
}
}
intmain()
{
intA[100];
intn;
printf("Pleaseinputthenumberofnumbers:");
scanf("%d",&n);
for(inti=0;i<n;i++)
{
scanf("%d",&A[i]);
}
printf("最大子序列的和为：%d",Find_Maximum_SubArray(A,0,n-1));
return0;
}

❺ 用C语言利用分治法求一组数据中最大的两个数和最小的两个数

#include <stdio.h>
main()
{
int a[10]={1,3,5,7,9,10,8,6,4,2};
int i,max1=0,max2=0,min1=0,min2=0;
for(i=0;i<10;i++)
{
if(a[max1]<a[i])
max1=i;
if(a[min1]>a[i])
min1=i;
}
if(max1==0)
max2=1;
if(min1==0)
min2=1;
for(i=0;i<10;i++)
{
if(i==max1||i==min1)
continue;
if(a[max2]<a[i])
max2=i;
if(a[min2]>a[i])
min2=i;
}
printf("max1=%d\nmax2=%d\nmin1=%d\nmin2=%d\n",a[max1],a[max2],a[min1],a[min2]);
}

❻ C++ 利用分治法求一组数据中最大的两个数和最小的两个数。

分治，顾名思义，分而治之;把一个父运算，分解成几个子运算，常见算法如归并排序。用函数T来表示运算的时间的话，父运算T(n)=T(n/k)+C。
具体的也记不太清楚了，如果是我做这题，我会用归并把数组排序，排完序，最大最小自然就出来了。
标准归并算法C++描述，具体思想网上有很多资料自己去看

/*归并算法*/
#include<iostream>
typedef int keytype;
void merge(keytype *,int,int,int);
void merge_sort(keytype *,int,int);
int main()
{
using namespace std;
keytype a[11]={1,5,8,4,6,3,8,1,3,8,2};
merge_sort(a,0,9);
for(int i=0;i<11;++i)
cout<<a[i]<<" ";
return 0;
}
void merge_sort(keytype *a,int low,int up)
{
int q=0;
if(low<up)
{
q=(low+up)/2;
merge_sort(a,low,q);
merge_sort(a,q+1,up);
merge(a,low,q,up);
}
}
void merge(keytype *a,int low,int mid,int up)
{
int len1=mid-low+1;
int len2=up-mid;
keytype *L=new keytype[len1+1];//栈内存效率更高
keytype *R=new keytype[len2+1];
for(int i=0;i<len1;++i)
L[i]=a[low+i];
for(int i=0;i<len2;++i)
R[i]=a[mid+i+1];
L[len1]=R[len2]=32767;

int i=0,j=0;
for(int k=low;k<=up;++k)
{
if(L[i]<=R[j])
{
a[k]=L[i];
++i;
}
else
{
a[k]=R[j];
++j;
}
}
delete[] L;
delete[] R;
}
递归的把任务分解成二个子任务，merge整合函数复杂度是O(n),每次分解成两部分分别排序之后调用整合函数，很容易知道复杂度是O(n),所以算法T(n)=T(n/2)+O(n),复杂度为O(nlogn)