常用代码总结

1：如何保证int char数组 输入时的正确性和安全性?

# include <stdio.h>//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||*p<a)        
            printf("输入有误,请重新输入[%d--%d]:",a,b);        
    }while(*p>b||*p<a);        
    return *p;        
}
int Getchar(char *A,int min,int max)//长度在[min,max]  <闭区间>  之间时 函数结束 返回字符串A的长度      
{      
    int B,C;    
 do{      
        A[max]=B=C=0;  
        while((A[B++]=getchar())!='\n'&&B<max);  
        if(A[B-1]!='\n')while(getchar()!='\n'&&++C);      
        else A[--B]=0;   
    if(C||B&&B<min)  
       printf("您录入的字符串长度:%d字节\n只录入(%d--%d)个字节!\n",B+C,min,max);      
    }while(C||B<min);      
    return B;    
} 

具体网址在：int-char-输入
2：字符串全匹配：

# include <stdio.h> 
# 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<num;i++)
    printf("%d ",C[i]);
    printf("\n");
    }while(1);
    return 0;  
}  
int BF(char a[],char b[],int c[])//a为主串 b为次串 c[]存储匹配的下标 函数返回 匹配的个数 
{                       
    int i=0,j=0,k=0;   
    do{  
        if (b[j]&&a[i++]==b[j])++j;  
        else  
        {  
            b[j]?(i-=j):(c[k++]=i-j);   
            j=0;              
        }  
    }while(a[i-1]);  
      return k;  
}  
int Getchar(char *A,int min,int max)//长度在[min,max]  <闭区间>  之间时 函数结束 返回字符串A的长度      
{      
    int B,C;    
 do{      
        A[max]=B=C=0;  
        while((A[B++]=getchar())!='\n'&&B<max);  
        if(A[B-1]!='\n')while(getchar()!='\n'&&++C);      
        else A[--B]=0;   
    if(C||B&&B<min)  
       printf("您录入的字符串长度:%d字节\n只录入(%d--%d)个字节!\n",B+C,min,max);      
    }while(C||B<min);      
    return B;    
} 

-----------字符串直接替换

# include <stdio.h>
# 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 <stdio.h>  
# include <math.h>  
# 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<Q;i++)
		if(!A[i])for(j=i*i;j<N;j+=i)
			A[j]=1;//经过筛法后 如果i是质数则S[i]=0 否则为1  
		printf("[2,%d)的质数:\n",N);
    for(i=0;i<N;i++)  
    if(!A[i])printf("%d ",i);  
    return 0;  
}  

保存质数的：

# include <stdio.h>  
# include <math.h>  
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<num;i++)  
       printf("%d ",B[i]);
	printf("\n区间[2,%d)的质数个数共%d个\n",N,num);
    return 0;  
}  
int ZHISHU(char S[],int T[])//调用完此函数后 如果一个数X为质数 则S[X]=0 否则S[X]=1 
{                           
   int i,j,k=0,Q=sqrt(N)+1;  
    for(S[0]=S[1]=1,i=2;i<Q;i++)  
    if(!S[i])  
    {  
          for(j=i*i;j<N;j+=i)  
          S[j]=1;  
        T[k++]=i;  
    }  
    do{  
    if(!S[i])T[k++]=i;  
    }while(++i<N);  
   return k;  
} 

更多内容链接：质数

4：快速排序一维和二维：

一：

# include <stdio.h>
# 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<j)j--;  //从右向左找  改为while(A[j]<=T&&i<j)
		while(A[i]<=T&&i<j)i++; //从左向右找   改为while(A[i]>=T&&i<j) 这两处 改完即为降序 
		if(i<j)change(&A[i],&A[j]); //交换两数
    }
if(L!=i)change(&A[L],&A[i]);       //基准数归位
    Qsort(A,L,i-1);         //递归左
    Qsort(A,i+1,R);         //递归右
}
int main(){
    int i,A[N]={10,15,1,2,789,456,145,41525}; //总共8个数字 
    Qsort(A,0,7);//数组下标为0--7 
	for(i=0;i<8;i++)
	 printf("%d ",A[i]);
    return 0;
}

二维：

# include <stdio.h>  
# 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<j)j--;  
        while((A[0][i]<temp[0]||A[0][i]==temp[0]&&A[1][i]<=temp[1])&& i<j)i++;  
        if(i<j)  
        {  
            change(&A[0][i],&A[0][j]);  
            change(&A[1][i],&A[1][j]);  
        }  
}  
if(i!=left)  
{  
    change(&A[0][left],&A[0][i]);  
    change(&A[1][left],&A[1][i]);  
}  
    paixu(A,left,i-1);  
    paixu(A,i+1,right);  
}    
int main(){  
    int i,T[2][N]={{8,8,6,6,3,3},{1,2,2,1,1,2}}; 
    paixu(T,0,5);//共2行8列 以第一行为基准升序 下标0--7
	for(i=0;i<6;i++)
	    printf("%d %d\n",T[0][i],T[1][i]); 
    return 0;  
}  

相关题目：心急的小加C

5：堆--优先队列：

一维《最小堆：

# include <stdio.h>  //WEI行 N列的优先队列 
# include <stdlib.h>
# include <time.h>
# 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;j++)
	{
	  	S=rand()%100+50;
	  	printf("%d \n",S);
	   insert(tree,S);
	}
	printf("堆的全部删除>以第每一列的第一个数字为基准:\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]<Tree[L])//如果将tree[R]<tree[L] 改为tree[R]>[L]
                L=R;    
      if(Tree[L]>=X) break;         //并且将>=改为<=即为最大堆
      Tree[i]=Tree[L];//否则继续调整堆    
      i=L;    
   }    
   Tree[i]=X;    
   return  root;    
}  

二维堆：

# include <stdio.h>  //WEI行 N列的优先队列 
# include <stdlib.h>
# include <time.h>
# 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<WEI;i++)
	  {
	  	S[i]=rand()%100+50;
	  	printf("%d ",S[i]);
	  }
	  insert(tree,S);
	  printf("\n");
	}
	printf("堆的全部删除>以第每一列的第一个数字为基准:\n");
	while(tree[0][0]){//tree[0][0]数值=存储的数字组数
		Delmin(tree,S);//每次删除完 tree[0][0]自动--
		for(i=0;i<WEI;i++) 
		printf("%d ",S[i]);
		printf("\n");
	}
	return 0;
}
void insert(int Tree[][N],int S[]) //向最小堆Tree[]里插入元素S[WEI]  
{  
    int par,i=++Tree[0][0],j;  //插入X 后 Tree[0]+1  
    while(i>>1)  //直到i不是根节点  
    {  
       par=(i>>1);  //父节点为par  
       if(Tree[0][par]<=S[0]) break;//如果父节点满足堆的特性 则插入当前的位置即可  
       for(j=0;j<WEI;j++)                    //如果将Tree[0][par]<=S[0]改为Tree[0][par]>=S[0] 即为最大堆插入方式
       Tree[j][i]=Tree[j][par]; //否则调整堆 即位置上移  
       i=par;  
    }  
    for(j=0;j<WEI;j++)  
    Tree[j][i]=S[j];
}  
void Delmin(int Tree[][N],int S[])//删除最值 将最值存在S中 
{  
   int i=1,j,R,L,m=Tree[0][0],T[WEI];  
   for(j=0;j<WEI;j++)
   {
   	T[j]=Tree[j][m];
   	S[j]=Tree[j][1];
   }
   while((i<<1)<m)  
   {  
      L=(i<<1);R=L+1; 
      if(R<m&&Tree[0][R]<Tree[0][L])//如果将 Tree[0][R]<Tree[0][L]改为Tree[0][R]>Tree[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<WEI;j++)  
      Tree[j][i]=Tree[j][L];//否则继续调整堆  
      i=L;  
   }  
   for(Tree[0][0]--,j=0;j<WEI;j++)  
   Tree[j][i]=T[j];  //调整好并赋值    
} 

堆排序：

# include <stdio.h>
# include <time.h>
# include <stdlib.h>
# 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;i<N;i++)
        tree[i]=rand()%M+1;
        //printf("%d\n",tree[i]=rand()%M+1);
    Dsort(tree,N);
    printf("\n");
  // for(i=0;i<N;i++)
      // printf("%d ",tree[i]);
    printf("over\n");
}
void Dsort(int *tree,int n)
{
    int i,j=1,L,R;
    tree--;
    while((i=++j)<=n)
    {
        R=tree[i];
        while(i>1)
        {
            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+=L<n&&tree[L+1]>tree[L];
            if(tree[L]<=R) break;
            tree[i]=tree[L];
            i=L;     L<<=1;
        }
        tree[i]=R;
    }
}

二维堆排序：

# include <stdio.h>
# include <time.h>
# include <stdlib.h>
# 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; i<M; i++)
    {
       for(j=0; j<N; j++)
          //A[i][j]=rand()%U+1;
            printf("%d ",A[i][j]=rand()%U+1);
        printf("\n");
        p[i]=&A[i][0];
    }
    printf("<\n");
    Dsort(p,M);
   printf("\n");
    for(i=0; i<M; i++)
    {
        for(j=0; j<N; j++)
            printf("%d ",p[i][j]);
        printf("\n");
    }
    printf("over\n");
    return 0;
}
void Dsort(int *tree[],int n)
{
    int i,j=0,k,L,*R;
    tree--;
    while((i=++j)<=n)
    {
        R=tree[i];
        while(i>1)
        {
            L=(i>>1);
            for(k=0; k<N&&tree[L][k]==R[k]; k++);
            if(tree[L][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(L<n)
            {
                for(k=0; k<N&&tree[L+1][k]==tree[L][k]; k++);
                if(tree[L+1][k]>tree[L][k])L++;
            }
            for(k=0; k<N&&tree[L][k]==R[k]; k++);
            if(tree[L][k]<=R[k]) break;
            tree[i]=tree[L];
            i=L;
            L<<=1;
        }
        tree[i]=R;
    }
    tree++;
}

 

相关题目：ON-MYgodness  || POJ-2431

6：大数斐波那契：

# include <stdlib.h>      
# include <stdio.h>      
# 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<index; k++)      
            if (a[c[2]][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 <stdio.h>  
#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<index; k++)  
            if (data[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;/*返回阶乘值的位数 */  
}  

更多代码内容链接：大数