C语言程序新手必看精选.docx
《C语言程序新手必看精选.docx》由会员分享，可在线阅读，更多相关《C语言程序新手必看精选.docx（42页珍藏版）》请在冰点文库上搜索。
C语言程序新手必看精选
C语言模板程序
1
求两个数最大公约数
方法一：
辗转相除法
思路：
两个数，用较大的数除以较小的数，所得余数与较小的数记为新的两个数，再重复之前的过程，直到余数为0，这时较大的数就是最大公约数。
完整程序
#include
intmain（）
{
intm,n,r;
scanf（"%d,%d",&m,&n）;
do
{
r=m%n;
m=n;
n=r;
}
while（n）;
printf（"greatestcommondivisoris%d\n",m）;
return0;
}
封装函数
intgcd（intm,intn）
{
do
{
r=m%n;
m=n;
n=r;
}
while（n）;
returnm;
}
调用函数
#include
intmain（）
{
intm,n,r;
intgcd（intm,intn）;
scanf（"%d,%d",&m,&n）;
gcd（intm,intn）;
printf（"greatestcommondivisoris%d\n",m）;
return0;
}
方法二：
更相减损法
思路：
两个数，用较大的数减去较小的数，所得差与较小的数记为新的两个数，再重复之前的过程，直到两个数相等，这时这两个数就是最大公约数。
完整程序
#include
intmain（）
{
intm,n;
scanf（"%d,%d",&m,&n）;
while（m!
=n）
{
if（m>n）m-=n;
elsen-=m;
}
printf（"greatestcommondivisoris%d\n",m）;
return0;
}
封装函数
intgcd（intm,intn）
{
while（m!
=n）
{
if（m>n）m-=n;
elsen-=m;
}
returnm;
}
调用函数
#include
intmain（）
{
intm,n,r;
intgcd（intm,intn）;
scanf（"%d,%d",&m,&n）;
printf（"greatestcommondivisoris%d\n",gcd（m,n））;
return0;
}
2
求两个数最小公倍数
思路：
两个数，从较大的数开始，依次找能同时整除这两个数的整数，这个整数就是这两个数的最小公倍数。
完整程序
#include
intmain（）
{
intm,n,i;
scanf（"%d,%d",&m,&n）;
for（i=（m>nm:
n）;;i++）
if（i%m==0&&i%n==0）
{
printf（"leasecommonmultipleis%d",i）;
break;
}
return0;
}
封装函数
intlcm（intm,intn）
{
inti;
for（i=（m>nm:
n）;;i++）
if（i%m==0&&i%n==0）
returni;
}
调用函数
#include
intmain（）
{
intm,n,i;
intlcm（intm,intn）;
scanf（"%d,%d",&m,&n）;
printf（"leasecommonmultipleis%d",lcm（m,n））;
return0;
}
3
判断素数
思路：
从2开始到所求整数的开方依次求余，如果有能整除所求整数的整数，则所求整数为合数，反之为素数。
完整程序
#include
#include
intmain（）
{
intnum;
inti,k,flag=1;
scanf（"%d",&num）;
k=sqrt（num）;
for（i=2;i<=k;i++）
{
if（num%i==0）printf（"%disn'taprimenumber!
",num）;
flag=0;
}
if（flag）printf（"%disaprimenumber!
",num）;
return0;
}
封装函数
intsushu（intnum）
{
inti,k;
k=sqrt（num）;
for（i=2;i<=k;i++）
{
if（num%i==0）return0;
}
return1;
}
调用函数
#include
#include
intmain（）
{
intnum;
intsushu（intnum）;
scanf（"%d",&num）;
if（sushu（num）==0）printf（"%disn'taprimenumber!
",num）;
elseprintf（"%disaprimenumber!
",num）;
return0;
}
4
冒泡排序（升序）
思路：
N个数，每次比较相邻的两个数，如果前面的数大就相互交换，这样小的数就会像气泡一样往前冒。
一趟排序完成后最后一个数最大。
共进行N-1趟排序。
完整程序
#include
#defineN10
intmain（）
{
intnum[N];
inti,j;
intt;
for（i=0;iscanf（"%d",&num[i]）;
for（i=0;ifor（j=0;jif（num[j]>num[j+1]）
{t=num[j];num[j]=num[j+1];num[j+1]=t;}
for（i=0;iprintf（"%d",num[i]）;
return0;
}
封装函数
voidmaopao（intnum[N]）
{
inti,j;
intt;
for（i=0;ifor（j=0;jif（num[j]>num[j+1]）
{t=num[j];num[j]=num[j+1];num[j+1]=t;}
}
调用函数
#include
#defineN10
intmain（）
{
intnum[N];
inti,j;
intt;
voidmaopao（intnum[N]）;
for（i=0;iscanf（"%d",&num[i]）;
maopao（num）;
for（i=0;iprintf（"%d",num[i]）;
return0;
}
5
选择排序（升序）
思路：
N个数，每次从剩下的数中选择最小的数（记住它的下标）与这组数中最前面的数交换，数的个数依次减少。
一趟排序完成后最前面的数最小。
共进行N-1趟排序。
完整程序
#include
#defineN10
intmain（）
{
intnum[N];
inti,j,k;
intt;
for（i=0;iscanf（"%d",&num[i]）;
for（i=0;i{
k=i;
for（j=i+1;jif（num[k]>num[j]）k=j;
if（k!
=i）{t=num[k];num[k]=num[i];num[i]=t;}
}
for（i=0;iprintf（"%d",num[i]）;
return0;
}
封装函数
voidxuanze（intnum[N]）
{
inti,j,k;
intt;
for（i=0;i{
k=i;
for（j=i+1;jif（num[k]>num[j]）k=j;
if（k!
=i）{t=num[k];num[k]=num[i];num[i]=t;}
}
}
调用函数
#include
#defineN10
intmain（）
{
intnum[N];
inti,j,k;
intt;
voidxuanze（intnum[N]）;
for（i=0;iscanf（"%d",&num[i]）;
xuanze（num）;
for（i=0;iprintf（"%d",num[i]）;
return0;
}
6
折半查找（升序）
思路：
N个按照从小到大排列好顺序的数，再从中寻找一个数，不是依次扫描每个数，而是先把这组数的中间元素拿出来与所找的数比较，如果中间数小于所找的数，则在这组数的后半段寻找；如果中间数大于所找的数，则在这组数的前半段寻找。
找到了，输出这个数的下标，如果找不到，输出Notfound！
。
完整程序
#include
#defineN10
intmain（）
{
inta[N],low=0,high=N-1,mid,i,key,flag=0;
for（i=0;iscanf（"%d",&a[i]）;
scanf（"%d",&key）;
while（low<=high）
{
mid=（low+high）/2;
if（a[mid]==key）
{
printf（"Found!
Theindexif%d",mid）;
flag=1;
break;
}
elseif（a[mid]>key）high=mid-1;
elselow=mid+1;
}
if（!
flag）printf（"Notfound!
"）;
return0;
}
封装函数
intzheban（inta[N],key）
{
intlow=0,high=N-1,mid;
while（low<=high）
{
mid=（low+high）/2;
if（a[mid]==key）
{
printf（"Found!
Theindexif%d",mid）;
returnmid;
}
elseif（a[mid]>key）high=mid-1;
elselow=mid+1;
}
printf（"Notfound!
"）;
return-1;
}
调用函数
#include
#defineN10
intmain（）
{
inta[N],low=0,high=N-1,mid,i,key,flag=0;
intzheban（inta[N],key）；
for（i=0;iscanf（"%d",&a[i]）;
scanf（"%d",&key）;
zheban（a,key）;
return0;
}
7
找最大数
（1）两个数找最大
思路：
比较两个数，输出较大者。
完整程序
#include
intmain（）
{
intx,y,z;
scanf（"%d,%d",&x,&y）;
z=x>yx:
y;
printf（"%d",z）;
return0;
}
封装函数
intmax（intx,inty）
{
intz;
z=x>yx:
y;
returnz;
}
调用函数
#include
intmain（）
{
intx,y,z;
intmax（intx,inty）;
scanf（"%d,%d",&x,&y）;
printf（"%d",max（x,y））;
return0;
}
（2）数组中找最大
①一维数组
思路：
让一个变量等于数组中第一个元素，从第二数开始依次进行比较，碰到更大的数则更改变量的值，直到全部比较完毕。
完整程序
#include
#defineN10
intmain（）
{
intnum[N];
inti,max;
for（i=0;iscanf（"%d",&num[i]）;
max=num[0];
for（i=1;iif（maxprintf（"%d",&max）;
return0;
}
封装函数
intmax（intnum[N]）
{
intmax=num[0];
inti;
for（i=1;iif（maxreturnmax;
}
调用函数
#include
#defineN10
intmain（）
{
intnum[N];
inti;
intmax（intnum[N]）;
for（i=0;iscanf（"%d",&num[i]）;
printf（"%d",max（num））;
return0;
}
②二维数组
思路：
让一个变量等于数组中第一个元素，从第一个数开始依次进行比较，碰到更大的数则更改变量的值，直到全部比较完毕。
完整程序
#include
#defineN10
#defineM5
intmain（）
{
intnum[N][M];
inti,j;
intmax;
for（i=0;ifor（j=0;jscanf（"%d",&num[i][j]）;
max=num[0][0];
for（i=0;ifor（j=0;jif（maxprintf（"%d",max）;
return0;
}
封装函数
intmax（intnum[N][M]）
{
intmax=num[0][0];
inti,j;
for（i=0;ifor（j=0;jif（maxreturnmax;
}
调用函数
#include
#defineN10
#defineM5
intmain（）
{
intnum[N][M];
inti,j;
intmax（intnum[N][M]）;
for（i=0;ifor（j=0;jscanf（"%d",&num[i][j]）;
printf（"%d",max（num））;
return0;
}
8
数组的行列转置
思路：
交换对应行列和列行的元素，注意只交换一半即可，否则相当于没有交换。
完整程序
#include
#defineN5
intmain（）
{
inta[N][N];
inti,j,t;
for（i=0;ifor（j=0;jscanf（"%d",&a[i][j]）;
for（i=0;ifor（j=i+1;j{
t=a[i][j];
a[i][j]=a[j][i];
a[j][i]=t;
}
for（i=0;i{
for（j=0;jprintf（"%d",a[i][j]）;
printf（"\n"）;
}
return0;
}
封装函数
voidzhuanzhi（inta[][N]）
{
inti,j,t;
for（i=0;ifor（j=i+1;j{
t=a[i][j];
a[i][j]=a[j][i];
a[j][i]=t;
}
}
调用函数
#include
#defineN5
intmain（）
{
inta[N][N];
inti,j;
voidzhuanzhi（inta[][N]）;
for（i=0;ifor（j=0;jscanf（"%d",&a[i][j]）;
zhuanzhi（a）;
for（i=0;i{
for（j=0;jprintf（"%d",a[i][j]）;
printf（"\n"）;
}
return0;
}
9
大整数
（1）大整数的输入
思路：
用字符类型输入。
完整程序
#include
#include
intmain（）
{
charch[101];
scanf（"%s",ch）;//或gets（ch）;
return0;
}
封装函数
voidInput_Big_Num（charch[101]）
{
scanf（"%s",ch）;//或gets（ch）;
}
调用函数
#include
#include
intmain（）
{
charch[101];
voidInput_Big_Num（charch[101]）;
Input_Big_Num（ch）;
return0;
}
（2）大整数的处理
①将大整数个位到最高位放在下标从0开始的整形数
完整程序
#include
#include
intmain（）
{
charch[101];
intdata[100];
intlen,i;
scanf（"%s",ch）;//或gets（ch）;
len=strlen（ch）;
for（i=0;idata[i]=ch[len-i-1]-'0';
return0;
}
封装函数
intChuli_Big_Num（charch[101],intdata[100]）
{
intlen,i;
len=strlen（ch）;
for（i=0;idata[i]=ch1[len-i-1]-'0';
returnlen-1;
}
调用函数
#include
#include
intmain（）
{
charch[101]={'\0'};
intdata[100]={0};
voidInput_Big_Num（charch[101]）;
intChuli_Big_Num（charch[101],intdata[100]）;
Input_Big_Num（ch）;
Chuli_Big_Num（ch,data）;
return0;
}
②将大整数最高位到个位放在下标从0开始的整形数
完整程序
#include
#include
intmain（）
{
charch[101];
intdata[100];
intlen,i;
scanf（"%s",ch）;//或gets（ch）;
len=strlen（ch）;
for（i=0;idata[i]=ch[i]-'0';
return0;
}
封装函数
intChuli2_Big_Num（charch[101],intdata[100]）
{
intlen,i;
len=strlen（ch）;
for（i=0;idata[i]=ch1[i]-'0';
returnlen-1;
}
调用函数
#include
#include
intmain（）
{
charch[101]={'\0'};
intdata[100]={0};
voidInput_Big_Num（charch[101]）;
intChuli2_Big_Num（charch[101],intdata[100]）;
Input_Big_Num（ch）;
Chuli_Big_Num（ch,data）;
return0;
}
（3）大整数的输出
完整程序
#include
#include
intmain（）
{
charch[101];
intdata[100];
intlen,i;
scanf（"%s",ch）;//或gets（ch）;
len=strlen（ch）;
for（i=0;idata[i]=ch1[len-i-1]-'0';
for（i=len-1;i>=0;i--）
printf（"%d",data[i]）;
return0;
}
封装函数
voidOutput_Big_Num（intdata[100],intweishu）
{
inti;
for（i=weishu-1;i>=0;i--）
printf（"%d",data[i]）;
}
调用函数
#include
#include
intmain（）
{
charch[101]={'\0'};
intdata[100]={0};
intweishu;
voidInput_Big_Num（charch[101]）;
intChuli_Big_Num（charch[101],intdata[100]）;
voidOutput_Big_Num（intdata[100],intweishu）;
Input_Big_Num（ch）;
weishu=Chuli_Big_Num（ch,data）;
Output_Big_Num（data,weishu）;
return0;
}
（4）大整数的加法（两个大整数相加）
完整程序
#include
#include
intmain（）
{
charch1[101]={'\0'},ch2[101]={'\0'};
intdata1[100]={0},data2[100]={0},data3[101]={0};
intlen1,len2,len,i,jinwei=0;
scanf（"%s",ch1）;//或gets（ch1）;
scanf（"%s",ch2）;//或gets（ch2）;
len1=strlen（ch1）;
for（i=0;idata1[i]=ch1[len-i-1]-'0';
len2=strlen（ch2）;
for（i=0;idata2[i]=ch2[len-i-1]-'0';
for（i=0;i<100;i++）
{
data3[i]=data1[i]+data2[i]+jinwei;
jinwei=data3[i]/10;
data3[i]=data3[i]%10;
}
for（i=100;i>=0;i--）
if（data3[i]!
=0）
{
len=i;
break;
}
for（i=len;i>=0;i--）
printf（"%d",data3[i]）;
return0;
}
封装函数
intPlus_Big_Num（intdata1[100],intdata2[100],intdata3[101]）
{
inti,jinwei=0;
for（i=0;i<100;i++）
{
data3[i]=d
升级会员 