简单c程序范例1

【1】链表(数据域中的数据，从小到大排序)

在单链表的开始结点之前附设一个类型相同的结点，称之为头结点。头结点的数据域可以不存储任何信息，头结点的指针域存储指向开始结点的指针（即第一个元素结点的存储位置）。

#include  <stdio.h>
#include  <stdlib.h>
#define    N    6
typedef struct node {
  int  data;
  struct node  *next;
} NODE;
void fun(NODE  *h)//选择排序法
{ NODE  *p, *q;    int  t;
  p = h->next ;//p指向头结点
  while (p) {//遍历各个节点
     q = p->next ;//将p节点的下一个节点赋值给q
     while (q) {//遍历p节点后的各节点
        if (p->data> q->data)//将小的值赋给p
        {  t = p->data;  p->data = q->data;  q->data = t;  }
        q = q->next;
    }
    p = p->next;
  }
}
NODE *creatlist(int  a[])
{  NODE  *h,*p,*q;        int  i;
  h = (NODE *)malloc(sizeof(NODE));
  h->next = NULL;
  for(i=0; i<N; i++)
  {  q=(NODE *)malloc(sizeof(NODE));
     q->data=a[i];
     q->next = NULL;
     if (h->next == NULL)  h->next = p = q;
     else    {  p->next = q;  p = q;   }
  }
   return  h;
}
void outlist(NODE  *h)
{ NODE  *p;
  p = h->next;
  if (p==NULL)  printf("The list is NULL!\n");
  else
  {  printf("\nHead  ");
     do
     {  printf("->%d", p->data); p=p->next;  }
     while(p!=NULL);
     printf("->End\n");
  }
}
void main()
{  NODE  *head;
   int  a[N]= {0, 10, 4, 2, 8, 6 };
   head=creatlist(a);
   printf("\nThe original list:\n");
   outlist(head);
   fun(head);
   printf("\nThe list after sorting :\n");
   outlist(head);
}

【2】链表（求数据域中最大值）

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
typedef struct aa
{ int data;
  struct aa *next;
} NODE;
int fun (NODE *h)//有返回值类型int
{ int max=-1;
  NODE *p;
  p=h->next;//p指向头结点的下一个节点
  while(p)
       { if(p->data>max)
             max=p->data;
          p=p->next;//指针后移
       }
  return max;
}
void outresult(int s, FILE *pf)
{ fprintf(pf, "\nThe max in link :%d\n",s);
}
NODE *creatlink(int n, int m)
{ NODE *h,*p,*s;
  int i;
  h=p=(NODE *)malloc(sizeof(NODE));
  h->data=9999;
  for(i=1;i<=n;i++)
    { s=(NODE *) malloc(sizeof(NODE));
      s->data=rand()%m; s->next=p->next;
      p->next=s;  p=p->next;
    }
  p->next=NULL;
  return h;
}
void outlink(NODE *h,FILE *pf)
{ NODE  *p;
  p=h->next;
  fprintf(pf, "\n The LIST :\n\n HEAD");
  while(p)
    { fprintf(pf, "->%d",p->data); 
  p=p->next;}
  fprintf(pf, "\n");
}
void main()
{ NODE *head; int m;
  system("CLS");
  head=creatlink(12,100);
  outlink(head,stdout);
  m=fun(head);
  printf("\nThe RESULT :\n"); 
  outresult(m,stdout);
}

【3】二维到一维数组

void fun (int (*s)[10], int *b, int *n, int mm, int nn)
{
   int i,j,k=0;
  for(i=0;i<mm;i++) //mm 二维数组行的长度
     for(j=0;j<nn;j++)//nn二维数组列的长度
        b[k++]=s[i][j];
  *n=k;//一位数组元素的个数（用于输出计算）  
}

【4】字符串数字字符顺序前移，返回新字符串的首地址

isdigit(s[i])判断是否数字字符,是 值>0；isdigit() 用来检测一个字符是否是十进制数字。头文件为 <ctype.h>

char *fun(char  *s)
{ int  i, j, k, n;    char  *p, *t;
  n=strlen(s)+1;//字符串加结束符'\0'的长度
  t=(char*)malloc(n*sizeof(char));//动态分配n长度的内存空间
  p=(char*)malloc(n*sizeof(char));
  j=0; k=0;
  for(i=0; i<n; i++)
  {  if(isdigit(s[i])) {//判断是否数字字符
       p[j]=s[i]; j++;}//p指向的空间存放数字字符
     else
     {  t[k]=s[i]; k++; }//t指向的空间存放非数字字符
   }
   for(i=0; i<k; i++) p[j+i]= t[i];//将非数字字符存放在数字字符之后
   p[j+k]=0;//字符串结束空字符
   return p;//返回新字符串的首地址
}

[5]先b字符串逆序排放，再a与b字符串字符交替存放到c

void fun( char  *a, char  *b, char  *c )
{
  int   i , j;     char   ch;
  i = 0;    j = strlen(b)-1;//j为b字符串最后一个字符的下标
  while ( i < j )//b字符串逆序排放
  {   ch = b[i]; b[i] = b[j]; b[j] = ch;
      i++;    j--;
  }
  while ( *a || *b ) {//a与b字符串字符交替存放到c
     if ( *a )
       { *c = *a;  c++; a++; }
     if ( *b )
       { *c = *b;  c++; b++; }
  }
  

[6]删除s所指字符串中满足下标为偶且ASCII值为奇的字符，再将余下字符存放t所指数组

void fun(char  *s, char  t[])
{
  int i, j = 0 ;
  for(i = 0 ; i < strlen(s) ; i++)//遍历s指向的字符串
    if(!(( % 2) ==0 && (s[i] % 2)==1)) //先判断满足下标为偶且ASCII值为奇再取反或（i % 2) ==1||(s[i] % 2)==0）
        t[j++] = s[i] ;//将满足条件的字符存放t指向的空间
  t[j] = 0 ;//空字符结束标志
}

[7]将M*N矩阵的将第0行与第k行元素交换

void fun(int (*a)[N], int k)
{ int i,temp ;
  for(i = 0 ; i < N ; i++)//将第0行与第k行交换
  { temp=a[0][i] ;
    a[0][i] = a[k][i] ;
    a[k][i] = temp; 
  }
}

[8]读入字符串，将字符按ASCII码值升序排序

void fun(char  t[])
{
 char c;
 int i,j;
for(i=strlen(t)-1; i; i--)//i的初始值为最后一个字符的下标
     for(j=0;j<i;j++)
	  if (t[j] > t[j+1])//冒泡排序
          {
           c= t[j];
           t[j]=t[j+1];
           t[j+1]=c;
          }
}

[9]将ss所指字符串中所有下标为奇数位置的字母转换为大写（不是字母则不变）

void fun(char *ss)
{
 int i;
  for(i=0;ss[i]!='\0';i++)//遍历ss字符串到空字符'\0'    
     if(i%2==1&&ss[i]>='a'&&ss[i]<='z')//下标为奇且为小写字母   
        ss[i]=ss[i]-32;//小写字母的ASCII值减32为大写字母的ASCII值
}

[10]将矩阵的第k列元素左移到第0列，第k列以后元素依次左移，原来左边的各列依次绕到右边 

void fun(int  (*a)[N],int  k)
{ int  i,j,p,temp;
  for(p=1; p<= k; p++)//循环向左移动k次
     for(i=0; i<M; i++)//每行移动相同操作
     {  temp=a[i][0];//将每行第一个元素放temp
        for(j=0; j< N-1 ; j++) //因j+1，j只能遍历到N-2
            a[i][j]=a[i][j+1];
        a[i][N-1]= temp;//将temp中元素放最后一列的空间
     }
}

[11]m*m数组，元素的值为数组元素下标加1的积

void fun(int a[][M], int m)//N*N数组的表达a[][N]和(*a)[N]
{  int j, k ;
   for (j = 0 ; j < m ; j++ )
        for (k = 0 ; k < m ; k++ )
          a[j][k] = (k+1)*(j+1) ;//元素的值为数组元素下标加1的积
}

[12]a与b合并成c例 a=45,b=12,c=5241

void fun(int  a, int  b, long  *c)
{  
    *c=(a)*1000+(b)*100+(a/10)*10+(b/10);
}

【13】在矩阵中找出在行上最大在列上最小的与元素

void fun(int  (*a)[N])
{ int  i=0,j,find=0,rmax,c,k;//find为标志位
  while( (i<M) && (!find))//循环条件在矩阵中且未找到
  {  
      rmax=a[i][0];  c=0;//假设rmax，c为rmax的例下标
     for(j=1; j<N; j++)//遍历的i行元素找最大值
       if(rmax<a[i][j])
       {
         rmax=a[i][j]; c= j ;
       }
     find=1; k=0;//标志位置1，k为行下标
     while(k<M && find) //判断rmax是否为该列最小
     {
       if (k!=i && a[k][c]<=rmax) //若rmax不是该列最小
           find= 0 ;//find置0
       k++;
     }
     if(find)//find=1，输出
         printf("find: a[%d][%d]=%d\n",i,c,a[i][c]);
      i++ ;
  }
  if(!find)//find=0，输出
      printf("not found!\n");
}

[14]计算t=1-1/(2*2)-1/(3*3)......-1/(m*m)

double fun ( int m )
{  double   y = 1.0 ;
   int  i ;
   for(i = 2 ; i <= m ; i++)//m参与计算所i<=m
      y -= 1.0/(i * i) ;//除数或被除数为double型结果为double型
   return( y ) ;
}

【15】一组成绩，计算低于平均分的个数，并将低于平均分的分数放另一个数组

int fun(int score[],int m, int below[])
{
  int i,j=0;
  float av=0.0;
  for(i=0;i<m;i++)
     av=av+(float)score[i]/m;   /*求平均值*/
  for(i=0;i<m;i++)
     if(score[i]<av)/*如果分数低于平均分，则将此分数放入below数组中*/
        below[j++]=score[i];
  return j;       /*返回低于平均分的人数*/
}}

【16】

将字符串s最右边n个字符复制到t数组中

strcpy(t,s) ：t为目的串，s为源串；作用将源串s拷贝的目的串t（到 s中的空字符（包括空字符）为止）

void fun(char  *s, int  n, char  *t)
{ int len,i,j=0;
  len=strlen(s);//s串的长度（不包括空字符）
  if(n>=len) strcpy(t,s);//n大于s串的长度
  else {//小于时
     for(i=len-n; i<=len-1; i++)  t[j++]= s[i] ;//i=len-n：从右开始向左第n个元素的下标
     t[j]= 0 ;//空字符（结束标志）
  }
}

【17】找出一个大于给定整数m且紧跟m的素数，并返回

int fun( int m)
{ int i,k;
  for (i=m+1; ;i++)//从m的后一个数开始直到找到
     { for (k=2;k<i;k++)//判断是否素数
          if (i%k==0)
          break;//结束循环
        if (k>=i)//满足条件，是素数
        return(i);//返回素数
     }
}

【18】求出能整除x且不是偶数的个整数

void fun (int x, int pp[], int *n)
{
	int i,j=0;
	for(i=1;i<=x;i=i+2)/*i的初始值为1，步长为2，确保i为奇数*/
		if(x%i==0)/*将能整除x的数存入数组pp中*/
		pp[j++]=i;
	*n=j;/*传回满足条件的数的个数*/
}

【19】是否回文，如“LEVEL”

int fun(char  *s)
{ char  *lp,*rp;
  lp= s ;//指向s串的第一个元素
  rp=s+strlen(s)-1;//指向s串的最后一个元素
  while((toupper(*lp)==toupper(*rp)) && (lp<rp) ) {
     lp++; rp -- ; }
  if(lp<rp) return 0 ;//不是回文
  else   return 1;//是
}

【20】求数列前n项和2/1，3/2，5/3...

double fun(int n)//返回值类型double
{ int a,b,c, k;
  double s;
  s=0.0;a=2;b=1;
  for(k=1;k<=n;k++)
     {
      s=s+(double)a/b;//累加
      c=a;a=a+b;b=c;//下一项的分子和分母
     }
  return s;//返回结果
}

【21】找出k个大于给定整数m的素数，并存放数组

void fun(int m,int k,int xx[])
{
  int i,j,n;
  for(i=m+1,n=0;n<k;i++)     /*找大于m的素数，循环k次，即找出紧靠m的k个素数*/
     {for(j=2;j<i;j++)       /*判断一个数是否为素数，如果不是，跳出此循环，判断下一个数*/
        if(i%j==0) break;
      if(j>=i)               /*如果是素数，放入数组xx中*/
         xx[n++]=i;
    }
}

【22】计算字符串s中包含的单词个数，并返回

int fun(char  *s)
{ int  n=0, flag=0;
  while(*s!='\0')//到空字符结束循环
  { if(*s!=' ' && flag==0) {//满足条件为单词第一个字符
     n++ ;  flag=1;}//单词个数加一
    if (*s==' ')  flag= 0 ;//空格flag置0
    s++ ;//指针后移
  }
  return  n;
}

【23】一组成绩，计算低于平均分的个数返回，并将平均分放形参

int fun(float *s, int n,float *aver)//n为学生个数
{ float ave ,t=0.0;
  int count=0,k,i;
  for(k=0;k<n;k++)
      t+=s[k];//n个学生成绩之和
  ave=t/n;//平均分
  for(i=0;i<n;i++)
      if(s[i]<ave) count++;//低于平均分的个数
  *aver=ave;//将平均分放形参
  return count;//个数返回
}

【24】求数组最大元素的下标并存放k所指向的单元

int fun(int *s,int t,int *k)//t为数组元素个数
{
   int i;
  *k=0;                                                                            /*k所指的数是数组的下标值*/
  for(i=0;i<t;i++)
     if(s[*k]<s[i]) *k=i;                           /*找到数组的最大元素，把该元素的下标赋给k所指的数*/
  return s[*k];                                                                      /*返回数组的最大元素*/
}/}