C语言常用代码.docx
《C语言常用代码.docx》由会员分享，可在线阅读，更多相关《C语言常用代码.docx（69页珍藏版）》请在冰豆网上搜索。
C语言常用代码
#include
usingnamespacestd;
voidfullxunhuan（int**a,intn）
{
intt=0;
intm1,m2;
if（n%2!
=0）
{n++;}
for（inti=0;i{
for（m1=i,m2=n-i-1;m1<=n-i-1;m1++）
{
a[m1][m2]=t%n+1;
t++;
}
for（--m1,--m2;m2>i;m2--）
{
a[m1][m2]=t%n+1;
t++;
}
for（;m1>i;m1--）
{
a[m1][m2]=t%n+1;
t++;
}
for（;m2{
a[m1][m2]=t%n+1;
t++;
}
}
}
voidprint（int**a,intn）
{
for（inti=0;i{
for（intj=0;j{
cout<}
cout<<"\n";
}
}
voidmain（）
{
int**a;
intn;
cout<<"请输入N"<cin>>n;
a=newint*[n];//申请一个N行N列的数组
for（inti1=0;i1{
a[i1]=newint[n];
}
for（inti=0;i{
for（intj=0;j{
a[i][j]=0;
}
}
fullxunhuan（a,n）;
print（a,n）;
}
ACM小组内部预定函数
数学问题：
1.精度计算——大数阶乘
2.精度计算——乘法（大数乘小数）
3.精度计算——乘法（大数乘大数）
4.精度计算——加法
5.精度计算——减法
6.任意进制转换
7.最大公约数、最小公倍数
8.组合序列
9.快速傅立叶变换（FFT）
10.Ronberg算法计算积分
11.行列式计算
12.求排列组合数
字符串处理：
1.字符串替换
2.字符串查找
3.字符串截取
计算几何：
1.叉乘法求任意多边形面积
2.求三角形面积
3.两矢量间角度
4.两点距离（2D、3D）
5.射向法判断点是否在多边形内部
6.判断点是否在线段上
7.判断两线段是否相交
8.判断线段与直线是否相交
9.点到线段最短距离
10.求两直线的交点
11.判断一个封闭图形是凹集还是凸集
12.Graham扫描法寻找凸包
数论：
1.x的二进制长度
2.返回x的二进制表示中从低到高的第i位
3.模取幂运算
4.求解模线性方程
5.求解模线性方程组（中国余数定理）
6.筛法素数产生器
7.判断一个数是否素数
图论：
1.Prim算法求最小生成树
2.Dijkstra算法求单源最短路径
3.Bellman-ford算法求单源最短路径
4.Floyd算法求每对节点间最短路径
排序/查找：
1.快速排序
2.希尔排序
3.选择法排序
4.二分查找
数据结构：
1.顺序队列
2.顺序栈
3.链表
4.链栈
5.二叉树
一、数学问题
1.精度计算——大数阶乘
语法：
intresult=factorial（intn）;
参数：
n：
n的阶乘
返回值：
阶乘结果的位数
注意：
本程序直接输出n!
的结果，需要返回结果请保留longa[]
需要math.h
源程序：
intfactorial（intn）
{
longa[10000];
inti,j,l,c,m=0,w;
a[0]=1;
for（i=1;i<=n;i++）
{
c=0;
for（j=0;j<=m;j++）
{
a[j]=a[j]*i+c;
c=a[j]/10000;
a[j]=a[j]%10000;
}
if（c>0）{m++;a[m]=c;}
}
w=m*4+log10（a[m]）+1;
printf（"\n%ld",a[m]）;
for（i=m-1;i>=0;i--）printf（"%4.4ld",a[i]）;
returnw;
}
2.精度计算——乘法（大数乘小数）
语法：
mult（charc[],chart[],intm）;
参数：
c[]：
被乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
m：
乘数，限定10以内
返回值：
null
注意：
需要string.h
源程序：
voidmult（charc[],chart[],intm）
{
inti,l,k,flag,add=0;
chars[100];
l=strlen（c）;
for（i=0;is[l-i-1]=c[i]-'0';
for（i=0;i{
k=s[i]*m+add;
if（k>=10）{s[i]=k%10;add=k/10;flag=1;}else{s[i]=k;flag=0;add=0;}
}
if（flag）{l=i+1;s[i]=add;}elsel=i;
for（i=0;it[l-1-i]=s[i]+'0';
t[l]='\0';
}
3.精度计算——乘法（大数乘大数）
语法：
mult（chara[],charb[],chars[]）;
参数：
a[]：
被乘数，用字符串表示，位数不限
b[]：
乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
空间复杂度为o（n^2）
需要string.h
源程序：
voidmult（chara[],charb[],chars[]）
{
inti,j,k=0,alen,blen,sum=0,res[65][65]={0},flag=0;
charresult[65];
alen=strlen（a）;blen=strlen（b）;
for（i=0;ifor（j=0;jfor（i=alen-1;i>=0;i--）
{
for（j=blen-1;j>=0;j--）sum=sum+res[i+blen-j-1][j];
result[k]=sum%10;
k=k+1;
sum=sum/10;
}
for（i=blen-2;i>=0;i--）
{
for（j=0;j<=i;j++）sum=sum+res[i-j][j];
result[k]=sum%10;
k=k+1;
sum=sum/10;
}
if（sum!
=0）{result[k]=sum;k=k+1;}
for（i=0;ifor（i=k-1;i>=0;i--）s[i]=result[k-1-i];
s[k]='\0';
while
（1）
{
if（strlen（s）!
=strlen（a）&&s[0]=='0'）
strcpy（s,s+1）;
else
break;
}
}
4.精度计算——加法
语法：
add（chara[],charb[],chars[]）;
参数：
a[]：
被乘数，用字符串表示，位数不限
b[]：
乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
空间复杂度为o（n^2）
需要string.h
源程序：
voidadd（chara[],charb[],charback[]）
{
inti,j,k,up,x,y,z,l;
char*c;
if（strlen（a）>strlen（b））l=strlen（a）+2;elsel=strlen（b）+2;
c=（char*）malloc（l*sizeof（char））;
i=strlen（a）-1;
j=strlen（b）-1;
k=0;up=0;
while（i>=0||j>=0）
{
if（i<0）x='0';elsex=a[i];
if（j<0）y='0';elsey=b[j];
z=x-'0'+y-'0';
if（up）z+=1;
if（z>9）{up=1;z%=10;}elseup=0;
c[k++]=z+'0';
i--;j--;
}
if（up）c[k++]='1';
i=0;
c[k]='\0';
for（k-=1;k>=0;k--）
back[i++]=c[k];
back[i]='\0';
}
5.精度计算——减法
语法：
sub（chars1[],chars2[],chart[]）;
参数：
s1[]：
被减数，用字符串表示，位数不限
s2[]：
减数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
默认s1>=s2，程序未处理负数情况
需要string.h
源程序：
voidsub（chars1[],chars2[],chart[]）
{
inti,l2,l1,k;
l2=strlen（s2）;l1=strlen（s1）;
t[l1]='\0';l1--;
for（i=l2-1;i>=0;i--,l1--）
{
if（s1[l1]-s2[i]>=0）
t[l1]=s1[l1]-s2[i]+'0';
else
{
t[l1]=10+s1[l1]-s2[i]+'0';
s1[l1-1]=s1[l1-1]-1;
}
}
k=l1;
while（s1[k]<0）{s1[k]+=10;s1[k-1]-=1;k--;}
while（l1>=0）{t[l1]=s1[l1];l1--;}
loop:
if（t[0]=='0'）
{
l1=strlen（s1）;
for（i=0;it[l1-1]='\0';
gotoloop;
}
if（strlen（t）==0）{t[0]='0';t[1]='\0';}
}
6.任意进制转换
语法：
conversion（chars1[],chars2[],longd1,longd2）;
参数：
s[]：
原进制数字，用字符串表示
s2[]：
转换结果，用字符串表示
d1：
原进制数
d2：
需要转换到的进制数
返回值：
null
注意：
高于9的位数用大写'A'～'Z'表示，2～16位进制通过验证
源程序：
voidconversion（chars[],chars2[],longd1,longd2）
{
longi,j,t,num;
charc;
num=0;
for（i=0;s[i]!
='\0';i++）
{
if（s[i]<='9'&&s[i]>='0'）t=s[i]-'0';elset=s[i]-'A'+10;
num=num*d1+t;
}
i=0;
while
（1）
{
t=num%d2;
if（t<=9）s2[i]=t+'0';elses2[i]=t+'A'-10;
num/=d2;
if（num==0）break;
i++;
}
for（j=0;j
{c=s2[j];s2[j]=s[i-j];s2[i-j]=c;}
s2[i+1]='\0';
}
7.最大公约数、最小公倍数
语法：
resulet=hcf（inta,intb）、result=lcd（inta,intb）
参数：
a：
inta，求最大公约数或最小公倍数
b：
intb，求最大公约数或最小公倍数
返回值：
返回最大公约数（hcf）或最小公倍数（lcd）
注意：
lcd需要连同hcf使用
源程序：
inthcf（inta,intb）
{
intr=0;
while（b!
=0）
{
r=a%b;
a=b;
b=r;
}
return（a）;
}
lcd（intu,intv,inth）
{
return（u*v/h）;
}
8.组合序列
语法：
m_of_n（intm,intn1,intm1,int*a,inthead）
参数：
m：
组合数C的上参数
n1：
组合数C的下参数
m1：
组合数C的上参数，递归之用
*a：
1～n的整数序列数组
head：
头指针
返回值：
null
注意：
*a需要自行产生
初始调用时，m=m1、head=0
调用例子：
求C（m,n）序列：
m_of_n（m,n,m,a,0）;
源程序：
voidm_of_n（intm,intn1,intm1,int*a,inthead）
{
inti,t;
if（m1<0||m1>n1）return;
if（m1==n1）
{
for（i=0;icout<<'\n';
return;
}
m_of_n（m,n1-1,m1,a,head）;//递归调用
t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t;
m_of_n（m,n1-1,m1-1,a,head+1）;//再次递归调用
t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t;
}
9.快速傅立叶变换（FFT）
语法：
kkfft（doublepr[],doublepi[],intn,intk,doublefr[],doublefi[],intl,intil）;
参数：
pr[n]：
输入的实部
pi[n]：
数入的虚部
n，k：
满足n=2^k
fr[n]：
输出的实部
fi[n]：
输出的虚部
l：
逻辑开关，0FFT，1ifFT
il：
逻辑开关，0输出按实部/虚部；1输出按模/幅角
返回值：
null
注意：
需要math.h
源程序：
voidkkfft（pr,pi,n,k,fr,fi,l,il）
intn,k,l,il;
doublepr[],pi[],fr[],fi[];
{
intit,m,is,i,j,nv,l0;
doublep,q,s,vr,vi,poddr,poddi;
for（it=0;it<=n-1;it++）
{
m=it;is=0;
for（i=0;i<=k-1;i++）
{j=m/2;is=2*is+（m-2*j）;m=j;}
fr[it]=pr[is];fi[it]=pi[is];
}
pr[0]=1.0;pi[0]=0.0;
p=6.283185306/（1.0*n）;
pr[1]=cos（p）;pi[1]=-sin（p）;
if（l!
=0）pi[1]=-pi[1];
for（i=2;i<=n-1;i++）
{
p=pr[i-1]*pr[1];
q=pi[i-1]*pi[1];
s=（pr[i-1]+pi[i-1]）*（pr[1]+pi[1]）;
pr[i]=p-q;pi[i]=s-p-q;
}
for（it=0;it<=n-2;it=it+2）
{
vr=fr[it];vi=fi[it];
fr[it]=vr+fr[it+1];fi[it]=vi+fi[it+1];
fr[it+1]=vr-fr[it+1];fi[it+1]=vi-fi[it+1];
}
m=n/2;nv=2;
for（l0=k-2;l0>=0;l0--）
{
m=m/2;nv=2*nv;
for（it=0;it<=（m-1）*nv;it=it+nv）
for（j=0;j<=（nv/2）-1;j++）
{
p=pr[m*j]*fr[it+j+nv/2];
q=pi[m*j]*fi[it+j+nv/2];
s=pr[m*j]+pi[m*j];
s=s*（fr[it+j+nv/2]+fi[it+j+nv/2]）;
poddr=p-q;poddi=s-p-q;
fr[it+j+nv/2]=fr[it+j]-poddr;
fi[it+j+nv/2]=fi[it+j]-poddi;
fr[it+j]=fr[it+j]+poddr;
fi[it+j]=fi[it+j]+poddi;
}
}
if（l!
=0）
for（i=0;i<=n-1;i++）
{
fr[i]=fr[i]/（1.0*n）;
fi[i]=fi[i]/（1.0*n）;
}
if（il!
=0）
for（i=0;i<=n-1;i++）
{
pr[i]=sqrt（fr[i]*fr[i]+fi[i]*fi[i]）;
if（fabs（fr[i]）<0.000001*fabs（fi[i]））
{
if（（fi[i]*fr[i]）>0）pi[i]=90.0;
elsepi[i]=-90.0;
}
else
pi[i]=atan（fi[i]/fr[i]）*360.0/6.283185306;
}
return;
}
10.Ronberg算法计算积分
语法：
result=integral（doublea,doubleb）;
参数：
a：
积分上限
b：
积分下限
functionf：
积分函数
返回值：
f在（a,b）之间的积分值
注意：
functionf（x）需要自行修改，程序中用的是sina（x）/x
需要math.h
默认精度要求是1e-5
源程序：
doublef（doublex）
{
returnsin（x）/x;//在这里插入被积函数
}
doubleintegral（doublea,doubleb）
{
doubleh=b-a;
doublet1=（1+f（b））*h/2.0;
intk=1;
doubler1,r2,s1,s2,c1,c2,t2;
loop:
doubles=0.0;
doublex=a+h/2.0;
while（x{
s+=f（x）;
x+=h;
}
t2=（t1+h*s）/2.0;
s2=t2+（t2-t1）/3.0;
if（k==1）
{
k++;h/=2.0;t1=t2;s1=s2;
gotoloop;
}
c2=s2+（s2-s1）/15.0;
if（k==2）{
c1=c2;k++;h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
r2=c2+（c2-c1）/63.0;
if（k==3）{
r1=r2;c1=c2;k++;
h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
while（fabs（1-r1/r2）>1e-5）{
r1=r2;c1=c2;k++;
h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
returnr2;
}
11.行列式计算
语法：
result=js（ints[][],intn）
参数：
s[][]：
行列式存储数组
n：
行列式维数，递归用
返回值：
行列式值
注意：
函数中常数N为行列式维度，需自行定义
源程序：
intjs（s,n）
ints[][N],n;
{
intz,j,k,r,total=0;
intb[N][N];/*b[N][N]用于存放，在矩阵s[N][N]中元素s[0]的余子式*/
if（n>2）
{
for（z=0;z{
for（j=0;jfor（k=0;kif（k>=z）b[j][k]=s[j+1][k+1];elseb[j][k]=s[j+1][k];
if（z%2==0）r=s[0][z]*js（b,n-1）;/*递归调用*/
elser=（-1）*s[0][z]*js（b,n-1）;
total=total+r;
}
}
elseif（n==2）
total=s[0][0]*s[1][1]-s[0][1]*s[1][0];
returntotal;
}
12.求排列组合数
语法：
result=P（longn,longm）;/result=longC（longn,longm）;
参数：
m：
排列组合的上系数
n：
排列组合的下系数
返回值：
排列组合数
注意：
符合数学规则：
m<＝n
源程序：
longP（longn,longm）
{
longp=1;
while（m!
=0）
{p*=n;n--;m--;}
returnp;
}
longC（longn,longm）
{
longi,c=1;
i=m;
while（i!
=0）
{c*=n;n--;i--;}
while（m!
=0）
{c/=m;m--;}
returnc;
}
二、字符串处理
1.字符串替换
语法：
replace（charstr[],charkey[],charswap[]）;
参数：
str[]：
在此源字符串进行替换操作
key[]：
被替换的字符串，不能为空串
swap[]：
替换
升级会员 