分治演算法求最大值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)