C语言常用代码.docx
《C语言常用代码.docx》由会员分享，可在线阅读，更多相关《C语言常用代码.docx（22页珍藏版）》请在冰豆网上搜索。
C语言常用代码
for（inti=0;ifor（intj=0;j}
}fullxunhuan（a,n）;
print（a,n）;
}
#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"<>n;
a=newint*[n];//申请一个N行N列
的数组
for（inti1=0;i1a[i1]=newint[n];
}
给数组初始化
ACMJ、组内部预定函数
数学问题：
1.精度计算—大数阶乘
2.精度计算——乘法（大数乘小数）
3.精度计算乘法（大数乘大数）
4.精度计算一一加法
5.精度计算一一减法
6•任意进制转换
7.最大公约数、最小公倍数
8.组合序列
9.快速傅立叶变换（FFT
10.Ronberg算法计算积分
11.行列式计算
12.求排列组合数
字符串处理：
1.字符串替换
2.字符串查找
3.字符串截取
计算几何：
1.叉乘法求任意多边形面积
2.求三角形面积
3.两矢量间角度
4.两点距离（2D3D）
5.射向法判断点是否在多边形内部
6.判断点是否在线段上
7.判断两线段是否相交
8.判断线段与直线是否相交
9.点到线段最短距离
10.求两直线的交点
11.判断一个封闭图形是凹集还是凸集
12.Graham扫描法寻找凸包
数论：
1.x的二进制长度
2.返回x的二进制表示中从低到高的第
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;
i位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;
3.精度计算——乘法（大数乘大数）
}
语法：
mult（chara[],charb[],chars[]）;
if（c>0）{m++;a[m]=c;}
参数：
}
a[]：
被乘数，用字符串表示，位数不限b[]：
乘数，用字符串表示，位数不限
w=m*4+log10（a[m]）+1;
t[]：
结果，用字符串表示
printf（"\n%ld",a[m]）;
返回值：
null
for（i=m-1;i>=0;i--）
注意：
printf（"%4.4ld",a[i]）;
空间复杂度为o（nA2）
returnw;
需要string.h
}
源程序：
voidmult（chara[],charb[],char
2.精度计算——乘法（大数乘小数）
s[]）
语法：
mult（charc[],chart[],intm）;
{
参数：
int
c[]：
被乘数，用字符串表示，
位数不限
i,j,k=0,alen,blen,sum=0,res[65][65]={
t[]：
结果，用字符串表示
0},flag=0;
m：
乘数，限定10以内
charresult[65];
返回值：
null
alen=strlen（a）;blen=strlen（b）;
注意：
for（i=0;i需要string.h
for（j=0;j源程序：
res[i][j]=（a[i]-'0'）*（b[j]-'0'）;
voidmult（charc[],chart[],intm）{
inti,l,k,flag,add=0;
for（i=alen-1;i>=0;i--）
{
for（j=blen-1;j>=0;j--）
chars[100];
sum=sum+res[i+blen-j-1][j];
l=strlen（c）;
result[k]=sum%10;
for（i=0;ik=k+1;
s[l-i-1]=c[i]-'0';
sum=sum/10;
for（i=0;i}
{
for（i=blen-2;i>=0;i--）
k=s[i]*m+add;
{
if
（k>=10）
for（j=0;j<=i;j++）
{s[i]=k%10;add=k/10;flag=1;}
else
sum=sum+res[i-j][j];
{s[i]=k;flag=0;add=0;}
result[k]=sum%10;
}
k=k+1;
if（flag）{l=i+1;s[i]=add;}
else
sum=sum/10;
l=i;
}
for（i=0;iif（sum!
=0）{result[k]=sum;k=k+1;}
t[l-1-i]=s[i]+'0';
for（i=0;it[l]='\0';
for（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（nA2）
需要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[i]=t[i+1];t[l1-1]='\0';gotoloop;}
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';
if
（strlen（t）==0）
}
{t[0]='0';t[1]='\0';}
}
7.最大公约数、最小公倍数
语法：
resulet=hcf（inta,intb）、
6.任意进制转换
result=lcd（inta,intb）
语法
：
conversion（chars1[],char
参数：
s2[],longd1,longd2）;
a：
inta，求最大公约数或最小公倍数
参数：
b：
intb，求最大公约数或最小公倍数
s[]：
原进制数字，用字符串表示
返回值：
返回最大公约数（hcf）或最
s2[]：
转换结果，用字符串表示
小公倍数（lcd）
d1：
原进制数
注意：
d2：
需要转换到的进制数
lcd需要连同hcf使用
返回值：
null
源程序：
注意：
inthcf（inta,intb）
高于
9的位数用大写A〜'Z'表示，2〜
{
16位进制通过验证
intr=0;
源程序：
while（b!
=0）
void
conversion（chars[],char
{
s2[],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;
{
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=m、1head=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;
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];
{
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.28318
5306;
}
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;jif（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）;/*递归调用*/else
r=（-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]
J
returntotal;
}
12.求排列组合数
语法：
result=P（longn,longm）;/result=longC（longn,longm）;
参数：
m：
排列组合的上系数
n：
排列组合的下系数返回值：
排列组合数
符合数学规则：
mJn
源程序：
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[]：
替换的字符串，可以为空串，为空串表示在源字符中删除key[]返回值：
null
默认str[]长度小于1000，如否，重新设定设定tmp大小
需要string.h
源程序：
voidreplace（charstr[],char
key[],charswap[]）
{
intl1,l2,l3,i,j,flag;
chartmp[1000];
l1=strlen（str）;
l2=strlen（key）;
l3=strlen（swap）;
for（i=0;i<=l1-l2;i++）
{
flag=1;
for（j=0;jif（str[i+j]!
=key[j]）
{flag=0;break;}
if（flag）
{
strcpy（tmp,str）;
strcpy（&tmp[i],swap）;
strcpy（&tmp[i+l3],&str[i+l2]）;
strcpy（str,tmp）;
i+=l3-1;
l1=strlen（str）;
}
}
}
2.字符串查找
语法：
result=strfind（charstr[],charkey[]）;
参数：
str[]：
在此源字符串进行查找操作key[]：
被查找的字符串，不能为空串返回值：
如果查找成功，返回key在str中第一次出现的位置，否则返回-1
需要string.h
源程序：
intstrfind（charstr[],charkey[]）
{
intl1,l2,i,j,flag;l1=strlen（str）;
l2=strlen（key）;
for（i=0;i<=l1-l2;i++）{flag=1;
for（j=0;jif（str[i+j]!
=key[j]）{flag=0;break;}
if（flag）returni;
}
return-1;
}
3.字符串截取
语法：
mid（charstr[],intstart,intlen,charstrback[]）
参数：
str[]：
操作的目标字符串
start：
从第start个字符串开始，截取长度为len的字符
len：
从第start个字符串开始，截取长
度为len的字符
strback[]：
截取的到的字符
返回值：
0：
超出字符串长度，截取失
败；1：
截取成功
需要string.h源程序：
intmid（charstr[],intstart,intlen,charstrback[]）{
intl,i,k=0;l=strlen（str）;
if（start+len>l）return0;
for（i=start;istrback[k]='\0';
升级会员 