常用代码总结
1：如何保证int char数组 输入时的正确性和安全性?
# include //int char 输入容易出问题 下面的代码可以解决这个问题
# define N 10 //如果要录入X个字节则 N=X
int Getchar(char A[],int min,int max);//直到用户输入的字符串长度在[min,max]之间时 函数结束 返回字符串A的长度
int gainint(int *p,int a,int b);
int main(){
char A[N+1];//最后一位存'\0'
int L,min,max;
do{
printf("请输入字符串的长度的最小值[0,%d]：",N);
gainint(&min,0,N);
printf("请输入字符串的长度的最大值[%d,%d]：",min,N);
gainint(&max,min,N);
printf("请输入字符串[%d,%d]:",min,max);
Getchar(A,min,max);
printf("字符串：%s\n",A);
}while(1);
return 0;
}
int gainint(int *p,int a,int b)//输入int *p直至满足(a,b)输入结束，并返回*p的位数
{
do{
*p=a-1; //此处是为了减少意外情况的发生 虽然那种意外情况不常见
scanf("%d",p);
while(getchar()!='\n');
if(*p>b||*pb||*p 之间时 函数结束 返回字符串A的长度
{
int B,C;
do{
A[max]=B=C=0;
while((A[B++]=getchar())!='\n'&&B 具体网址在：int-char-输入
2：字符串全匹配：
# include
# define N 100 //如果要录入X个字节则 N=X
int Getchar(char A[],int min,int max);//直到用户输入的字符串长度在[min,max]之间时 函数结束 返回字符串A的长度
int BF(char a[],char b[],int c[]);//a为主串 b为次串 c[]存储匹配的下标 函数返回 匹配的个数
int main(){
char A[N+1],B[N+1];
int C[N],L,num,i;
do{
printf("请输入主字符串A[%d,%d]:",1,N);
L=Getchar(A,1,N);
printf("请输入次字符串B[%d,%d]:",1,L);
Getchar(B,1,L);
num=BF(A,B,C);
printf("B在A中共%d个,下标:",num);
for(i=0;i 之间时 函数结束 返回字符串A的长度
{
int B,C;
do{
A[max]=B=C=0;
while((A[B++]=getchar())!='\n'&&B -----------字符串直接替换
# include
# define N 101
int BF(char A[],char B[],char C[],char D[])
{//将A[]中的所有B[]换成C[] 所形成的新字符串存到D[]中
int i=0,j=0,k=0,m=0,n=0;//返回替换的个数
do{
if (B[j]&&A[i++]==B[j])j++;
else
{
if(!B[j]&&++n) while(C[m])D[k++]=C[m++];
else (i-=j)&&(D[k++]=A[i-1]);
j=m=0;
}
}while(A[i-1]);
return n;
}
int main()
{
char A[N],B[N],C[N],D[N];
gets(A);
gets(B);
gets(C);
printf("替换个数:%d\n新字符串:\n",BF(A,B,C,D));
puts(D);
}
更多关于字符串匹配的函数和代码链接：字符串替换-C语言
3：埃氏筛法：
常用的：
# include
# include
# define N 10000
char A[N];
int main()
{
int i,j,Q;
for(A[0]=A[1]=1,Q=sqrt(N)+1,i=2;i 保存质数的：
# include
# include
int ZHISHU(char S[],int T[]);//调用完此函数后 如果一个数X为质数 则S[X]=0 否则S[X]=1 T存储质数 返回质数的个数
# define N 10000
char A[N];
int B[N/10];
int main(){
int i,num;
num=ZHISHU(A,B);
for(i=0;i 更多内容链接：质数
4：快速排序一维和二维：
一：
# include
# define N 100
void change(int *a,int *b)//交换函数 交换a b的值
{
int c=*a;
*a=*b;
*b=c;
}
void Qsort(int A[],int L,int R)//快速排序 升序
{
int i=L,j=R,T=A[L]; //T为基准数
if(L>R) return;
while(i!=j) //当数组左右两边没相遇
{
while(A[j]>=T&&i=T&&i 二维：
# include
# define N 50
void change(int *a,int *b){//交换函数
int c=*a;
*a=*b;
*b=c;
}
void paixu(int A[][N],int left,int right)//快速排序升序
{
int i=left,j=right,temp[2]={A[0][left],A[1][left]};
if(left>=right) return;
while(i!=j)
{
while((A[0][j]>temp[0]||A[0][j]==temp[0]&&A[1][j]>=temp[1])&& i 相关题目：心急的小加C
5：堆--优先队列：
一维《最小堆：
# include //WEI行 N列的优先队列
# include
# include
# define N 100
void insert(int Tree[],int X);//向堆中插入值 S[WEI]
int Delmin(int Tree[]); //删除最小值-并返回最小值
int tree[N+1];
int main(){
int S,i,j;
srand(time(0));
printf("随机生成的数字:");
for(j=0;j以第每一列的第一个数字为基准:\n");
while(tree[0])
{
printf("%d \n",Delmin(tree));
}
return 0;
}
void insert(int Tree[],int X)
{
int par,i=++Tree[0]; //插入X 后 Tree[0]+1
while(i>1) //直到i不是根节点
{
par=(i>>1); //父节点为par
if(Tree[par]<=X) break; //将<=改为>=即改为最大堆了
Tree[i]=Tree[par]; //否则调整堆 即位置上移
i=par;
}
Tree[i]=X;//插入新节点
}
int Delmin(int Tree[])
{
int i=1,root=Tree[1],R,L,X=Tree[Tree[0]--];
while((i<<1)<=Tree[0])
{
L=i<<1;R=L+1;//Left Right 记录左右节点
if(R<=Tree[0]&&Tree[R][L]
L=R;
if(Tree[L]>=X) break; //并且将>=改为<=即为最大堆
Tree[i]=Tree[L];//否则继续调整堆
i=L;
}
Tree[i]=X;
return root;
} 二维堆：
# include //WEI行 N列的优先队列
# include
# include
# define N 101
# define WEI 2 //如果改为3行的 直接将WEI改为3
void insert(int Tree[][N],int S[]);//向最小堆中插入值 S[WEI]
void Delmin(int Tree[][N],int S[]);//删除堆的最小值 将最小值存在S中
int tree[WEI][N]; //初始化只需要将tree[0][0]设为0即可
int main(){
int S[WEI],i,j;
srand(time(0));
printf("随机生成的数字:");
for(j=0;j<10;j++)
{
for(i=0;i以第每一列的第一个数字为基准:\n");
while(tree[0][0]){//tree[0][0]数值=存储的数字组数
Delmin(tree,S);//每次删除完 tree[0][0]自动--
for(i=0;i>1) //直到i不是根节点
{
par=(i>>1); //父节点为par
if(Tree[0][par]<=S[0]) break;//如果父节点满足堆的特性 则插入当前的位置即可
for(j=0;j=S[0] 即为最大堆插入方式
Tree[j][i]=Tree[j][par]; //否则调整堆 即位置上移
i=par;
}
for(j=0;jTree[0][L]
L=R;
if(Tree[0][L]>=T[0]) break;//并将 Tree[0][L]>=T[0]改为Tree[0][L]<=T[0]即为最大堆的删除代码
for(j=0;j 堆排序：
# include
# include
# include
# define N 10000000
# define M 5000000
int tree[N];
void Dsort(int *tree,int n);
int main()
{
int i;
srand(time(0));
for(i=0;i1)
{
L=(i>>1);
if(tree[L]>=R) break;
tree[i]=tree[L];
i=L;
}
tree[i]=R;
}
while(n)
{
R=tree[n]; tree[n--]=tree[1];
i=1; L=2;
while(L<=n)
{
L+=Ltree[L];
if(tree[L]<=R) break;
tree[i]=tree[L];
i=L; L<<=1;
}
tree[i]=R;
}
} 二维堆排序：
# include
# include
# include
# define M 70
# define N 50
# define U 5
int tree[M][N];
void Dsort(int *tree[],int n);
int main()
{
int A[M][N],*p[M],i,j;
srand(time(0));
for(i=0; i1)
{
L=(i>>1);
for(k=0; k=R[k]) break;
tree[i]=tree[L];
i=L;
}
tree[i]=R;
}
while(n)
{
R=tree[n];
tree[n--]=tree[1];
i=1;
L=2;
while(L<=n)
{
if(Ltree[L][k])L++;
}
for(k=0; k
相关题目：ON-MYgodness || POJ-2431
6：大数斐波那契：
# include
# include
# define M 1000000000/*每一个int存9位*/
# define size 9290/*第40万个斐波那契需要9290个int的存储空间*/
# define MAX 400000
int add(int a[][size],int d);
int main()
{
int shu[3][size]={0,0,0},num,wei=0,k,t;/*初始化shu[][];*/
do{
while(wei<1||wei>MAX){
printf("显示第几个斐波纳挈数?(1--%d):\n",MAX);
scanf("%d",&wei);
while(getchar()!='\n');
}
t=num=add(shu,wei);
wei=(wei-1)%3;
k=printf("%d",shu[wei][num]);
shu[wei][num--]=0;
while(num>0)
{
printf("%09d",shu[wei][num]);
shu[wei][num--]=0;
}
printf("\n共%d位\n",(t-1)*9+k);
}while(t);
return 0;
}
int add(int a[][size],int b)
{
int i,j,m,k,c[]={0,1,2},index=1;
a[0][1]=a[1][1]=1;/*初值为1 1*/
for (i=1;i<=b;i++)
{
for (j=1;j<=index; j++)
a[c[2]][j]=a[c[0]][j]+a[c[1]][j];
for (k=1;k=M)
{
a[c[2]][k+1]+=a[c[2]][k]/M; /* 当前位向前进位 */
a[c[2]][k]%=M; /*当前位进位之后的值 */
}
while (a[c[2]][index]>=M)
{
a[c[2]][index+1] = a[c[2]][index]/M; /* 向最高位进位 */
a[c[2]][index++]%=M; /* 进位之后的值,位数+1*/
}
for(m=0;m<3;m++)
c[m]=(c[m]+1)%3;//对c[0--2]循环做加法
}
return index;
} 7：大数阶乘：
#include
#define SIZE 77200
# define N 10000 /*每四位进一位 每一个int 存四位*/
int BigFact(int m,int data[]);//计算m的阶乘
void main()
{
int data[SIZE] = {0}; /*存储SIZE位数,元素全部初始化为0,data[0]空着 */
int index,n=0,k; /* 数组元素个数，表示阶乘值的位数 */
printf("10000!用时约2秒\n20000!用时约5秒\n30000!用时约11秒\n40000!用时约21秒\n50000!用时约37秒\n60000!用
时约52秒\n70000!用时约73秒\n");
do{
do{
printf("输入n 求n!(1-70000):");
scanf("%d", &n);
while(getchar()!='\n');
}while(n<1||n>70000);
printf("%d!=\n", n);
n=index = BigFact(n,data);/* 计算阶乘n!，返回阶乘值的位数 */
if (index) /* 检验数组是否溢出，若未溢出，则打印阶乘值 */
k=printf("%d",data[index]);
data[index--]=0;
while(index>0)
{
printf("%04d",data[index--]);
data[index--]=0;
}
printf("\n位数共%d位\n",(n-1)*4+k);
}while(1);
}
int BigFact(int m, int data[])/*函数功能：计算m!，存于数组data中返回阶乘值的位数*/
{
int i, j, k,index = 1; /* 数组元素个数，表示阶乘值的位数 */
for (data[1]=i=1; i<=m; i++) /* 初始化，令1!=1 计算阶乘m!*/
{
for (j=1; j<=index; j++)
data[j]=data[j] * i;/*每一位数字都乘以i,模仿乘法计算*/
for (k=1; k=N) /*阶乘值的每位数字应在0~9之内若>=10，则进位*/
{
data[k+1]+=data[k]/N; /* 当前位向前进位 */
data[k]%=N;
/*当前位进位之后的值 */
}
/* 单独处理最高位，若计算之后的最高位>=10，则位数index加1 */
while (data[index] >=N)
{
data[index+1] = data[index]/N; /* 向最高位进位 */
data[index++]%=N; /* 进位之后的值 位数index加1 */
}
}
return index;/*返回阶乘值的位数 */
}
更多代码内容链接：大数