精华内容
下载资源
问答
  • 100道经典例题包含答案,做完收获很大,适合掌握了C语言基本语法以后想做练习的同学学习
  • C语言经典例题100道

    2018-08-12 14:34:36
    C语言经典例题100道,包含题目和答案,比较基础,适合做一做。
  • C语言经典例题100-小甲鱼C语言视频教程中推荐的C语言例题
  • 100个经典例题(C语言)

    2020-05-17 01:06:30
    此资源为C语言例题,是C语言,不是C++,有需要的朋友可以下载 。
  • 答案自己做的 都测试了的 就最后两道没做(一道链表嫌麻烦,一道子串是java里的概念)
  • C语言经典例题整理

    千次阅读 多人点赞 2020-04-05 14:53:43
    } } } } 归并排序 算法原理   归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而**治...

    1 加法器与累乘器

    代码

    累加器

    #include<stdio.h>
    int main (void)
    {
    int i;
    int sum=0;
    for(i=1;i<=100;i++)
    {
    sum=sum+i;
    }
    printf("%d.\n",sum);
    return 0;
    }
    

    累乘器:

    #include<stdio.h>
    int main (void)
    {
    int i;
    int p=1;
    for(i=2;i<=100;i++)
    {
    p=p*i;
    }
    printf("%d.\n",p);
    return 0;
    }
    

    2 求最大数与最小数

    题目描述

      输入5个数

    样例输入

    21 12 5 78 485
    

    样例输出

    max:485 min:5
    

    代码

    #include <stdio.h>
    int main(){
    	int a[5],max,min,i;
    	for(i=0;i<5;i++){
    		scanf("%d",&a[i]);
    	}
    	max=a[0];
    	min=a[0];
    	for(i=1;i<5;i++){
    		if(a[i]>max){
    			max=a[i];
    		}
    		if(a[i]<min){
    			min=a[i];
    		}
    	}
    	printf("max:%d min:%d\n",max,min);
    	return 0;
    }
    

    3 排序算法

    冒泡排序

    算法原理

      它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。

    题目描述

      输入10个数,从小到大排序

    样例输入

    15 23 2 6 9 46 75 6 8 10
    

    样例输出

    2 6 6 8 9 10 15 23 46 75
    

    代码

    #include <stdio.h>
    void bubleSort(int a[]);
    int main(){
    	int a[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	bubleSort(a);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    void bubleSort(int a[]){
    	int i,j,temp;
    	for(i=0;i<10-1;i++){    //外循环为排序趟数,len个数进行len-1趟
    		for(j=0;j<10-i-1;j++){  //内循环为每趟比较的次数,第i趟比较len-i次
    			if(a[j]>a[j+1]){
    				temp=a[j+1];
    				a[j+1]=a[j];
    				a[j]=temp;
    			}
    		}
    	}
    }
    

    选择排序

    算法原理

      第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。

    代码

    #include <stdio.h>
    void select_Sort(int a[], int len);
    int main(){
    	int a[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	select_Sort(a, 10);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    void select_Sort(int a[], int len){
    	int i,j,min,temp;
    	for(i=0;i<len-1;i++){
    		min=i;  //每一趟找出最小值的下标
    		for(j=i+1;j<len;j++){
    			if(a[j]<a[min]){
    				min=j;
    			}
    		}
    		if(min!=i){
    			temp=a[min];
    			a[min]=a[i];
    			a[i]=temp;
    		}
    	}
    }
    

    插入排序

    算法原理

      主要的实现思想是将数据按照一定的顺序一个一个的插入到有序的表中,最终得到的序列就是已经排序好的数据。

    代码

    #include <stdio.h>
    void Insert_Sort(int a[], int len);
    int main(){
    	int a[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	Insert_Sort(a, 10);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    void Insert_Sort(int a[], int len){
    	int i,j;
    	int temp;
    	//开始时只有第一项,有序;从第二项开始即可 
    	for(i=1;i<len;i++){
    		temp=*(a+i);
    		//若前一项比插入的项大,则前一项后移 
    		for(j=i;j>0&&*(a+j-1)>temp;j--){
    			*(a+j)=*(a+j-1);
    		}
    		*(a+j)=temp;
    	}
    }
    

    希尔排序

    算法原理

    image-20200316124012165

    代码

    #include <stdio.h>
    void Shell_Sort(int a[], int len);
    int main(){
    	int a[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	Shell_Sort(a, 10);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    void Shell_Sort(int a[], int len){
    	int gap,i,j,k,temp;
    	// 步长初始化为数组长度的一半,每次遍历后步长减半
    	for(gap=len/2;gap>=1;gap/=2){
    		//分组插入排序  
    		for(i=0;i<gap;i++){
    			for(j=i+gap;j<len;j+=gap){
    				temp=a[j];
    				for(k=j;k>j%gap&&a[k-gap]>temp;k-=gap){
    					a[k]=a[k-gap];
    				}
    				a[k]=temp;
    			}
    		}
    	}
    }
    

    归并排序

    算法原理

      归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题(divide)成一些小的问题然后递归求解,而**治(conquer)**的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。

    img

    • https://www.cnblogs.com/chengxiao/p/6194356.html

    代码

    #include <stdio.h>
    //合 
    void Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex)
    {
        int i = startIndex, j=midIndex+1, k = startIndex;
        while(i!=midIndex+1 && j!=endIndex+1)
        {
            if(sourceArr[i] > sourceArr[j])
                tempArr[k++] = sourceArr[j++];
            else
                tempArr[k++] = sourceArr[i++];
        }
        while(i != midIndex+1)
            tempArr[k++] = sourceArr[i++];
        while(j != endIndex+1)
            tempArr[k++] = sourceArr[j++];
        for(i=startIndex; i<=endIndex; i++)
            sourceArr[i] = tempArr[i];
    }
    //内部使用递归
    void Merge_Sort(int sourceArr[], int tempArr[], int startIndex, int endIndex)
    {
        int midIndex;
        if(startIndex < endIndex)
        {
            midIndex = startIndex + (endIndex-startIndex) / 2;//避免溢出int
            Merge_Sort(sourceArr, tempArr, startIndex, midIndex);
            Merge_Sort(sourceArr, tempArr, midIndex+1, endIndex);
            Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);
        }
    }
    int main(){
    	int a[10],b[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	Merge_Sort(a, b, 0, 9);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    

    快速排序

    算法原理

    image-20200317133844661

    • https://blog.51cto.com/13733462/2113397

    代码

    #include <stdio.h>
    void QuickSort(int a[],int left,int right);
    int main(){
    	int a[10],i;
    	for(i=0;i<10;i++){
    		scanf("%d",&a[i]);
    	}
    	QuickSort(a,0,9);
    	for(i=0;i<10;i++){
    		printf("%d ",a[i]);
    	}
    }
    void QuickSort(int a[],int left,int right){
    	if(left>=right){
    		return;
    	}
    	int i=left,j=right;
    	int key=a[left];
    	while(i<j){
    		while(i<j&&key<=a[j]){
    			j--;
    		}
    		a[i]=a[j];
    		while(i<j&&key>=a[i]){
    			i++;
    		}
    		a[j]=a[i];
    	}
    	a[i]=key;
    	QuickSort(a,left,i-1);
    	QuickSort(a,i+1,right);
    }
    

    4 大小写字母转换

    样例输入

    aBujZx
    

    样例输出

    ABUJZX
    

    代码

    #include <stdio.h>
    void toupper(char a[]);
    int main(){
    	char a[50];
    	scanf("%s", a);
    	toupper(a);
    	printf("%s", a);
    }
    void toupper(char a[]){
    	int i=0;
    	while(a[i]!='\0'){
    		if('a'<=a[i]&&a[i]<='z'){
    			a[i]=a[i]-32;
    		}
    		i++;
    	}
    }
    

    5 统计字符串中的字母,数字,空格,其他个数

    样例输入

    aBcd48_@ 653
    

    样例输出

    字母有: 4 个
    数字有: 5 个
    空格有: 1 个
    其他有: 2 个
    

    代码

    #include <stdio.h>
     
    int main(void)
    {
    	char ch;
    	int zimu, shuzi, kongge, other;
    	zimu = shuzi = kongge = other = 0;
     
    	 while( ( ch = getchar() ) != '\n')
    	 {
    		if ( (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') )
    		{
    			zimu++;
    		
    		}
    		else if( ch >= '1' && ch <= '9')
    		{
    			shuzi++;
    		
    		}
    		else if( ch == ' ')
    		{
    			kongge++;
    		
    		}
    		else
    		{
    			other++;
    		}
    	 }
     
    	printf("字母有: %d 个\n", zimu);
    	printf("数字有: %d 个\n", shuzi);
    	printf("空格有: %d 个\n", kongge);
    	printf("其他有: %d 个\n", other);
    	printf("\n");
    	return 0;
    }
    

    6 判断闰年

    样例输入

    1900
    2004
    

    样例输出

    1900 year is not leap year
    2004 year not leap year
    

    代码

    #include <stdio.h>
    int main(){
    	int year;
    	scanf("%d",&year);
    	if((year%4==0 && year%100!=0) || year%400==0){  //判断闰年的条件
    		printf("%d year is leap year\n", year);
    	}
    	else{
    		printf("%d year is not leap year\n", year);
    	}
    	return 0;
    }
    

    7 百分制成绩和等级制成绩转换

    题目描述

    代码

    #include <stdio.h>
    int main(){
    	int score;
    	char result;
    	do{
    		scanf("%d",&score);
    	}while(score<0 || score>100);
    	switch((int)(score/10)){
    		case 10:                    //注意switch case语句使用,case仅能常量
    		case 9:result='A';break;
    		case 8:result='B';break;
    		case 7:result='C';break;
    		case 6:result='D';break;
    		default:result='E';
    	}
    	printf("%c",result);
    	return 0;
    }
    

    8 求两数最大公因数和最小公倍数(辗转相除法/欧几里得算法)

    算法原理

    样例输入

    3139 2117
    

    样例输出

    最大公约数 73,最小公倍数 91031
    

    代码

    #include <stdio.h>
    int main(){
    	int a,b,m,n,o;
    	scanf("%d%d",&a,&b);
    	m=a;
    	n=b;
    	if(a<b){    //a<b则交换顺序
    		m=b;
    		n=a;
    	}
    	while(n!=0){    //辗转相除法
    		o=m%n;
    		m=n;
    		n=o;
    	}
    	printf("最大公约数 %d,最小公倍数 %d\n",m,a*b/m);    //最小公约数最小公倍数关系
    	return 0;
    }
    

    9 求斐波拉契数列有限项(递归应用)

    样例输入

    9
    

    样例输出

    34
    

    代码

    #include <stdio.h>
    int Fibonacci(int n);
    int main(){
    	int n;
    	scanf("%d",&n);
    	printf("%d",Fibonacci(n));
    }
    int Fibonacci(int n){
    	if(n==1 || n==2){
    		return 1;
    	}
    	else{
    		return Fibonacci(n-1)+Fibonacci(n-2);
    	}
    }
    

    10 验证哥德巴赫猜想(素数验证应用)

    题目描述

      数学领域著名的“哥德巴赫猜想”的大致意思是:任何一个大于2的偶数总能表示为两个素数之和。比如:24=5+19,其中5和19都是素数。本实验的任务是设计一个程序,验证20亿以内的偶数都可以分解成两个素数之和。

    样例输入

    42
    

    样例输出

    42 = 5 + 37
    

    代码

    #include <stdio.h>
    #include <math.h>
    bool is_prime(int num);
    int main(){
    	int n,i;
    	scanf("%d",&n);
    	for(i=2;i<n;i++){
    		if(is_prime(i) && is_prime(n-i)){
    			printf("%d = %d + %d\n",n,i,n-i);
    			break;
    		}
    	}
    	return 0;
    }
    bool is_prime(int num){
    	int i,k;
    	k=sqrt(num);
    	for(i=2;i<=k;i++){  //素数验证可简化为仅需判断是否能够被 2~√n 之间整数整除即可
    		if(num%i==0)break;
    	}
    	if(i<=k){
    		return false;
    	}
    	else
    		return true;
    }
    

    11 水仙花数

    题目描述

    样例输出

    153 370 371 407
    

    代码

    #include <stdio.h>
    #include <math.h>
    int main(){
    	int i,ge,shi,bai;
    	for(i=100;i<=999;i++){
    		ge=i%10;
    		shi=(i%100)/10;
    		bai=i/100;
    		if(i==pow(ge,3)+pow(shi,3)+pow(bai,3)){
    			printf("%d ",i);
    		}
    	}
    	return 0;
    }
    

    12 完全平方数

    题目描述

      一个整数,它加上100 后是一个完全平方数,再加上168 又是一个完全平方数,请问该数是多少?

      完全平方数:开方之后是整数
    样例输出

    21 261 1581
    

    代码

    #include <stdio.h>
    #include <math.h>
    int main(){
    	int i,num1,num2;
    	for(i=0;i<100000;i++){
    		num1=i+100;
    		num2=num1+168;
    		if(sqrt(num1)==(int)sqrt(num1) && sqrt(num2)==(int)sqrt(num2)){
    			printf("%d ",i);
    		}
    	}
    	return 0;
    }
    

    13 完数

    题目描述

      它所有的真因子(即除了自身以外的约数)的和(即因子函数),恰好等于它本身,1 不是完数
    样例输出

    6 is factors are 1 2 3
    28 is factors are 1 2 4 7 14
    496 is factors are 1 2 4 8 16 31 62 124 248
    

    代码

    #include <stdio.h>
    #include <math.h>
    int main(){
    	int i,j,s;
    	for(i=2;i<=1000;i++){
    		s=0;
    		for(j=1;j<i;j++){
    			if(i%j==0){
    				s+=j;
    			}
    		}
    		if(s==i){
    			printf("%d is factors are ",i);
    			for(j=1;j<i;j++){
    				if(i%j==0){
    					printf("%d ",j);
    				}
    			}
    			printf("\n");
    		}
    	}
    	return 0;
    }
    

    14 梯形法求定积分近似值

    题目描述

      求函数X^2的定积分近似值

    样例输入

    0 1
    

    样例输出

    0.353804
    

    代码

    #include <stdio.h>
    #include <math.h>
    float seekSimilar(float a,float b,int n);
    float func(float x);
    int main(){
    	float a,b;
    	scanf("%f%f",&a,&b);
    	printf("%f", seekSimilar(a,b,50));
    }
    float seekSimilar(float a,float b,int n){
    	float h,i,s=0;
    	h=(b-a)/n;	//将区间划为n份 
    	for(i=a;i<b;i+=h){
    		s+=(func(i)+func(i+h))*h/2;
    	}
    	return s;
    }
    float func(float x){
    	return pow(x,2);
    }
    

    15 牛顿迭代法求多元方程根

    题目描述


    样例输出

    2.000000
    

    代码

    #include <stdio.h>
    #include <math.h>
    int main(){
    	double x0,x1,f,f1;
    	x1=1.5;
    	do{
    		x0=x1;
    		f=2*pow(x0,3)-4*pow(x0,2)+3*x0-6;
    		f1=6*pow(x0,2)-8*x0+3;
    		x1=x0-f/f1;
    	}while(fabs(x1-x0)>=1e-5);  //注意判断条件
    	printf("%f\n",x1);
    	return 0;
    }
    

    16 二分法求多次方根

    题目描述


    样例输入

    enter x1,x2:-10,10
    

    样例输出

    x=  2.00
    

    代码

    #include <stdio.h>
    #include <math.h>
    int main(){
    	float x1,x2,x0,f1,f2,f0;
    	do{
    		printf("enter x1,x2:"); 
    		scanf("%f,%f",&x1,&x2);
    		f1=2*pow(x1,3)-4*pow(x1,2)+3*x1-6;
    		f2=2*pow(x2,3)-4*pow(x2,2)+3*x2-6;
    	}while(f1*f2>0);
    	do{
    		x0=(x1+x2)/2;
    		f0=2*pow(x0,3)-4*pow(x0,2)+3*x0-6;
    		if(f0*f1<0){
    			x2=x0;
    			f2=f0;
    		}
    		else{
    			x1=x0;
    			f1=f0;
    		}
    	}while(fabs(x1-x2)>=1e-5);
    	printf("x=%6.2f", x0);
    	return 0;
    }
    

    17 求两个矩阵相乘

    样例输入

    输入第一个矩阵:
    1 2
    3 4
    5 6
    输入第二个矩阵:
    7 8 9
    10 11 12
    

    样例输出

       27   30   33
       61   68   75
       95  106  117
    

    代码

    #include <stdio.h>
    #define X 3
    #define Y 2
    #define Z 3
    int main(){
    	int a[X][Y],b[Y][Z],c[X][Z];
    	int i,j,k;
    	printf("输入第一个矩阵:\n");
    	for(i=0;i<X;i++){
    		for(j=0;j<Y;j++){
    			scanf("%d", &a[i][j]);
    		}
    	}
    	printf("输入第二个矩阵:\n");
    	for(i=0;i<Y;i++){
    		for(j=0;j<Z;j++){
    			scanf("%d", &b[i][j]);
    		}
    	}
    	printf("矩阵相乘结果:\n");
    	for(i=0;i<X;i++){
    		for(j=0;j<Z;j++){
    			c[i][j]=0;
    			for(k=0;k<Y;k++){
    				c[i][j] += a[i][k]*b[k][j]; //相乘的时候注意下标
    			}
    		}
    	}
    	for(i=0;i<X;i++){
    		for(j=0;j<Z;j++){
    			printf("%5d", c[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }
    

    18 利润利息计算


    代码

    //利息计算
    #include <stdio.h>
    #include <math.h>
    
    int main(){
    	double P1, P2, P3, P4, P5;
    	
    	P1 = 1000*(1+5*0.0585);
    	P2 = (1000*(1+2*0.0468))*(1+3*0.054);
    	P3 = (1000*(1+3*0.054))*(1+2*0.0468);
    	P4 = 1000*pow(1+0.0414, 5);
    	P5 = 1000*pow(1+0.0072/4, 5*4);
    	
    	printf("%f\n%f\n%f\n%f\n%f\n", P1, P2, P3, P4, P5);
    	return 0;
    }
    

    19 年月日判断是年份的第几天

    样例输入

    Please input year/mouth/day:2000/4/2
    

    样例输出

    its 93 day
    

    代码

    #include <stdio.h>
    int main(){
    	int mon[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    	int year,mouth,day,num,i;
    	printf("Please input year/mouth/day:");
    	scanf("%d/%d/%d",&year,&mouth,&day);
    	if((year%4==0 && year%100!=0) || (year%400==0)){
    		mon[1]=29;
    	}
    	num=day;
    	for(i=0;i<mouth-1;i++){
    		num += mon[i];
    	}
    	printf("its %d day\n",num);
    	return 0;
    }
    

    20 图形输出

    //图形输出问题
    //分成两部分来看,找每一行空格,*和行号的规律
    //注意输出一行后记得输出\n
    #include <stdio.h>
    int main(){
      int i,j,k;
      for(k=1;k<=4;k++){
      	for(i=1;i<=4-k;i++){
      		printf(" ");
    	  }
    	for(j=1;j<=2*k-1;j++){
    		printf("*");
    	}
    	printf("\n");
      }
      for(k=1;k<=3;k++){
      	for(i=1;i<=k;i++){
      		printf(" ");
    	}
    	for(j=1;j<=2*(3-k)+1;j++){
    		printf("*");
    	}
    	printf("\n");
      }
      return 0;
     }
    

    21 输出乘法表

    样例输出

    1×1=1
    2×1=2    2×2=4
    3×1=3    3×2=6    3×3=9
    4×1=4    4×2=8    4×3=12   4×4=16
    5×1=5    5×2=10   5×3=15   5×4=20   5×5=25
    6×1=6    6×2=12   6×3=18   6×4=24   6×5=30   6×6=36
    7×1=7    7×2=14   7×3=21   7×4=28   7×5=35   7×6=42   7×7=49
    8×1=8    8×2=16   8×3=24   8×4=32   8×5=40   8×6=48   8×7=56   8×8=64
    9×1=9    9×2=18   9×3=27   9×4=36   9×5=45   9×6=54   9×7=63   9×8=72   9×9=81
    

    代码

    #include "stdio.h"
    main(){
    	int i,j;
    	for(i=1;i<10;i++){
    		for(j=1;j<=i;j++){
    			printf("%d×%d=%-5d",i,j,i*j);
    		}
    		printf("\n");
    	}
    	return 0;
    }
    

    22 兔子问题(斐波那契数列应用)

    题目描述

      有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?

    代码

    #include <stdio.h>
    int Fibonacci(int n);
    int main(){
    	int n;
    	scanf("%d",&n);
    	printf("%d",Fibonacci(n));
    }
    int Fibonacci(int n){
    	if(n==1 || n==2){
    		return 1;
    	}
    	else{
    		return Fibonacci(n-1)+Fibonacci(n-2);
    	}
    }
    

    23 分解质因数

    代码

    #include <stdio.h>
    #include <stdlib.h>
    //将一个正整数分解质因数
    int main()
    {
        int i,n;
        printf("Please input an integer!\n");
        scanf("%d",&n);
        for(i=2;i<=n;i++)
        {
            while(n!=i)     //若i=n,则质因数就是n本身
            {
                if(n%i==0)  //若i是质因数,则打印出i的值,并用商给n赋新值
                {
                    printf("%d\n",i);
                    n=n/i;
                }
                else break;//若不能被i整除,则算下一个i
            }
        }
        printf("%d\n",n);   //这里是打印最后一个质因数,也就是等于i时的那个
        return 0;
    }
    

    24 求sn=a+aa+aaa+aaaa+aa…a


    代码

    //注意an的求法
    #include <stdio.h>
    int main(){
    	int a,n,i=1,result=0,an=0;
    	printf("a,n:");
    	scanf("%d,%d",&a,&n);
    	while(i<=n){
    		an=an+a;
    		printf("%d\n",an);
    		result=result+an;
    		a=a*10;
    		i++;
    	}
    	printf("a+aa+aaa+ …=%d\n",result);
    	return 0;
    }
    

    25 小球下落问题

    题目描述

      一球从100 米高度自由落下,每次落地后反跳回原高度的一半;再落下,求它在第10次落地时,共经过多少米?第10 次反弹多高?

    样例输出

    Total 299.609375
    h10 is 0.097656
    

    代码

    #include <stdio.h>
    #include <stdlib.h>
     
    int main()
    {
        int i;
        double sn=100;
        double hn=sn/2;
        for(i=2;i<=10;i++)
        {
            sn+=2*hn;
            hn/=2;
        }
        printf("Total %lf\n",sn);
        printf("h10 is %lf\n",hn);
        return 0;
    }
    

    26 比赛排序


    //比赛排序问题
    //先逻辑图,判断出正确结果
    //编程使用假设的方法,三层循环,判断符合条件的情况
    #include <stdio.h>
    int main(){
      char i,j,k;
      for(i='X';i<='Z';i++){
      	for(j='X';j<='Z';j++){
      		if(i!=j){
      			for(k='X';k<='Z';k++){
      				if(k!=i&&k!=j){
      					if(i!='X'&&k!='X'&&k!='Z'){
      						printf("A-%c,B-%c,C-%c\n",i,j,k);
    					  }
    				  } 
    			  }
    		  }
    	  }
      }
      return 0;
     }
    

    27 阶乘的和

    代码

    #include <stdio.h>
    #include <stdlib.h>
    //求1到20的阶乘的和
    int main()
    {
        int i,j;
        long int sum,n;
        sum=0;
        for(i=1;i<=20;i++)
        {
            n=1;
            for(j=1;j<=i;j++)
               n*=j;
            //循环后的n为i!
            sum+=n;
        }
        printf("Sum is %ld!\n",sum);
        return 0;
    }
    

    28 递归逆序输出字符

    代码

    //注意,一定要在putchar()之前调用递归函数,另外注意:getchar()是从输入流中获取一个字符,所以输入的时候格式就是abcde,并非像scanf那样输入一个字符后,按回车或者Tab后再输入下一个字符。
    #include <stdio.h>
    
    void print(int);
    int main()
    {
        printf("Input chars:\n");
        print(5);
        printf("\n");
        return 0;
    }
    void print(int n)
    {
        char c;
        if(n==1){
        	c=getchar();
        	printf("Output:\n");
        	putchar(c);
    	}
    	else{
    		c=getchar();
    		print(n-1);
    		putchar(c);
    	}
    }
    

    29 求一个整数的位数且逆序打印

    样例输入

    Please input an integer!
    789456
    

    样例输出

    654987
    It contains 6 digits!
    

    代码

    #include <stdio.h>
    #include <stdlib.h>
    int digits(int n);
    int main()
    {
        int i;
        printf("Please input an integer!\n");
        scanf("%d",&i);
        printf("It contains %d digits!\n",digits(i));
        return 0;
    }
    int digits(int n){
    	int d=0;
    	while(n>0){
    		printf("%d", n%10);
    		n /= 10;
    		d++;
    	}
    	printf("\n");
    	return d;
    }
    

    30 判断回文数

    样例输入

    12121
    

    样例输出

    12121 是回文数
    

    代码

    //思路:反着排一遍,如果和原数相同则为回文数
    #include <stdio.h>
    
    bool huiwenshu(int num);
    int main(){
        int num;
        scanf("input a interger:");
        scanf("%d",&num);
        if(huiwenshu(num)){
        	printf("%d 是回文数", num);
    	}
    	else{
    		printf("%d 不是回文数", num);
    	}
    	return 0; 
    }
    bool huiwenshu(int num){
    	int s,y=0;
    	s=num;
    	while(s>0){
    		y=y*10+s%10;
    		s /= 10;
    	}
    	if(y==num)
    		return true;
    	else
    		return false;
    }
    

    31 判断字符串是否为回文

    样例输入

    abcdcba
    

    样例输出

    是回文
    

    代码

    #include <stdio.h>
    #include <string.h>
    
    bool  huiwen(char *str, int len);
    int main(){
        char str[20];
        scanf("input a string:");
    //    scanf("%s",&str);
    	gets(str);
    	if(huiwen(str, strlen(str))){
    		printf("是回文"); 
    	}
    	else{
    		printf("不是回文");
    	}
    	return 0;
    }
    bool  huiwen(char *str, int len){
    	int i;
    	for(i=0;i<len;i++){
    		if(str[i]!=str[len-i-1]){
    			return false;
    		}
    	}
    	return true;
    }
    

    32 顺序队列中插入新元素

    代码

    #include <stdio.h>
    #include <stdlib.h>
     
    int main()
    {
        int a[11]={1,2,4,7,9,13,18,24,32,45};
        int i,num,pos=0;
        scanf("%d",&num);
        if(num>=a[9])
            a[10]=num;
        while(a[i]<num)     //找到第一个不比num小的元素的位置
        {
            i++;
            pos++;
        }
        for(i=10;i>pos;i--) //将该元素及之后所有元素右移一位
            a[i]=a[i-1];
        a[pos]=num;         //给新元素安排位置
        for(i=0;i<11;i++)
            printf("%4d",a[i]);
        return 0;
    }
    

    33 杨辉三角形

    代码

    #include <stdio.h>
    # define N 10
    int main(){
      int i,j,a[N][N];
      for(i=0;i<N;i++){
      	a[i][i]=1;
      	a[i][0]=1;
      }
      for(i=2;i<N;i++){
      	for(j=1;j<=i-1;j++){
      		a[i][j]=a[i-1][j]+a[i-1][j-1];
    	  }
      }
      for(i=0;i<N;i++){
      	for(j=0;j<=i;j++)
      		printf("%6d", a[i][j]);
      	printf("\n");
      }
      return 0;
     }
    

    34 约瑟夫环问题

    题目描述

      一堆猴子都有编号,编号是1,2,3 …m,这群猴子(m个)按照1-m的顺序围坐一圈,从第1开始数,每数到第N个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。

    样例输入

    请输入猴子的总数:6
    请输入循环单位:5
    

    样例输出

    它出列了:5
    它出列了:4
    它出列了:6
    它出列了:2
    它出列了:3
    最终大王是他:1
    

    代码

    #include <stdio.h>
    #define MAX_SIZE 50
    
    int main(){
    	int Monkey[MAX_SIZE];
    	int total_num,num,n,i,count,pos;
    	printf("请输入猴子的总数:");
    	scanf("%d", &total_num);
    	printf("请输入循环单位:");
    	scanf("%d", &n);
    	for(i=0;i<total_num;i++){
    		Monkey[i]=i+1;
    	}
    	count=0;
    	pos=0;
    	num=total_num;
    	while(num!=1){
    		if(Monkey[pos]!=0){
    			count++;
    		}
    		if(count==n){
    			Monkey[pos]=0;
    			num--;
    			printf("它出列了: %d\n",pos+1);
    			count=0;
    		}
    		pos++;
    		if(pos==total_num){
    			pos=0;
    		}
    	}
    	pos=0;
    	while(Monkey[pos]==0){
    		pos++;
    	}
    	printf("最终大王是他:%d", pos+1);
    	return 0;
    } 
    

    35 八进制转十进制

    代码

    #include <stdio.h>
    
    int main()
    { char *p,s[6];int n;
    p=s;
    gets(p);
    n=0;
    while(*(p)!='\0')
    {n=n*8+*p-'0';
    p++;}
    printf("%d",n);
    return 0;
    }
    

    36 鸡兔同笼

    题目描述

      已知鸡和兔的总数量为n,总腿数为m,输入nm,依次输出鸡的数目和兔的数目。如果无解则输出No answer

    样例输入

    14 32
    

    样例输出

    12 2
    

    代码

    ///巧解,先算出鸡的数量再算兔子的数量,根据均>=0判断是否有解
    #include "stdio.h"
    int main() {
      int a,b,n, m;
      // a鸡的数量
      // b兔的数量
      // n鸡兔总数
      // m总脚数
      scanf("%d %d", &n,&m);
      a = (4 * n - m) / 2;//算出鸡的数量
      b = n - a;//算出兔的数量
    
      if (a <= 0 || b <= 0) {
      //结果小于等于0,答案不成立,无解
        printf("No answer");
      } else {
      //结果大于0
        printf("%d %d", a, b);
      }
      return 0;
    }
    

    37 三天打鱼两天晒网

    题目描述

      中国有句俗语叫“三天打鱼两天晒网”。某人从2010年1月1日起开始“三天打鱼两天晒网”,问这个人在以后的以后的某一天中是打鱼还是晒网。

    代码

    /*中国有句俗语“三天打鱼两天晒网”,
    有个人从2010年1月1日起开始“三天打鱼,两天晒网”
    问这个人在以后的某一天是“打鱼”还是“晒网”。*/ 
    
    #include<stdio.h>
    int main()
    {
    	int year,month,day;
    	int y=2010;
    	int sum=0;
    	int a[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};//建立一个有平年各月份天数的数组
    	printf("请按照年月日的顺序输入日期,中间用空格隔开\n");
    	scanf("%d""%d""%d",&year,&month,&day);//输入日期
    	while((year<2010)||(month<1||month>12)||(month==2&&(year%4!=0||year%400!=0)&&day>=29)||(day>a[month]))
    	{
    		printf("输入日期错误,请重新输入\n");
    		printf("请按照年月日的顺序重新输入日期,中间用空格隔开\n");
    		scanf("%d""%d""%d",&year,&month,&day);
    	}
    	//判断输入日期是否正确
    	for(y;y<year;y++)//用此循环加上相差年份所隔的天数。 
    	{
    		if((year%400==0)||(year%4==0&&year%100!=0))//判断此年份是否是闰年 
    		{
    			sum+=366;
    		}//是闰年,则总天数加上366. 
    		else
    		{
    			sum+=365;
    		}//是平年,总天数加上365 
    	}
    	for(int m=1;m<month;m++)//用此循环加上所隔月份的总天数 
    	{
    		sum+=a[m];
    		if(month==2&&((year%400==0)||(year%4==0&&year%100!=0))) 
    		{
    			sum+=1;
    		}//判断月份是否为闰年2月,若是2月,则总天数加一。
    	}
    	sum+=day;//总天数加上日 
    	if((sum%5==1)||(sum%5==2)||(sum%5==3))//用相隔总天数除以周期5,若余数为1,2,3,则此人打鱼。 
    	{
    	printf("这个人今天打鱼\n");
    	}
    	else//否则,这个人晒网
    	{
    	printf("这个人今天晒网\n"); 
    	}
    	return 0;
    }
    

    38 汉诺塔问题

    问题描述

    image-20200320150341382

      需要移动的次数是2n-1

    image-20200320151003876image-20200320151036509

    样例输入

    input the number of disks:3
    

    样例输出

    the step:
    A->C
    A->B
    C->B
    A->C
    B->A
    B->C
    A->C
    

    代码

    image-20200320151153771

    #include <stdio.h>
    
    void hannuo(int num,char one,char two,char three);
    void move(char a,char b);
    int main(){
    	int num;
    	printf("input the number of disks:");
    	scanf("%d", &num);
    	printf("the step:\n");
    	hannuo(num,'A','B','C');
    }
    
    void hannuo(int num,char one,char two,char three){
    	if(num==1){
    		move(one,three);
    	}
    	else{
    		hannuo(num-1,one,three,two);
    		move(one,three);
    		hannuo(num-1,two,one,three);
    	}
    }
    
    void move(char a,char b){
    	printf("%c->%c\n",a,b);
    }
    

    39 数组循环移位

    题目描述

    image-20200325101713838

    样例输入

    6 2
    1 2 3 4 5 6
    

    样例输出

    5 6 1 2 3 4
    

    代码

    方法一:递归的方法

    image-20200325103028994

    方法二:直接移位,大问题化小问题

    #include <stdio.h>
    #define MAX 10
    
    void ArrayRight(int a[],int n,int m);
    int main(){
    	int a[MAX],n,m;
    	int i;
    	scanf("%d%d",&n,&m);
    	for(i=0;i<n;i++){
    		scanf("%d",&a[i]);
    	}
    	ArrayRight(a,n,m);
    	for(i=0;i<n;i++){
    		printf("%d ",a[i]);
    	}
    }
    void ArrayRight(int a[],int n,int m){
    	int temp,k,i;
    	//总共移动m位 
    	for(k=0;k<m;k++){
    		temp=*(a+n-1);
    		for(i=n-1;i>=0;i--){
    			*(a+i)=*(a+i-1);
    		}
    		*a=temp;
    	}
    }
    

    40 线性表

    翔哥代码:

    /*
        适用于标准C
    	SeqList.c
    	V1.1
    	2016.9.12 wangx
    */
    #include <stdio.h>
    #include <stdlib.h>
    #define OK 1
    #define OVERFLOW 0
    #define LIST_INIT_SIZE 100
    #define LISTINCREMENT 10
    
    #define Elemtype char
    
    //公共错误码,项目组成员之间的共同约定
    #define MALLOC_ERROR  -1  
    #define NOTFIND  -2
    #define PARAM_ERROR -3
    #define REALLOC_ERROR  -4  
    //顺序表的结构定义
    typedef struct 
    {
    	Elemtype *pElem;    //动态模式,只定义了一个指针,未分配数据的存储空间。本例假设每个元素都是char型,此处是实际应用中每个元素可能会是结构体变量或者结构体指针
    	int iCount;         //当前长度
    	int iTotalLength;   //线性表的总长度
    }SeqList;               //定义一个新类型,顺序表的类型名称
    
    
    //你这个菜鸟的任务,就是写这个InitList()函数。本函数假设实参指针已经指向了一个SeqList类型的结构体变量
     int InitList(SeqList *pList)
     {
    	 pList->iCount=0; //初始时,一个元素都没有
    	 pList->iTotalLength= LIST_INIT_SIZE;  //初始时理论总长就是100个元素(假定值)
    	 pList->pElem= (Elemtype *)malloc( LIST_INIT_SIZE * sizeof(Elemtype));  //因为SeqList的定义中,elem只是一个指针,需要分配空间并让该指针指向这段空间。因为malloc可能迸发异常,所以实际中往往会放在try {} catch() {}结构中
    	 if (pList->pElem==NULL)
    	 {
    	 	 return MALLOC_ERROR;   //  返回一个非0值(通常是一个负数),表示本子函数非正常结束,以供主调函数识别和采取对应措施
    	 }
    	 return 0;                           //一般情况下,在实际工程开发中,基本上都默认函数返回值为0表示该函数运行期间没有异常情况
     }
    
    //根据元素的值x,在顺序表pList中,查找其第一次出现的位置下标,并返回(注意,下标可以为0)。如果没找到,则返回NOTFIND,即-2
    int SearchByValue(SeqList *pList, Elemtype Value)
    {
    	int pos=0;
    	//重要的步骤,参数校验!一定别忘了!如果Value有一定的现实含义,则还需要对其做参数有效性校验
    	if (pList==NULL)
    	{
    		return PARAM_ERROR;
    	}
    
    	while ( pos<=pList->iCount-1 && pList->pElem[pos]!= Value) //一边比较,一边往后移pos的值,直到找到或者到达有效数据的末尾
    		pos++;
    
    	if ( pos <= pList->iCount-1 ) //如果是以“找到”的姿态跳出while循环
    		return pos;
    	else  
    		return NOTFIND;    //如果是以“到末尾”的姿态跳出while循环
    
    }
    
    //功能:根据给定的逻辑位置值pos(假设从1开始),在pList指向的顺序表中提取其元素值,存放到pValue指针指向的空间中并返回给主调函数使用
    //备注:pValue的写法,展示了C语言如何通过参数传递,将子函数内的数据传出来,给主调函数使用,注意形参写法和调用时的实参写法!
    //      pValue指针,假定其已经指向某个存储空间,本函数不再校验它。问题是:这个空间,应该在主调函数中申请,还是在子函数中申请?一般做法是在主调函数中申请!
    int GetValue(SeqList *pList, int pos, Elemtype *pValue)
    {
    	//重要的步骤,参数校验!一定别忘了!如果Value有一定的现实含义,则还需要对其做参数有效性校验
    	if (pList==NULL || pList->pElem==NULL || pos<1 || pos >pList->iCount || pValue==NULL)
    	{
    		return PARAM_ERROR;
    	}
    	
    	*pValue= pList->pElem[pos];                    //获得元素值
    	return 0;
    }
    
    //功能:根据指定的逻辑位置pos值(假设从0开始),在pList指向的顺序表中,第pos个元素后面插入值为Value的元素
    //备注:pos的值应>=0,当pos=0时,全体所有数据都需要后移一格;当pos>=iCount时,全体数据都不需要后移
    int SeqListInsert(SeqList *pList, int pos, Elemtype Value)
    {
    	Elemtype *pNewBase, *p, *q;
    	
    	if (pList==NULL || pList->pElem==NULL || pos <0 )
    	{
    		return PARAM_ERROR;
    	}
    	if ( pos > pList->iCount )
    		pos = pList->iCount ;
    
    	//如果当前已经装满,则需要扩展存储空间
    	if (pList->iCount == pList->iTotalLength)
    	{
    		pNewBase= (Elemtype *)realloc(pList->pElem, (pList->iTotalLength + LISTINCREMENT)*sizeof(Elemtype));  //请同学们进一步了解realloc的工作原理,当空间字节数较多时,该函数开销较大!
    		if (pNewBase== NULL)
    		{
    			return REALLOC_ERROR;
    		}
    
    		pList->pElem= pNewBase;
    		pList->iTotalLength= pList->iTotalLength + LISTINCREMENT;
    	}
    
    	q= &(pList->pElem[pos]); //q 指向的这个元素及其后面所有元素都需要后移一格
    	for(p= &(pList->pElem[pList->iCount-1]) ; p>=q; p--)  //从后面往前,循环,每个元素后移一格,直到腾出要插入的内存空间。当pos=0时,全体所有数据都需要后移一格;当pos>=iCount时,全体数据都不需要后移
    		*(p+1)= *p;
    
    	*q= Value;  //实现插入操作
    	pList->iCount++;  //元素增加,别忘了让有效长度值iCount加1――随时维护iCount值的准确性,以方便程序员即时读取,而不是在需要的时候才去数个数
    	return 0;
    }
    
    //合并无序的顺序表  MergeOption:0 不允许重复  1允许重复
    int DisorderSeqListMerge(SeqList *pListA, SeqList *pListB, int MergeOption, SeqList **pListC)
    {
    	int i, ret;
    
    	if (pListA==NULL || pListA->pElem==NULL || pListB==NULL || pListB->pElem==NULL || MergeOption < 0 || MergeOption > 1 )
    	{
    		return PARAM_ERROR;
    	}
    
    	*pListC= (SeqList *)malloc( sizeof(SeqList));
    	if (*pListC==NULL)
    	{
    		return MALLOC_ERROR;
    	}
    
    	(*pListC)->iTotalLength= pListA->iTotalLength + pListB->iTotalLength;
    	(*pListC)->pElem= (Elemtype *)malloc( (*pListC)->iTotalLength * sizeof(Elemtype));  
    	if ((*pListC)->pElem==NULL)
    	{
    		if ((*pListC) != NULL)
    			free(*pListC);
    		*pListC= NULL;
    		return MALLOC_ERROR;
    	}
    	
    	//将A表的数据依次复制到C表数据区
    	for(i= 0; i<pListA->iCount; i++)
    		(*pListC)->pElem[i]= pListA->pElem[i];
    	(*pListC)->iCount= pListA->iCount;
    
    	for (i=0; i<pListB->iCount; i++)
    	{
    		ret = SearchByValue(pListA, pListB->pElem[i]);
    		if ( ret >= 0 && MergeOption==0) //现有重复的元素,且不允许重复
    		{
    			//什么都不做,不执行插入操作
    		}
    		else  //没找到,没有重复的元素
    		{
    			SeqListInsert(*pListC, (*pListC)->iCount, pListB->pElem[i]);  //将LB[i]插入到新表LC的末尾
    		}
    	}
    
    	return 0;
    }
     //测试代码,或者主程序代码,在测试InitList函数时,由你自己随意编写;在提交老板后,由项目经理或高级程序员负责编写
    void main(void)
    {
    	int ret, i;
    	SeqList List1, List2;              //内存中为List1这个结构体变量分配4+4+4=12个字节
    	Elemtype myValue;
    	Elemtype *pmyValue= &myValue;
    	SeqList *pList1= &List1;    //内存中为pList1这个结构体指针变量分配4个字节         
    	SeqList *pList3= NULL;
    	//创建演示
    	ret= InitList( &List1 );  //注意,InitList需要的是一个结构体变量的地址,故传&pList1
    	if (ret==0)
    		printf("创建空的顺序表成功!表的理论总长为%d,每次如果不够,自动增长值为%d", LIST_INIT_SIZE, LISTINCREMENT);
    	else
    	{
    		printf("未能成功分配顺序表的数据存储空间,创建顺序表失败!");
    		return;
    	}
    
    	ret= InitList( &List2 );  //注意,InitList需要的是一个结构体变量的地址,故传&pList2
    	if (ret==0)
    		printf("创建空的顺序表成功!表的理论总长为%d,每次如果不够,自动增长值为%d", LIST_INIT_SIZE, LISTINCREMENT);
    	else
    	{
    		printf("未能成功分配顺序表的数据存储空间,创建顺序表失败!");
    		return;
    	}
    
    	for (i= 0; i<5; i++)
    	{
    		SeqListInsert(pList1, i, (Elemtype)('H'-i));
    	}
    	for (i= 0; i<5; i++)
    	{
    		SeqListInsert(&List2, i, (Elemtype)('A'+i));
    	}
    
    	//访问演示
    	ret= GetValue(&List1, 2, pmyValue);  //注意在Debug状态下看看*pmyValue的变化,理解数据传递的方向(从子函数给主调函数)
    	if (ret==0)
    		printf("你要读取表中第%d个元素,其值是%c", 2, *pmyValue); //主调函数使用子函数传出来的数据
    	else
    		printf("你要读取表中第%d个元素,本表不存在这个元素!", 2);
    
    	//无序表的合并
    	DisorderSeqListMerge(&List1, &List2, 1, &pList3);
    	return;
    }
    

    java版本:

    class person{
    	public int ID;
    	public String name;
    	public person(int ID,String name) {
    		this.ID = ID;
    		this.name = name;
    	}
    }
    
    public class Seqlist{
    
    	static final int MAXSIZE = 20;
    	static person []Element;
    	static int Count;//线性表当前长度 
    	
    	//构造函数,线性表的初始化
    	public Seqlist(int maxsize) {
    		Count = 0;
    		Element = new person[maxsize];
    	}
    	
    	//取元素值
    	static person Getvalue(int pos) throws Exception{
    		if(Count == 0)
    		{
    			throw new Exception("为空表,查找失败");
    		}
    		else if(pos <= 0 || pos > Count)
    		{
    			throw new Exception("第"+pos+"个元素不存在");
    		}
    			return Element[pos - 1];
    	}
    	
    	 //插入元素
    	int Insert(int pos,person value) throws Exception{
    		if(Count == MAXSIZE)
    		{
    			throw new Exception("表溢出!");
    		}
    		else if(pos <= 0 )
    		{
    			throw new Exception("插入位置错误");
    		}
    		for(int i = Count-1;i >= pos-1;i--)
    		{
    			Element[i+1] = Element[i];
    		}
    		Element[pos-1] = value;
    		Count++;
    		return 1;
    	}
    	
    	//删除元素
    	int Del(int pos) throws Exception{
    		if(pos <= 0 || pos > Count)
    		{
    			throw new Exception("该元素不存在");
    		}
    		for(int i = pos;i <= Count;i++)
    		{
    			Element[i-1] = Element[i];
    		}
    		Count--;
    		return 1;
    	}
    	
    	//获取长度
    	int ListLength() {
    		return Count;
    	}
    	
    	//清空表
    	int ListClear() {
    		Count = 0;
    		return 1;
    	}
    	
    	 //获得前驱
    	static person GetPre(int pos) throws Exception{
    		if(pos < 2 || pos > Count)
    		{
    			throw new Exception("前驱不存在");
    		}
    		return Element[pos - 2];
    	}
    	
    	 //获得后驱
    	static person GetNext(int pos) throws Exception{
    		if(pos < 1 || pos > Count - 1)
    		{
    			throw new Exception("后驱不存在");
    		}
    		return Element[pos];
    	}
    	
    	//显示链表
    	void display() {
    		System.out.println("当前表中一共有"+Count+"个元素,表中元素如下:");
    		for(int i = 0;i < Count;i++)
    		{
    			System.out.println("ID:"+Element[i].ID+"  name:"+Element[i].name);
    		}
    	}
    	
    	public static void main(String[] args) throws InterruptedException {
    		// TODO Auto-generated method stub
    		//创建并初始化线性表
    		Seqlist list1 = new Seqlist(10);
    		
    		person[] data1 = new person[5];
    		
    		person p1 = new person(1,"张三");
    		person p2 = new person(2,"李四");
    		person p3 = new person(3,"王五");
    		person p4 = new person(4,"李雷");
    		person p5 = new person(5,"韩梅梅");
    		
    		data1[0] = p1;
    		data1[1] = p2;
    		data1[2] = p3;
    		data1[3] = p4;
    		data1[4] = p5;
    		
    		for(int i = 0;i <5;i++)
    		{
    			try {
    				list1.Insert(list1.ListLength()+1,data1[i]);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		list1.display();
    		System.out.println("顺序表初始化成功");
    		System.out.println("表的长度为:"+list1.ListLength());
    		System.out.println("表中第三个元素的值:");
    		try {
    			System.out.println("ID:"+Getvalue(3).ID+"  name:"+Getvalue(3).name);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.out.println("添加姓名为'刘备'的数据到位置二");
    		person p6 = new person(6,"刘备");
    		try {
    			list1.Insert(2,p6);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		list1.display();
    		System.out.println("删除位置四的数据");
    		try {
    			list1.Del(4);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		list1.display();
    		System.out.println("位置二的前驱为:");
    		try {
    			System.out.println("ID:"+GetPre(2).ID+"  name:"+GetPre(2).name);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.out.println("位置二的后驱为:");
    		try {
    			System.out.println("ID:"+GetNext(2).ID+"  name:"+GetNext(2).name);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		list1.ListClear();
    		System.out.println("清空线性表成功");
    		System.out.println(list1.ListLength());
    	}
    
    }
    
    

    41 单链表

    翔哥代码:

    /*
        适用于标准C
    	LinkList.c
    	无序单链表的实现代码
    	V1.1――2016.9.20 by wangx
        v1.2――2017.9.7  by wangx
    	v1.2.1――2017.9.10  by wangx
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h> //for memcpy
    
    #define OK 1
    #define OVERFLOW 0
    #define LIST_INIT_SIZE 100
    #define LISTINCREMENT 10
    
    
    //公共错误码,项目组成员之间的共同约定
    #define MALLOC_ERROR  -1  
    #define NOTFIND  -2
    #define PARAM_ERROR -3
    #define REALLOC_ERROR  -4  
    #define END_ID  0  
    
    typedef struct  person
    {
    	long ID;           //4
    	char name[20];     //20
    }Elemtype;
    
    //单链表的单个数据结点的类型定义
    typedef struct NODE
    {
    	Elemtype	data;  //24
    	struct NODE *next; //4 
    }NODE, *pNODE;                 //如果定义数据结点的对象或变量,每个变量有24+4=28个字节
    
    //单链表整体结构的类型定义
    typedef struct LIST
    {
    	int	Count;                 //数据个数,即表长。该信息使用频繁,3种思路可做:1. 定义为pubblic权限的成员变量Count,增删清空等时候维护该变量,获取时直接以list1.Count的形式返回――有安全风险,且容易引发混乱,不提倡!
    	                           //                                               2. 定义成成员方法getCount()的形式,调用方法,临时去计算并返回长度值。                           ――计算费时,不适合频繁使用,尤其是数据量很大的时候
    	                           //                                               3. 定义为private权限的成员变量Count,增删清空等时候维护该变量,获取时用public权限的成员方法getCount()去读取该变量。――这是实际普遍使用的方式
    	struct NODE *pHeadOfData;  //指向单链表表头的指针,即书上所说的head指针。必须是private权限的,不允许其他类的对象来修改这个成员的值,对使用链表的程序员透明(即:不需要知道它的存在)。指向表头结点,一旦创建了链表对象,在销毁之前永不变。
    	//下面是不太重要或常用的一些成员,同学们可以自由发挥想一下,例如如下:
    	int maxValue;              //一个并不成熟的设计,要求数据必须是可相互比较的类型,且删除后不好维护
    	int minValue;
    	struct NODE *pTailOfData;   //以方便快速定位到表尾结点(在数据的尾插法中可以用到)
    	// ......
    }LIST, *LINKLIST;              //如果定义对象,则每个对象有4+4+4+4=16个字节
    
    
    /*****************************************************************
     *  函数名字:SearchByPos
     *	函数功能:查询指定的单链表中指定位置的元素,获得其数据结点的地址
     *	函数参数:pList ――指向某单链表对象的一级指针,要求非空
     *			  pos   ――所搜数据在表中的逻辑位置(编号从0开始)
     *			  ppNode――向主调函数传出(加一级指针)该表的第pos个结点的地址(一级指针),故此处需要用1+1=2级指针的参数类型
     *						如果没找到第pos个元素,则该参数返回NULL,即0x00000000
     *	函数返回:int型,0表示操作正常结束; -2(NOTFIND)表示没找到; -3(PARAM_ERROR)表示参数校验失败
     *	备    注:同学们可以自己写SearchByValue函数
     *			  该函数如果在类中,可设为public权限,开放
     */
    //根据逻辑顺序值pos,在单链表pList中,将第pos个元素结点的地址值以参数形式传出。
    int SearchByPos(LIST *pList, int pos, NODE **ppNode)
    {
    	int i;
    	NODE *p;
    	//参数校验
    	if (pList==NULL)
    	{
    		return PARAM_ERROR;
    	}
    
    	i= 0;
    	p= pList->pHeadOfData;
    	while ( i<pos && p->next!= NULL) //当没有数到逻辑顺序的第i个结点 并且 还没有到表尾的时候,则
    	{
    		p= p->next;          //一边将p指针指向下一个结点
    		i++;				 //一边计数
    	}
    
    	if ( i==pos ) // 如果 i== pos,即p指向第pos个元素了
    	{
    		*ppNode= p;    //如果是以“找到第pos个元素”的姿态跳出while循环
    		return 0;
    	}
    	else  //如果是p->next== NULL,即以“到表尾”的姿态跳出while循环
    	{
    		*ppNode= NULL;
    		return NOTFIND;
    	}
    }
    
    
    /*****************************************************************
     *  函数名字:Insert
     *	函数功能:插入一个元素到指定的单链表中的指定位置后
     *	函数参数:pList――指向某单链表对象的一级指针,要求非空
     *			  value――需要添加或插入的元素的值,假定元素值是有效的; 可稍作改动,支持结构体变量类型
     *			  pos  ――需要插入的逻辑位置(之后),pos大于表长时视为“表尾追加元素”,pos<=0时视为“表头后插入元素”
     *	函数返回:int型,0表示操作正常结束
     *	备    注:本函数不对上层程序员开放。在无序表中,不需要指定插入的位置(因为无序表中元素的先后顺序并不重要。在Java或C++的有些类中,也提供了这种插入操作,主要是在指定位置之前插入。同学们可以自行设计和尝试改写下面代码)
     *			                            在有序表中,其该插入的位置是由其值的大小来决定的,无须指定插入位置pos;而且,有序表,主要都用在顺序表中,很少有用在单链表里的情况。查找很不方便哦!折半查找没法用!(作为练手,同学们可以尝试编写这个插入方法)
     *			  该函数如果在类中,可设为private权限,不开放
     */
    int Insert(LIST *pList, Elemtype value, int pos)
    {
    	long len;
    	int ret;
    	struct NODE *pNew= NULL;
    	struct NODE *pPre= NULL;
    	//参数校验
    	if (pList==NULL)
    	{
    		return PARAM_ERROR;
    	}
    	//参数调整
    	len= pList->Count; //将长度信息读出来备用,len变量不定义也是可以的。
    	if (pos >= len)
    		pos= len;
    	if (pos <0)
    		pos= 0;
    
    	//插入第一步:申请新结点空间
    	pNew= (struct NODE *)malloc(sizeof(struct NODE));
    	if (pNew==NULL)
    	{
    		return MALLOC_ERROR;
    	}
    
    	//插入第二步:填值到新结点空间,准备就绪
    	memset(pNew, 0, sizeof(struct NODE));
    	pNew->data.ID= value.ID; //此处不能直接写成pNew->data= value;
    	memcpy(pNew->data.name, value.name, strlen(value.name));
    	pNew->next= NULL;
    
    	//插入第三步:找到第pos个结点,以备在其后插入新结点
    	ret= SearchByPos(pList, pos, &pPre);
    	if (ret== NOTFIND)
    	{
    		free(pNew);
    		return NOTFIND;
    	}
    
    	//插入第四步:插入结点
    	pNew->next= pPre->next;
    	pPre->next= pNew;
    	
    	//插入第五步:长度值别忘了+1
    	pList->Count++;
    
    	return 0;
    }
    
    /*****************************************************************
     *  函数名字:AddToTail
     *	函数功能:往“无序”的线性“表尾”后面添加一个元素(即:在表尾追加一个元素结点)
     *	函数参数:pList――指向某单链表对象的一级指针,要求非空
     *			  value――需要添加的元素的值,假定元素值是有效的; 可稍作改动,支持结构体变量类型
     *	函数返回:int型,0表示操作正常结束
     *	备    注:该函数如果在类中,可设为public权限,开放给上层程序员使用
     */
    int AddToTail(LIST *pList, Elemtype value)
    {
    	int len;
    	len= pList->Count;
    	return Insert(pList, value, len);
    }
    
    /*****************************************************************
     *  函数名字:AddToHead
     *	函数功能:往“无序”的线性“表头”后面添加一个元素结点
     *	函数参数:pList――指向某单链表对象的一级指针,要求非空
     *			  value――需要添加的元素的值,假定元素值是有效的; 可稍作改动,支持结构体变量类型
     *	函数返回:int型,0表示操作正常结束
     *	备    注:该函数如果在类中,可设为public权限,开放给上层程序员使用
     */
    int AddToHead(LIST *pList, Elemtype value)
    {
    	return Insert(pList, value, 0); //在第一个元素之前(即:第0个元素之后)插入元素结点
    }
    
    
    /*****************************************************************
     *   函数名字:createList
     *	函数功能:创建一个空的带表头节点的单向链表
     *	函数参数:ppList――是一个2级指针,调用结束后*ppList指向一个单链表结构的对象
     *	函数返回:int型,0表示操作正常结束
     *  备    注:该函数如果在类中,可设为public权限,开放给上层程序员使用
     */
    //创建一个带表头结点的链表,完成数据输入和串接
    int createList(LIST **ppList)  //一般我们都将指向单链表第一个结点(或表头结点)的指针命名为head,这是习惯约定
    {
    	struct LIST *pNewList;
    	struct NODE *pNewNode;
    	if (ppList==NULL)              //参数校验,注意:此处校验的是ppList(不能为空,口袋必须要有!),不是*ppList(可以为NULL,表示有口袋,但是口袋里什么东西都没有)。
    		return PARAM_ERROR;
    
    	//创建一个表头结点,并用pNewList指向该空间
    	pNewNode = (struct NODE *)malloc(sizeof(struct NODE));  //申请空间,注意:申请的是一个表结点的空间(28个字节)
    	if (pNewNode==NULL)
    	{
    		return MALLOC_ERROR;
    	}
    	memset(pNewNode, 0, sizeof(struct NODE));
    	pNewNode->next = NULL;  //空表,没有后续结点。表头结点的data域不需要处理,清0即可。另,养成良好习惯,当结点的next成员指向何方尚不明朗时,先置为NULL以防患于未然,避免野指针。
    
    
    	//创建一个表对象的空间,并用pNewList指向该空间
    	pNewList = (struct LIST *)malloc(sizeof(struct LIST));  //申请空间,注意:申请的是一个表对象的空间(16个字节),而不是一个表结点的空间(28个字节)
    	if (pNewList==NULL)
    	{
    		free(pNewNode);     //在发生异常,准备退出之前,先把之前成功申请的pNewNode结点空间给释放了!这一点很多程序员容易忽略,造成内存泄露!
    		return MALLOC_ERROR;
    	}
    	memset(pNewList, 0, sizeof(struct LIST));
    	pNewList->Count= 0;   //设置该空表头的表长值为0
    	pNewList->pHeadOfData = pNewNode;  //表对象的数据头指针指向刚才建好的表头结点。
    	pNewList->pTailOfData = pNewNode;  //表对象的数据尾指针指向刚才建好的表头结点。空表,没数据,所以尾指针指向头结点。
    
    	*ppList = pNewList;  //给表头指针赋值为表头结点的地址。
    						 //这是套路,先用一个临时变量pNewList去操作数据,然后交付给*ppList
    
    	return 0;            //本函数是如何返回表头指针的?又如何调用本函数呢?思考这2个问题!能画出内存四区图来么?
    }
    
    /*****************************************************************
     *   函数名字:createList2
     *	函数功能:创建一个单向链表,并填入数据,以尾插法实现结点挂接。
     *	函数参数:
     *	函数返回:LIST ** (函数运行结束之后,返回指向该表对象空间的一个2级指针)
     *  备    注:以前数据结构的老版本,没学过面向对象思想的人才会这么写
                  这个方法不是面向对象的思想!不会成为单链表类的一个成员函数。写在这里,只是为了给同学们展示目前大多数教科书或考题中的一个不成熟的考法。
     */
    //创建一个带表头结点的链表,并且完成数据输入和串接
    int createList2(LIST **ppList)
    {
    	struct NODE *pNew;
    	Elemtype Data;
    
    	if (ppList==NULL)              //参数校验
    		return PARAM_ERROR;
    
    	createList(ppList);          //调用之前定义的函数,产生一个空表
    
    	printf("请输入学生的5位证件号的值和姓名(空格隔开,ID值为0表示输入结束):");
    	scanf("%ld", &(Data.ID));
    	scanf("%s", Data.name);
    	//创建并挂接后续的各个结点
    	while (Data.ID != END_ID)  //程序员和用户已约定:当用户输入的数据为0(END_ID)时,表示数据录入的结束(注意,此约定不是唯一方法,仅供学习时适用)
    	{
    		//创建新的结点并赋值
    		pNew = (struct NODE *)malloc(sizeof(struct NODE));  //申请空间
    		if (pNew==NULL)
    		{
    			return MALLOC_ERROR;
    		}
    		memset(pNew, 0, sizeof(struct NODE));
    
    		pNew->data.ID= Data.ID;    //为新结点的data域填入数据
    		memcpy(pNew->data.name, Data.name, strlen(Data.name));
    		pNew->next = NULL;           //为新结点的next域填入数据,指向不行时填入NULL;或因为其是新的表尾结点,所以也应该将其next域填入NULL表示链表在结尾。
    
    		//将新结点挂接到原链表中,此步骤很关键!
    		(*ppList)->pTailOfData->next = pNew;          //pTail专门指向链表当前的最后一个结点,此行代码实现了将新结点连入链表尾部(还记得王老师曾经讲过的指针赋值的那句口诀不?“指针的赋值如何看?等式左边的指针,指向等式右边指针所指向的东西”)
    		(*ppList)->pTailOfData = pNew;                //pTail指向的结点已经不是链表的表尾结点了(挂接之后,pNew指向的结点才是新的表尾结点),故而刷新pTail,让其指向新的表尾结点。
    		printf("请输入学生的5位证件号的值和姓名(空格隔开,ID值为0表示输入结束):");
    		scanf("%ld", &(Data.ID));
    		scanf("%s", Data.name);
    	}
    	return 0;     //本函数是如何返回一个表的?思考这个问题!
    }
    
    /*****************************************************************
     *  函数名字:output
     *	函数功能:输出单链表的所有结点数据,在屏幕上显示打印
     *	函数参数:pList――指向某单链表对象的一级指针,要求非空(有了它,我们就能顺藤摸瓜,找出所有数据)
     *	函数返回:无(这是一个打印或显示类型的函数,不需要返回任何数据)
     *  备    注:教学演示所用,并无实用
     */
    void output(struct LIST *pList)
    {
    	struct NODE *p;
    	if (pList==NULL)                 //参数如果不正确,则直接罢工
    		return;
    	p = pList->pHeadOfData->next;   //"顺藤",从pHeadOfData->next开始,跳过表头节点的Data域不打印
    	while (p != NULL)               //到尾。注意,单链表的最后一个结点的next域的值为NULL,本块代码也是读取单链表的标准模板
    	{
    		printf("%6d  ", p->data.ID);  //"摸瓜"
    		printf("%s\n",  p->data.name);
    		p = p->next;                //千万别忘记本行代码,否则死循环了
    	}
    	return ;
    }
    
    /*****************************************************************
     *  函数名字:DelByPos
     *	函数功能:删除指定单链表中指定逻辑顺序位置的元素结点,并将删除的元素的值提取出来
     *	函数参数:pList ――指向某单链表对象的一级指针,要求非空
     *			  pos   ――需要删除的结点的逻辑序号(从0开始编号),pos大于表长或者pos<=0时视为“参数不合法”
     *			  pValue――指向被删除元素的值,以方便在有些应用场合中对其做死前最后可能的访问操作。
     *	函数返回:int型,0表示操作正常结束
     *	备    注:该函数如果在类中,可设为public权限,开放。同学们可以自行练习DelByValue函数。
     */
    int DelByPos(struct LIST *pList, int pos, Elemtype *pValue)
    {
    	int ret;
    	struct NODE *pDel= NULL;
    	struct NODE *pPre= NULL;
    	//参数校验
    	if (pList==NULL)
    	{
    		return PARAM_ERROR;
    	}
    	//删除第一步:找到第pos-1个结点的地址,顺带着也就校验了pos值是否过大
    	ret= SearchByPos(pList, pos-1, &pPre); //要删除第pos个元素,在链表这种结构中,需要获取到第pos-1个元素的地址,以方便删除操作
    	if (ret== NOTFIND) //如果本来该表压根就没有第pos-1个元素,那无法完成删除,pos值过大!
    	{
    		return PARAM_ERROR;
    	}
    
    	//删除第二步:获取第pos个结点的地址并暂存该地址(函数的任务就是要删这个结点)
    	pDel= pPre->next; 
    	if (pDel==NULL)  //有第pos-1个结点,但恰好没有第pos个结点的情况,仍然归咎于pos参数传入错误
    	{
    		return PARAM_ERROR;
    	}
    
    	//删除第三步:将第pos个结点从链表中摘下来,使其脱离链表
    	pPre->next= pPre->next->next;
    
    	//删除第四步:(非必须的步骤)将该结点的值拷贝出来,以备上层函数可能使用
    	pValue->ID= pDel->data.ID;
    	memcpy(pValue->name, pDel->data.name, strlen(pDel->data.name));
    
    	//删除第五步:释放pDel指针所指向的结点空间(在堆区),注意,并不是释放pDel指针变量本身这4个字节哦!free之后,pDel变量仍然存在!成为了一个野指针!
    	free(pDel);
    	pDel=NULL;  //指针复位操作。可以看出,pDel指针仍然存在,有值,但其指向的空间已被回收。为了避免误操作,特意将这4个字节的空间全部清0,即让pDel指针为NULL
    	
    	//删除第六步:长度值别忘了-1
    	pList->Count--;
    
    	return 0;
    }
    
    // 思考下面的这些操作应该怎么去设计参数和操作思想?
    /*****************************************************************
     *  函数名字:clearList
     *	函数功能:清空一个单向链表的数据
     *	函数参数:pList――是一个指向表对象空间的1级指针。
     *	函数返回:int型,0表示操作正常结束
     *  备    注:只是清空操作,表对象仍然存在,只是没数据而已。所以表对象指针不会发生变化,没必要用二级指针,一级指针就能搞定。
     */
    int clearList(LIST *pList)
    {
    	pNODE p,q;
    	// 参数校验
    	if(pList==NULL){
    		return PARAM_ERROR;
    	}
    	// 做好循环控制并针对每个数据结点,释放结点空间。建议用while循环,想想循环结束条件是什么?
    	p=pList->pHeadOfData->next;
    	while(p){
    		q=p->next;
    		free(p);
    		p=q;
    	}
    	// pHeadOfData指针复位
    	pList->pHeadOfData->next=NULL;
    	// 调整表长,恢复为0 ,此步骤千万别忘了!
    	pList->Count=0;
    	return 0;
    }
    
    
    /*****************************************************************
     *  函数名字:destroyList
     *	函数功能:销毁一个单向链表
     *	函数参数:ppList――是一个2级指针,因为要销毁空间,所以需要在函数内改变实参的值(往外传一个NULL),所以要用2级指针
     *	函数返回:int型,0表示操作正常结束
     *  备    注:
     */
    int destroyList(LIST **ppList)
    {
    	pNODE p,q;
    	// 参数校验
    	if(ppList==NULL){
    		return PARAM_ERROR;
    	}
    	// 清空数据并销毁数据
    	p=(*ppList)->pHeadOfData->next;
    	while(p){
    		q=p->next;
    		free(p);
    		p=q;
    	}
    	// 释放表对象所占空间
    	free((*ppList)->pHeadOfData);
    //	free((*ppList)->pTailOfData);
    	// 表对象指针复位
    	*ppList=NULL;
    	return 0;
    }
    
    /*****************************************************************
     *  函数名字:MergeList
     *	函数功能:将2个单链表进行无序合并,合并后不改变原有的2个表的数据。
     *	函数参数:pList1――指向某单链表对象1的一级指针,要求非空
     *			  pList2――指向某单链表对象2的一级指针,要求非空
     *	函数返回:int型,0表示操作正常结束
     *	备    注:
     */
    //    int MergeList(LIST *pList1,   LIST *pList2)
    //    int MergeList(LIST **ppList1, LIST *pList2)
    // LIST * MergeList(LIST *pList1,   LIST *pList2)
    //    ......
    
    
    
    int main(void)
    {
    	int ret, pos;
    	struct LIST *pList1;
    //	struct LIST *pList2;
    	Elemtype value;
    
    	//创建链表1,并填入数据
    	ret= createList(&pList1);     // 一定要看清楚此处的用法哦!pList1是一级指针,所以&pList1就是二级指针了(一级指针的地址,有些书上称之为二级指针类型了)!
    	value.ID= 10;
    	memset(value.name, 0, 20);
    	memcpy(value.name,"汤唯", 4);
    	AddToTail(pList1, value);
    
    	value.ID= 20;
    	memset(value.name, 0, 20);
    	memcpy(value.name,"林志玲", 6);
    	AddToTail(pList1, value);
    
    	value.ID= 30;
    	memset(value.name, 0, 20);
    	memcpy(value.name,"关之琳", 6);
    	AddToTail(pList1, value);
    
    	value.ID= 40;
    	memset(value.name, 0, 20);
    	memcpy(value.name,"迪丽热巴", 8);
    	AddToTail(pList1, value);
    
    	output(pList1);  //输出显示单链表的所有数据
    	
    	printf("=========下面演示删除=====================\n");
    	pos= 8;
    	ret= DelByPos(pList1, pos, &value); //删除第8个。但是不存在第8个结点,删除失败,返回-1,放弃删除(你也可以编程实现让它在这种情况下(pos>count时)去删除最后一个结点来作为对用户的回应)
    	if (ret== 0)
    		printf("我删除了%s这个结点\n", value.name);
    	else
    		printf("我没法删除第%d个结点\n", pos);
    	output(pList1);  //输出显示单链表的所有数据
    	clearList(pList1);
    	destroyList(&pList1);
    	printf("okkk");
    //	printf("=========下面用过时的创建函数演示一下========\n");
    //	ret= createList2(&pList2); //用老方法来创建,在创建的同时就在插入元素,模块的划分有点混乱
    //	output(pHead2);
    
    	//同学们可以在下面针对上面写的所有函数自行添加测试代码去使用一下!
    	// ......
    
    	return 0;
    }
    
    

    Java版本:

    //Java没有指针,用对象引用的方法
    //单链表单个结点类型定义
    class node{
    	public int data;
    	public node next;
    	public node(int data) {
    		this.data = data;
    		this.next = null;
    	}
    	public node() {
    		this.data = 0;
    		this.next = null;
    	}
    }
    
    public class Linklist{
    	//错误代码
    	static final int PARAM_ERROR = -1;
    	static final int NOTFIND = -2;
    	static final int OREADY = -3;
    	private int count;
    	private static node HeadofData;
    	
    	//创建一个带头结点的链表
    	public Linklist() {
    		HeadofData=new node(0);
    		count = 0;
    	}
    	
    	/**
    	 * 获取单链表的长度
    	 * @return
    	 */
    	public int length() {
    		return count;
    	}
    	
    	/**
    	 * 在表尾插入一个结点
    	 * @param pin 插入的结点
    	 * @return
    	 */
    	public int AddtoTail(node pin) {
    		return InsertbyPos(pin,count);
    	}
    	
    	/**
    	 * InsertbyPos:根据位置插入结点,如果位置大于链表长度,会插在链表尾
    	 * @param pin 插入的结点
    	 * @param pos 插入的位置
    	 * @return
    	 */
    	public int InsertbyPos(node pin,int pos) {
    		//参数校验
    		if(HeadofData == null) {
    			return PARAM_ERROR;
    		}
    		//极端情况,调整参数
    		if(pos > count) {
    			pos = count;
    		}
    		if(pos < 0) {
    			pos = 0;
    		}
    		int i = 0;
    		node p = HeadofData;
    		while(i < pos) {
    			i++;
    			p = p.next;
    		}
    		pin.next = p.next;
    		p.next = pin;
    		count++;
    		return 0;
    	}
    	
    	/**
    	 * 按位置查找结点
    	 * @param pos 结点位置
    	 * @return 返回结点上的数据
    	 */
    	public int SearchbyPos(int pos,node elem) {
    		int i = 1;
    		//参数校验
    		if(HeadofData == null) {
    			return PARAM_ERROR;
    		}
    		node p = HeadofData.next;
    		while(i < pos && p.next != null) {
    			p = p.next;
    			i++;
    		}
    		if(i == pos) {
    			elem.data = p.data;
    			elem.next = p.next;
    			return 0;
    		}
    		else {
    			return NOTFIND;
    		}
    	}
    	
    	//表头添加一个结点
    	int AddtoHead(node pin) {
    		return InsertbyPos(pin,0);
    	}
    	
    	//输出单链表中所有的数据
    	void Output() {
    		System.out.println("表中结点元素:");
    		node p = HeadofData;
    		p = HeadofData.next;
    		while(p != null){
    			System.out.print(p.data+" ");
    			p = p.next;
    		}
    		System.out.println("\n");
    	}
    
    	/**
    	 * 按位置删除
    	 * @param pos 结点位置
    	 * @param delelem 删除的结点
    	 * @return
    	 */
    	int DelbyPos(int pos,node delelem) {
    		//参数校验
    		node previous = HeadofData;
    		node current = HeadofData;
    		if(HeadofData == null) {
    			return PARAM_ERROR;
    		}
    		int flag = SearchbyPos(pos, delelem);
    		if(flag == NOTFIND) {
    			return NOTFIND;
    		}
    		//删除结点
    		int i = 0;
    		while(i < pos) {
    			previous = current;
    			current = current.next;
    			i++;
    		}
    		previous.next = current.next;
    		count--;
    		return 0;
    	}
    	
    	/**
    	 * 链表排序
    	 * @param moudle 1为从小到大,2为从大到小
    	 * @return
    	 */
    	int order(int moudle) {
    		//参数校验
    		if(HeadofData == null) {
    			return PARAM_ERROR;
    		}
    		int temp;
    		node pNode = HeadofData;
    		if(moudle == 1) {
    			for(int i = 0;i < count;i++) {
    				pNode = HeadofData.next;
    				while(pNode.next != null) {
    					if(pNode.data > pNode.next.data) {
    						temp = pNode.data;
    						pNode.data = pNode.next.data;
    						pNode.next.data =temp;
    					}
    					pNode = pNode.next;
    				}
    			}
    		}
    		else {
    			for(int i = 0;i < count;i++) {
    				pNode = HeadofData.next;
    				while(pNode.next != null) {
    					if(pNode.data > pNode.next.data) {
    						temp = pNode.data;
    						pNode.data = pNode.next.data;
    						pNode.next.data =temp;
    					}
    					pNode = pNode.next;
    				}
    			}
    		}
    		return 0;
    	}
    	
    	/**
    	 * 获取前驱结点
    	 * @param pos
    	 * @return
    	 */
    	public node GetPre(int pos) {
    		node elem = new node();
    		SearchbyPos(pos-1, elem);
    		return elem;
    	}
    	
    	//清空链表
    	int clearlist() {
    		if(HeadofData == null) {
    			return OREADY;
    		}
    		HeadofData.next = null;
    		return 0;
    	}
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Linklist plist1 = new Linklist();
    		if(plist1.HeadofData == null) {
    			System.out.println("创建单链表失败");
    			System.exit(0);
    		}
    		node p1 = new node(6);
    		plist1.AddtoTail(p1);
    		node p2 = new node(8);
    		plist1.AddtoTail(p2);
    		node p3 = new node(10);
    		plist1.AddtoTail(p3);
    		node p4 = new node(3);
    		plist1.AddtoTail(p4);
    		node p5 = new node(13);
    		plist1.AddtoTail(p5);
    		System.out.println("单链表创建成功,表的长度为:"+plist1.length());
    		plist1.Output();
    		node elem1 = new node(); //存储查找到的结点
    		plist1.SearchbyPos(3, elem1);
    		System.out.println("第三个结点元素是:"+elem1.data);
    		node elem2 = new node();
    		plist1.DelbyPos(3, elem2);
    		System.out.println("删除第三个结点上,结点元素为:"+elem2.data);
    		plist1.Output();
    		System.out.println("在三号位置后插入结点,元素为29");
    		node p6 = new node(29);
    		plist1.InsertbyPos(p6, 3);
    		plist1.Output();
    		System.out.println("在表头插入结点,元素为3");
    		node p7 = new node(3);
    		plist1.AddtoHead(p7);
    		plist1.Output();
    		plist1.order(1);
    		System.out.println("将表中元素排序后");
    		plist1.Output();
    		node elem3 = plist1.GetPre(3);
    		System.out.println("位置三的前驱为:"+elem3.data);
    		plist1.clearlist();
    		plist1.Output();
    		System.out.println("链表清空成功");
    	}
    
    }
    
    

    42 链表合并排序

    题目描述

      已有a、b两个链表,每个链表中的节点包括学号、成绩,且a、b两个链表中的节点均按照学号升序排列。要求把两个链表合并,按照学号升序排列并输出。

    样例输入

    Please input n m:[1-100]
    3 5
    Please input 3 students' numbers and scores:
    101 90
    104 80
    106 85
    Please input 5 students' numbers and scores:
    103 95
    105 88
    107 87
    108 90
    109 95
    

    样例输出

    Output:
    The result is:
    101 90
    103 95
    104 80
    105 88
    106 85
    107 87
    108 90
    109 95
    

    代码

    ///方法一:直接合并
    #include <stdio.h>
    #include <stdlib.h>
    
    struct node {
        int num;
        int score;
        struct node * next;
    };
    
    int main()
    {
        int n, m, i;
        struct node *heada, *taila, *headb, *tailb, *head, *tail, *p;
        heada = taila = headb = tailb = NULL;
        
        printf("Please input n m:[1-100]\n");
        scanf("%d%d", &n, &m);
        /* 读入a链表中的n个学生信息 */
        printf("Please input %d students' numbers and scores:\n", n);
        for (i = 0; i < n; i++) 
        {
            p = (struct node *)malloc(sizeof(struct node));
            scanf("%d%d", &p->num, &p->score);
            if (heada == NULL) 
            {
                heada = taila = p;
            } 
            else 
            {
                taila->next = p;
                taila = p;
            }
        }
        taila->next = NULL;
        /* 读入b链表中的m个学生信息 */
        printf("Please input %d students' numbers and scores:\n", m);
        for (i = 0;i < m;i++) 
        {
            p = (struct node *)malloc(sizeof(struct node));
            scanf("%d%d", &p->num, &p->score);
            if (headb == NULL) 
            {
                headb = tailb = p;
            } 
            else 
            {
                tailb->next = p;
                tailb = p;
            }
        }
        tailb->next = NULL;
        
        printf("Output:\nThe result is:\n");
        /* 合并两个链表 */
        /******start******/
        head=tail=NULL; 
    	struct node *p1, *p2;
    	p1=heada;
    	p2=headb;
    	while(p1!=NULL && p2!=NULL){
    		if(p1->num < p2->num){
    			if(head==NULL){
    				head=tail=p1;
    			}
    			else{
    				tail->next=p1;
    				tail=p1;
    			}
    			p1=p1->next;
    		}
    		else{
    			if(head==NULL){
    				head=tail=p2;
    			}
    			else{
    				tail->next=p2;
    				tail=p2;
    			}
    			p2=p2->next;
    		}
    	}
    	while(p1!=NULL){
    		tail->next=p1;
    		tail=p1;
    		p1=p1->next;
    	}
    	while(p2!=NULL){
    		tail->next=p2;
    		tail=p2;
    		p2=p2->next;
    	}
    	tail->next=NULL; 
        /******end******/
        /* 将合并后的链表进行输出 */
        p = head;
        while (p != NULL) 
        {
            printf("%d %d\n", p->num, p->score);
            p = p->next;
        }
        return 0;
    }
    
    //方法二:先合并,再使用冒泡排序
    #include <stdio.h>
    #include <stdlib.h>
    
    struct node {
        int num;
        int score;
        struct node * next;
    };
    
    int main()
    {
        int n, m, i;
        struct node *heada, *taila, *headb, *tailb, *head, *tail, *p;
        heada = taila = headb = tailb = NULL;
        
        printf("Please input n m:[1-100]\n");
        scanf("%d%d", &n, &m);
        /* 读入a链表中的n个学生信息 */
        printf("Please input %d students' numbers and scores:\n", n);
        for (i = 0; i < n; i++) 
        {
            p = (struct node *)malloc(sizeof(struct node));
            scanf("%d%d", &p->num, &p->score);
            if (heada == NULL) 
            {
                heada = taila = p;
            } 
            else 
            {
                taila->next = p;
                taila = p;
            }
        }
        taila->next = NULL;
        /* 读入b链表中的m个学生信息 */
        printf("Please input %d students' numbers and scores:\n", m);
        for (i = 0;i < m;i++) 
        {
            p = (struct node *)malloc(sizeof(struct node));
            scanf("%d%d", &p->num, &p->score);
            if (headb == NULL) 
            {
                headb = tailb = p;
            } 
            else 
            {
                tailb->next = p;
                tailb = p;
            }
        }
        tailb->next = NULL;
        
        printf("Output:\nThe result is:\n");
        /* 合并两个链表 */
        /******start******/
        //先合并
    	head=heada;
    	taila->next=headb;
    	//然后使用排序算法
    	struct node *p1;
    	int temp1,temp2;
    	for(p=head;p!=NULL;p=p->next){
    		for(p1=p;p1->next!=NULL;p1=p1->next){
    			if((p1->num) > (p1->next->num)){
    				temp1=p1->num;
    				temp2=p1->score;
    				p1->num=p1->next->num;
    				p1->score=p1->next->score;
    				p1->next->num=temp1;
    				p1->next->score=temp2;
    			}
    		}
    	} 
        /******end******/
        /* 将合并后的链表进行输出 */
        p = head;
        while (p != NULL) 
        {
            printf("%d %d\n", p->num, p->score);
            p = p->next;
        }
        return 0;
    }
    

    43 链栈

    翔哥代码

    /*
     *  文件名:LinkStack.c
     *	链栈的实现
     *	版本:1.0
     *	时间:2016.09.26
     *	作者:wangx
     *	假定条件: 假设元素的基本类型为int,且每个元素只有一个整数信息需要压栈
     *			
    */
    
    #include "malloc.h" 
    #include "stdio.h"
    
    #define PARAM_ERROR -1
    #define MALLOC_ERROR -2
    
    typedef  int TElemType;
    typedef struct SNode
    {
    	TElemType data;
       struct SNode *next;
    }StackNode;
    
    typedef struct 
    {
    	StackNode *Top; //一重指针,指向栈顶结点
    }LinkStack, *PLinkStack; //PLinkStack是二重指针,等效于LinkStack *
    //此处定义了一个链栈类型,叫LinkStack,该结构只有一个数据成员,即一个指向栈顶结点的指针Top
    //因为链栈中不设置表头结点,也不需要栈底指针,所以只有一个Top指针变量来指向栈顶元素即可。同学们可以自行添加栈的其他辅助信息到这个结构里面,例如栈的当前深度之类的
    
     //初始化链栈,只需要将Top指针置空即可
     //子函数内改变Top指针的值,故形参为二级指针
    int InitStack(LinkStack **ppStack)
    {
       if (*ppStack== NULL) //参数校验,该二级指针必须要指向主调函数中的一个LinkStack *类型的指针变量,即该二级指针指向的东西必须存在!
    		return PARAM_ERROR;
    
    	*ppStack= (LinkStack*)malloc(sizeof(LinkStack));
    	(*ppStack)->Top= NULL;
    	return 0;
    }
    
    int ClearStack(LinkStack *pStack)
    {
    	StackNode *pTemp, *pNext;
    
    	if (pStack== NULL)
    		return PARAM_ERROR; //栈如果不存在,返回错误码。注意,空栈的状态是允许的,即允许pStack->Top==NULL
    
    	pTemp= pStack->Top;
    	while(pTemp!= NULL)
    	{
    		pNext= pTemp->next; 
    		free(pTemp);
    		pTemp= pNext;
    	}
    	return 0;
    }
    
    //因为链栈无表头,所以清空和销毁操作是同样的操作
    int DestroyStack(LinkStack **ppStack)
    {
       if (*ppStack== NULL)
    		return PARAM_ERROR; //栈如果不存在,返回错误码。注意,空栈的状态是允许的,即允许pStack->Top==NULL
    
    	ClearStack(*ppStack);
    	free(*ppStack);
    	*ppStack= NULL;
    	return 0;
    }
    
    int Push(LinkStack *pStack, TElemType Value)
     {
       StackNode *p;
       if (pStack== NULL)
    		return PARAM_ERROR; //栈如果不存在,返回错误码。注意,空栈的状态是允许的,即允许pStack->Top==NULL
       p=(StackNode *)malloc(sizeof(StackNode));
       if(!p)
         return MALLOC_ERROR;
       p->data=Value;
       //头插法入栈  必须用头插法入栈
       p->next=pStack->Top;  
       pStack->Top=p;
       
       return 0;
     }
    
    int Pop(LinkStack *pStack, TElemType *pValue)
    {
    	StackNode *p;
    	if (pStack== NULL || pStack->Top == NULL || pValue==NULL) 
    		return PARAM_ERROR; //空栈无数据可返回,返回错误码
    	p= pStack->Top;  //临时指针指向栈顶结点
    	pStack->Top= pStack->Top->next;  //调整栈顶指针,指向下一个结点(出栈后的新栈顶结点)
    
    	*pValue= p->data;  //将原栈顶结点的数据值取出,返回给主调函数使用
    	free(p);  //销毁原栈顶结点
    	p=NULL;
    	return 0;
    }
    
    //判断一个栈是否为空栈
    int IsStackEmpty(LinkStack *pStack)
    {
    	if (pStack==NULL) //参数校验
    		return PARAM_ERROR;
    
    	if (pStack->Top == NULL) //如果是空栈
    		return 1;  //空栈返回1
    	else
    		return 0;
    
    }
    
    int main()
    {
    	TElemType value;
    	LinkStack *pStack;
    	InitStack(&pStack);
    	Push(pStack, 10);
    	Push(pStack, 20);
    	Push(pStack, 30);
    	Push(pStack, 40);
    //	DestroyStack(&pStack);
    
    	while (!IsStackEmpty(pStack))
    	{
    		Pop(pStack, &value);
    		printf("%d  ", value);
    	}
    	DestroyStack(&pStack);
    	return 0;
    }
    

    44 循环队列

    翔哥代码

    //1. 循环队列为空:Q.rear=Q.front
    //2. 循环队列满:Q.front=(Q.rear+1)   %   maxsize
    //3. 求循环队列长度 (Q.rear-Q.front+maxsize)%maxsize
    /*
     *  文件名:SeqQueue.c
     *	循环队列的实现
     *	版本:1.0
     *	时间:2016.06.26
     *	作者:wangx
     *	假定条件: 假设元素的基本类型为整数int
     *			
    */
    //代码3. ---------顺序结构下的循环队列基本结构定义代码---------//
    //文件名:SeqQueue.c
    #include "stdio.h"
    #include "malloc.h"
    
    #define MAXQSIZE 10        //假定数组长度为10
    typedef int QElemType;     //假定队列元素为比较简单的int型
    typedef struct
    {
        QElemType *base; //注意,连续存储空间需要在函数中动态申请,此处只是定义了指向该空间的指针
        int front; //队头指针,若队列不空,指向队列头元素的下标
        int rear;  //队尾指针,若队列不空,指向队列尾元素的下一个空位下标
    }SeqQueue;
    
    //代码3. ---------顺序结构下的“创建并初始化一个队列”操作算法代码---------//
    //文件名:SeqQueue.c
    //因为涉及到可能更改指向队列的指针值,所以采用二重指针ppQ为参数,以便返回
    int InitQueue(SeqQueue **ppQ)
    { 
        //创建循环队列的基本结构,诞生base、front和rear
        *ppQ= (SeqQueue *)malloc(sizeof(SeqQueue));
        if (!*ppQ) return -1;
        //创建循环队列的数组载体结构,诞生base指向的数组空间
        (*ppQ)->base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
        if(!(*ppQ)->base)
        {
            free(*ppQ);
            return -1;
        }
        //front和rear相等,初始化设其都为0(也可以不从0开始)
        (*ppQ)->front=(*ppQ)->rear=0;
        return 0;
    }
    
    //代码3. ---------顺序结构下的“队列销毁”操作算法代码---------//
    //文件名:SeqQueue.c
    //因为涉及到可能更改指向队列的指针值,所以采用二重指针ppQ为参数,以便返回
    int DestroyQueue(SeqQueue **ppQ)
    { /* 销毁队列Q,Q不再存在 */
       if((*ppQ)->base)
         free((*ppQ)->base);
       if(*ppQ)
         free(*ppQ);
       *ppQ= NULL;
       return 0;
    }
    
    //代码3. ---------顺序结构下的“清空队列”操作算法代码---------//
    //文件名:SeqQueue.c
    //函数要求队列本身是已存在的
    int ClearQueue(SeqQueue *pQ)
    {
        if (pQ==NULL) return -1;
        pQ->front=pQ->rear=0;    //注意,并不需要对数组中已存在的元素置为0或空
        return 0;
    }
    
    //代码3. ---------顺序结构下的“判断队列是否为空”操作算法代码---------//
    //文件名:SeqQueue.c
    //函数要求队列本身是已存在的,否则返回-1
    //若队列pQ为空队列,则返回1,否则返回0
    int QueueIsEmpty(SeqQueue *pQ)
    {
        if (pQ== NULL) return -1;
        if(pQ->front==pQ->rear) /* 队列空的标志 */
            return 1;
        else
            return 0;
    }
    
    //代码3. ---------顺序结构下的"获取队列元素个数"操作算法代码---------//
    //文件名:SeqQueue.c
    //函数要求队列本身是已存在的,否则返回-1
    int GetQueueLength(SeqQueue *pQ)
    {
        int length;
        if (pQ== NULL) return -1;
        //循环队列中,rear的值有可能会小于front,故要加个MAXQSIZE再来取余
        length= (pQ->rear-pQ->front+MAXQSIZE)%MAXQSIZE;
        return length;
    }
    
    //代码3. ---------顺序结构下的"获取队头元素的值"操作算法代码---------//
    //文件名:SeqQueue.c
    //队列为空或者队列不存在,均返回-1,否则将队头元素的值存储到地址为pe的空间中,并返回0
    int GetHead(SeqQueue *pQ,QElemType *pe)
    {
        if (pQ== NULL) return -1;
        /* 若队列不空,则用e返回Q的队头元素,并返回0,否则返回-1 */
        if(pQ->front==pQ->rear) /* 队列空 */
            return -1;
        *pe=pQ->base[pQ->front];
        return 0;
    }
    
    //代码3. ---------顺序结构下的"进队列"操作算法代码---------//
    //文件名:SeqQueue.c
    //队列不存在,返回-1;队列满,返回-2;正常进队返回0
    //注意此时进队元素是普通的值传递方式	
    int EnQueue(SeqQueue *pQ, QElemType e)
    {
        if (pQ== NULL) return -1;
        if((pQ->rear+1)%MAXQSIZE==pQ->front) //如果队列满,产生真上溢,放弃操作
            return -2;
        pQ->base[pQ->rear]=e;                //先填值,注意,入队列和front无关
        pQ->rear=(pQ->rear+1)%MAXQSIZE;      //再循环加1
        return 0;
    }
    
    //代码3. ---------顺序结构下的"出队列"操作算法代码---------//
    //文件名:SeqQueue.c
    //队列不存在,返回-1;队列空,返回-2;正常出队返回0
    //注意此时出队元素pe采用的是参数的地址传递方式	
    int DeQueue(SeqQueue *pQ,QElemType *pe)
    {
        if (pQ== NULL) return -1;
        if(pQ->front==pQ->rear)              //如果队列为空,直接放弃操作
            return -2;
        *pe=pQ->base[pQ->front];             //先读值,出队列操作与rear无关
        pQ->front=(pQ->front+1)%MAXQSIZE;    //再循环加1
        return 0;
    }
    
    int main()
    {
        SeqQueue *pQ;
        InitQueue(&pQ);
    	DestroyQueue(&pQ);
    	return 0;
    }
    

    45 链队列

    翔哥代码

    /*
     *  文件名:LinkQueue.c
     *	链队列的实现
     *	版本:1.0
     *	时间:2016.06.26
     *	作者:wangx
     *	假定条件: 假设元素的基本类型为int类型
     *			
    */
    
    //链队列
    #include "stdio.h"
    #include "malloc.h"
     
    typedef int QElemType;         //假设队列元素类型为int,读者可更换为其他类型
    
    typedef struct QNode          //定义单向链表的结点类型名为QNode,并定义指向
    {                             //这种类型的指针的类型名称为QueuePtr
        QElemType data;
        struct QNode *next;
    }QNode, *QueuePtr;
    /*将队头指针和队尾指针打包封装,定义出新的结构体类型,
      即链队列的数据类型,取名为LinkQueue
    */
    typedef struct                
    {
        QueuePtr front;           // 队头指针
        QueuePtr rear;            // 队尾指针
    }LinkQueue;
    
    //代码3. ---------链队列的创建和初始化操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的二重指针ppQ为参数,在函数内构建B和C部分,实现关联
    int InitQueue(LinkQueue **ppQ)
    { 
        (*ppQ)=(LinkQueue *)malloc(sizeof(LinkQueue));
        if(!(*ppQ))  return -1;
        (*ppQ)->front=(*ppQ)->rear=(QueuePtr)malloc(sizeof(QNode));
        if(!(*ppQ)->front)  return -2;
        (*ppQ)->front->next=NULL;
        return 0;
    }
    
    //代码3. ---------链队列的“判断是否为空”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数
    // 如果参数有误,返回-1; 若Q为空队列,则返回1,否则返回0 
    int QueueIsEmpty(LinkQueue *pQ)
    { 
        if (pQ==NULL) return -1;
        if(pQ->front==pQ->rear)
            return 1;
        else
            return 0;
    }
    
    //代码3. ---------链队列的“读取队头元素”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数
    // 如果队列存在且非空,获取队头元素的值,以地址传递的方式通过e传出;如果参数有误,返回-1;  
    int GetQueueHead(LinkQueue *pQ,QElemType *e)
    {
        if(QueueIsEmpty(pQ)!=0)
            return -1;
        *e=pQ->front->next->data;
        return 0;
    }
    
    //代码3. ---------链队列的“入队列”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数
    // 如果队列不存在或操作异常,返回负数; 反之,成功操作返回0  
    int EnQueue(LinkQueue *pQ,QElemType e)
    { 
        QueuePtr R;
        if (pQ==NULL) return -1;
        // 为新进元素e申请结点空间,并让指针R指向。 
        R=(QueuePtr)malloc(sizeof(QNode));
        if(!R) return -2;          //内存申请失败,返回-2
        R->data=e;
        R->next=NULL;
        //进行入队的指针关联
        pQ->rear->next=R;
        pQ->rear=R;
        return 0;
    }
    
    //代码3. ---------链队列的“出队列”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数,参数pe为地址传递形式
    //将队头元素用指针e返回;若是唯一元素,需调整rear指针
    //如果队列不存在或队列为空,返回-1; 反之,成功操作返回0  
    int DeQueue(LinkQueue *pQ,QElemType *pe)
    {
        QueuePtr R;
        if (pQ==NULL) return -1;            //队列不存在,返回-1
        if(pQ->front==pQ->rear) return -2;  //队列为空,返回-2
            
        R=pQ->front->next;			        //令R指向表头后的第一个结点
        *pe=R->data;
        pQ->front->next=R->next;
        if(pQ->rear==R)                     //如果第一个结点也是最后一个结点
            pQ->rear=pQ->front;
        free(R);
        return 0;
    }
    
    //代码3. ---------链队列的“求队列长度”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数
    int GetQueueLength(LinkQueue *pQ)
    {
        QueuePtr p;
        int count=0;
        p=pQ->front;
        while(p!=pQ->rear)
        {
            count++;
            p=p->next;
        }
        return count;
    }
    
    //代码3. ---------链队列的“清空队列”操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的一重指针pQ为参数
    //清空后,front和rear指针均指向表头结点
    int ClearQueue(LinkQueue *pQ)
    { /* 将Q清为空队列 */
        QueuePtr p,q;
    	if (pQ==NULL) return -1;
        pQ->rear=pQ->front;    //rear指针归位
        p=pQ->front->next;     //p指针指向表中第一个数据结点
        pQ->front->next=NULL;  //表头结点的next域归位
        while(p!=NULL)         //循环释放每个数据结点的空间
        {
            q=p;
            p=p->next;
            free(q);
        }
        return 0;
    }
    
    
    //代码3. ---------链队列的销毁操作---------//
    //文件名:LinkQueue.c
    //以指向LinkQueue结构体的二重指针ppQ为参数
    //在函数内先清空队列数据,然后销毁空队列的B、C部分,并归位队列指针
    int DestroyQueue(LinkQueue **ppQ)
    { 
        if (ClearQueue(*ppQ)==-1) return -1;
        free((*ppQ)->front);
        free(*ppQ);
        ppQ= NULL;
        return 0;
    }
    
    
    int main()
    {
    	int k,flag;
    	LinkQueue *pQ= NULL;
    	InitQueue(&pQ);
    	scanf("%d",&k);
    	while(k != 0)
    	{
    		EnQueue(pQ,k);
    		scanf("%d",&k);
    	}
    	while(QueueIsEmpty(pQ) != 1)
    	{
    		DeQueue(pQ,&k);
    		printf("%d ",k);
    	}
    }
    

    46 二分查找

    样例输入

    请输入10个单调递增的数:5 10 13 18 20 24 27 31 33 39
    要查找的数:20
    

    样例输出

    20在4位置
    

    代码

    #include <stdio.h>
    int BinarySearch(int *a,int n,int key);
    int main(){
    	int a[10],i,pos,key;
    	printf("请输入10个单调递增的数:");
    	for(i=0;i<10;i++){
    		scanf("%d", &a[i]);
    	}
    	printf("要查找的数:");
    	scanf("%d",&key);
    	pos=BinarySearch(a,10,key);
    	if(pos==-1){
    		printf("找不要要查找的数\n"); 
    	}
    	else{
    		printf("%d在%d位置\n",key,pos);
    	} 
    }
    int BinarySearch(int *a,int n,int key){
    	int low,high,mid;
    	low=0;high=n-1;
    	while(low<=high){
    		mid=low+high/2;
    		if(a[mid]<key){
    			low=mid+1;
    		}
    		else if(a[mid]>key){
    			high=mid-1;
    		}
    		else{
    			return mid;
    		}
    	}
    	return -1;
    }
    

    参考链接

    • https://blog.csdn.net/mrbourne/category_1925119.html
    展开全文
  • c语言经典例题

    2011-10-21 16:15:19
    c语言经典例题例如:题目:有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少? 1.程序分析:可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去  掉不满足条件的排列。...
  • C语言经典例题(菜鸟教程100例)

    万次阅读 多人点赞 2018-09-04 18:47:59
    学习c语言基础,怎么能少了菜鸟教程上的100道例题呢,这里整理一下每道题的链接,希望大家能享受学习的乐趣 1,有1,2,3,4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少? 2,企业发放的奖金根据...

    学习c语言基础,怎么能少了菜鸟教程上的100道例题呢,这里整理一下每道题的链接,希望大家能享受学习的乐趣

    1,有1,2,3,4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?

    2,企业发放的奖金根据利润提成。其实就是考分类。

    3,一个整数,它加上100后是一个完全平方数,再加上168又是一个完全平方数,请问该数是多少?

    4,输入某年某月某日,判断这一天是这一年的第几天?

    5,输入三个整数X,Y,Z,请把这三个数由小到大输出。

    6,用*号输出字母Ç的图案。

    7,输出特殊图案。

    8,输出9 * 9口诀。

    9,要求输出国际象棋棋盘。

    10,打印楼梯,同时在楼梯上方打印两个笑脸。

    11,古典问题(兔子生崽):有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?(输出前40个月即可)

    12,判断101到200之间的素数。

    13,打印出所有的“水仙花数”,所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数本身例如:153是一个“水仙花数”,因为153 = 1的三次方+5的三次方+3的三次方。

    14,将一个正整数分解质量数例如:输入90,打印出90 = 2 * 3 * 3 * 5。

    15,利用条件运算符的嵌套来完成此题:学习成绩> = 90分的同学用甲表示,60-89分之间的用乙表示,60分以下的用Ç表示。

    16,输入两个正整数米和N,求其最大公约数和最小公倍数。

    17,输入一行字符,分别统计出其中英文字母,空格,数字和其它字符的个数。

    18,求S = A + AA + AAA + AAAA + AA ...一个的值,其中一个是一个数字。例如2 + 22 + 222 + 2222 + 22222(此时共有5个数相加),几个数相加有键盘控制。

    19,一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6 = 1 + 2 + 3.编程找出1000以内的所有完数。

    20,一球从100米高度自由落下,每次落地后反跳回原高度的一半;再落下,求它在第10次落地时,共经过多少米第10次反弹多高?

    21,猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时,见只剩下一个桃子了。求第一天共摘了多少。

    22,两个乒乓球队进行比赛,各出三人。甲队为A,B,C三人,乙队为X,Y,Z三人。已抽签决定比赛名单。有人向队员打听比赛的名单.A说他不和X比,C说他不和X,Z比,请编程序找出三队赛手的名单。

    23,打印出如下图案(菱形)。

    24,有一分数序列:2 / 1,3 / 2,5 / 3,8 / 5,13 / 8,21 / 13 ...求出这个数列的前20项之和。

    25,求1 + 2!+3!+ ... + 20!的和。

    26,利用递归方法求5!

    27,利用递归函数调用方式,将所输入的5个字符,以相反顺序打印出来。

    28,有5个人坐在一起,问第五个人多少岁?他说比第4个人大2岁。问第4个人岁数,他说比第3个人大2岁。问第三个人,又说比第2人大两岁。问第2个人,说比第一个人大两岁。最后问第一个人,他说是10岁。请问第五个人多大?

    29,给一个不多于5位的正整数,要求:一,求它是几位数,二,逆序打印出各位数字。

    30,一个5位数,判断它是不是回文数。即12321是回文数,个位与万位相同,十位与千位相同。

    31,请输入星期几的第一个字母来判断一下是星期几,如果第一个字母一样,则继续判断第二个字母。

    32,删除一个字符串中的指定字母,如:字符串“ACA”,删除其中的一个字母。

    33,判断一个数字是否为质数。

    34,练习函数调用。

    35,字符串反转,如将字符串“www.runoob.com”反转为“moc.boonur.www”。

    36,求100之内的素数。

    37,对10个数进行排序。

    38,求一个3×3矩阵对角线元素之和。

    39,有一个已经排好序的数组。现输入一个数,要求按原来的规律将它插入数组中。

    40,将一个数组逆序输出。

    41,学习静态定义静态变量的用法。

    42,学习使用自动定义变量的用法。

    43,学习使用静态的另一用法。

    44,学习使用外部的用法。

    45,学习使用寄存器定义变量的方法。

    46,宏的#定义命令练习。

    47,宏的#定义命令练习2。

    48,宏的#定义命令练习3。

    49,#if #ifdef和#ifndef的综合应用。

    50,#include的应用练习。

    参考:菜鸟教程-C语言经典100示例(后50)

    展开全文
  • C语言经典例题100

    2019-03-27 18:05:22
    C语言经典例题100,100道c语言例题,适合c语言初学者学习。
  • C语言经典例题100道(没错,就是你要找的那个)

    万次阅读 多人点赞 2020-07-14 15:44:01
    C语言经典例题100道(没错,就是你要找的那个) 希望可以帮助到你,加油!!! 【程序1】 题目:有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少? 1.程序分析:可填在百位、十位、个位的...

    C语言经典例题100道(没错,就是你要找的那个)

    希望可以帮助到你,加油!!!
    【程序1】
    题目:有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?
    1.程序分析:可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去
           掉不满足条件的排列。
    2.程序源代码:
    main()
    {
    int i,j,k;
    printf("\n");
    for(i=1;i<5;i++)    /以下为三重循环/
      for(j=1;j<5;j++) 
       for (k=1;k<5;k++)
        {
         if (i!=k&&i!=j&&j!=k)    /确保i、j、k三位互不相同/
         printf("%d,%d,%d\n",i,j,k);
        }
    }

    【程序2】
    题目:企业发放的奖金根据利润提成。利润(I)低于或等于10万元时,奖金可提10%;利润高
        于10万元,低于20万元时,低于10万元的部分按10%提成,高于10万元的部分,可可提
        成7.5%;20万到40万之间时,高于20万元的部分,可提成5%;40万到60万之间时高于
        40万元的部分,可提成3%;60万到100万之间时,高于60万元的部分,可提成1.5%,高于
        100万元时,超过100万元的部分按1%提成,从键盘输入当月利润I,求应发放奖金总数?
    1.程序分析:请利用数轴来分界,定位。注意定义时需把奖金定义成长整型。      
    2.程序源代码:
    main()
    {
    long int i;
    int bonus1,bonus2,bonus4,bonus6,bonus10,bonus;
    scanf("%ld",&i);
    bonus1=1000000.1;bonus2=bonus1+1000000.75;
    bonus4=bonus2+2000000.5;
    bonus6=bonus4+200000
    0.3;
    bonus10=bonus6+4000000.15;
      if(i<=100000)
       bonus=i
    0.1;
      else if(i<=200000)
          bonus=bonus1+(i-100000)*0.075;
         else if(i<=400000)
             bonus=bonus2+(i-200000)*0.05;
            else if(i<=600000)
                bonus=bonus4+(i-400000)*0.03;
               else if(i<=1000000)
                   bonus=bonus6+(i-600000)*0.015;
                  else
                   bonus=bonus10+(i-1000000)*0.01;
    printf(“bonus=%d”,bonus);
    }

    【程序3】
    题目:一个整数,它加上100后是一个完全平方数,再加上168又是一个完全平方数,请问该数是多少?
    1.程序分析:在10万以内判断,先将该数加上100后再开方,再将该数加上268后再开方,如果开方后
           的结果满足如下条件,即是结果。请看具体分析:
    2.程序源代码:
    #include “math.h”
    main()
    {
    long int i,x,y,z;
    for (i=1;i<100000;i++)
      { x=sqrt(i+100);   /x为加上100后开方后的结果/
       y=sqrt(i+268);   /y为再加上168后开方后的结果/
        if(xx==i+100&&yy==i+268)/如果一个数的平方根的平方等于该数,这说明此数是完全平方数/
         printf("\n%ld\n",i);
      }
    }

    【程序4】
    题目:输入某年某月某日,判断这一天是这一年的第几天?
    1.程序分析:以3月5日为例,应该先把前两个月的加起来,然后再加上5天即本年的第几天,特殊
           情况,闰年且输入月份大于3时需考虑多加一天。
    2.程序源代码:
    main()
    {
    int day,month,year,sum,leap;
    printf("\nplease input year,month,day\n");
    scanf("%d,%d,%d",&year,&month,&day);
    switch(month)/先计算某月以前月份的总天数/
    {
      case 1:sum=0;break;
      case 2:sum=31;break;
      case 3:sum=59;break;
      case 4:sum=90;break;
      case 5:sum=120;break;
      case 6:sum=151;break;
      case 7:sum=181;break;
      case 8:sum=212;break;
      case 9:sum=243;break;
      case 10:sum=273;break;
      case 11:sum=304;break;
      case 12:sum=334;break;
      default:printf(“data error”);break;
    }
    sum=sum+day;  /再加上某天的天数/
      if(year%4000||(year%40&&year%100!=0))/判断是不是闰年/
       leap=1;
      else
       leap=0;
    if(leap==1&&month>2)/如果是闰年且月份大于2,总天数应该加一天/
    sum++;
    printf(“It is the %dth day.”,sum);}

    【程序5】
    题目:输入三个整数x,y,z,请把这三个数由小到大输出。
    1.程序分析:我们想办法把最小的数放到x上,先将x与y进行比较,如果x>y则将x与y的值进行交换,
           然后再用x与z进行比较,如果x>z则将x与z的值进行交换,这样能使x最小。
    2.程序源代码:
    main()
    {
    int x,y,z,t;
    scanf("%d%d%d",&x,&y,&z);
    if (x>y)
    {t=x;x=y;y=t;} /交换x,y的值/
    if(x>z)
    {t=z;z=x;x=t;}/交换x,z的值/
    if(y>z)
    {t=y;y=z;z=t;}/交换z,y的值/
    printf(“small to big: %d %d %d\n”,x,y,z);
    }

    【程序6】
    题目:用号输出字母C的图案。
    1.程序分析:可先用’
    '号在纸上写出字母C,再分行输出。
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    printf(“Hello C-world!\n”);
    printf(" ****\n");
    printf(" *\n");
    printf(" * \n");
    printf(" ****\n");
    }

    【程序7】
    题目:输出特殊图案,请在c环境中运行,看一看,Very Beautiful!
    1.程序分析:字符共有256个。不同字符,图形不一样。      
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    char a=176,b=219;
    printf("%c%c%c%c%c\n",b,a,a,a,b);
    printf("%c%c%c%c%c\n",a,b,a,b,a);
    printf("%c%c%c%c%c\n",a,a,b,a,a);
    printf("%c%c%c%c%c\n",a,b,a,b,a);
    printf("%c%c%c%c%c\n",b,a,a,a,b);}

    【程序8】
    题目:输出99口诀。
    1.程序分析:分行与列考虑,共9行9列,i控制行,j控制列。
    2.程序源代码:
    #include “stdio.h”
    main()
    {
      int i,j,result;
      printf("\n");
      for (i=1;i<10;i++)
       { for(j=1;j<10;j++)
         {
          result=i
    j;
          printf("%d*%d=%-3d",i,j,result);/-3d表示左对齐,占3位/
         }
        printf("\n");/每一行后换行/
       }
    }

    【程序9】
    题目:要求输出国际象棋棋盘。
    1.程序分析:用i控制行,j来控制列,根据i+j的和的变化来控制输出黑方格,还是白方格。
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int i,j;
    for(i=0;i<8;i++)
      {
       for(j=0;j<8;j++)
        if((i+j)%2==0)
         printf("%c%c",219,219);
        else
         printf(" “);
        printf(”\n");
      }
    }

    【程序10】
    题目:打印楼梯,同时在楼梯上方打印两个笑脸。
    1.程序分析:用i控制行,j来控制列,j根据i的变化来控制输出黑方格的个数。
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int i,j;
    printf("\1\1\n");/输出两个笑脸/
    for(i=1;i<11;i++)
      {
      for(j=1;j<=i;j++)
       printf("%c%c",219,219);
      printf("\n");
      }
    }经典C语言程序设计100例11-20
    【程序11】
    题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月
        后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?
    1.程序分析: 兔子的规律为数列1,1,2,3,5,8,13,21…
    2.程序源代码:
    main()
    {
    long f1,f2;
    int i;
    f1=f2=1;
    for(i=1;i<=20;i++)
      { printf("%12ld %12ld",f1,f2);
        if(i%2==0) printf("\n");/控制输出,每行四个/
        f1=f1+f2; /前两个月加起来赋值给第三个月/
        f2=f1+f2; /前两个月加起来赋值给第三个月/
      }
    }

    【程序12】
    题目:判断101-200之间有多少个素数,并输出所有素数。
    1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除,
           则表明此数不是素数,反之是素数。       
    2.程序源代码:
    #include “math.h”
    main()
    {
      int m,i,k,h=0,leap=1;
      printf("\n");
      for(m=101;m<=200;m++)
       { k=sqrt(m+1);
        for(i=2;i<=k;i++)
          if(m%i0)
           {leap=0;break;}
        if(leap) {printf("%-4d",m);h++;
             if(h%10
    0)
             printf("\n");
            }
        leap=1;
       }
      printf("\nThe total is %d",h);
    }

    【程序13】
    题目:打印出所有的“水仙花数”,所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数
        本身。例如:153是一个“水仙花数”,因为153=1的三次方+5的三次方+3的三次方。
    1.程序分析:利用for循环控制100-999个数,每个数分解出个位,十位,百位。
    2.程序源代码:
    main()
    {
    int i,j,k,n;
    printf("'water flower’number is:");
      for(n=100;n<1000;n++)
      {
       i=n/100;/分解出百位/
       j=n/10%10;/分解出十位/
       k=n%10;/分解出个位/
       if(i100+j10+k==iii+jjj+kkk)
        {
        printf("%-5d",n);
        }
      }
    printf("\n");
    }

    【程序14】
    题目:将一个正整数分解质因数。例如:输入90,打印出90=2335。
    程序分析:对n进行分解质因数,应先找到一个最小的质数k,然后按下述步骤完成:
    (1)如果这个质数恰等于n,则说明分解质因数的过程已经结束,打印出即可。
    (2)如果n<>k,但n能被k整除,则应打印出k的值,并用n除以k的商,作为新的正整数你n,
      重复执行第一步。
    (3)如果n不能被k整除,则用k+1作为k的值,重复执行第一步。
    2.程序源代码:
    /
    zheng int is divided yinshu*/
    main()
    {
    int n,i;
    printf("\nplease input a number:\n");
    scanf("%d",&n);
    printf("%d=",n);
    for(i=2;i<=n;i++)
      {
       while(n!=i)
       {
        if(n%i==0)
        { printf("%d*",i);
         n=n/i;
        }
        else
         break;
       }
    }
    printf("%d",n);}

    【程序15】
    题目:利用条件运算符的嵌套来完成此题:学习成绩>=90分的同学用A表示,60-89分之间的用B表示,
        60分以下的用C表示。
    1.程序分析:(a>b)?a:b这是条件运算符的基本例子。
    2.程序源代码:
    main()
    {
      int score;
      char grade;
      printf(“please input a score\n”);
      scanf("%d",&score);
      grade=score>=90?‘A’:(score>=60?‘B’:‘C’);
      printf("%d belongs to %c",score,grade);
    }

    【程序16】
    题目:输入两个正整数m和n,求其最大公约数和最小公倍数。
    1.程序分析:利用辗除法。
    2.程序源代码:
    main()
    {
      int a,b,num1,num2,temp;
      printf(“please input two numbers:\n”);
      scanf("%d,%d",&num1,&num2);
      if(num1<num2)
     { temp=num1;
       num1=num2; 
       num2=temp;
      }
    a=num1;b=num2;
    while(b!=0)/利用辗除法,直到b为0为止/
      {
       temp=a%b;
       a=b;
       b=temp;
      }
    printf(“gongyueshu:%d\n”,a);
    printf(“gongbeishu:%d\n”,num1*num2/a);
    }

    【程序17】
    题目:输入一行字符,分别统计出其中英文字母、空格、数字和其它字符的个数。
    1.程序分析:利用while语句,条件为输入的字符不为’\n’.
          
    2.程序源代码:
    #include “stdio.h”
    main()
    {char c;
      int letters=0,space=0,digit=0,others=0;
      printf(“please input some characters\n”);
      while((c=getchar())!=’\n’)
      {
      if(c>=‘a’&&c<=‘z’||c>=‘A’&&c<=‘Z’)
       letters++;
      else if(c==’ ')
       space++;
        else if(c>=‘0’&&c<=‘9’)
            digit++;
          else
            others++;
    }
    printf(“all in all:char=%d space=%d digit=%d others=%d\n”,letters,
    space,digit,others);
    }

    【程序18】
    题目:求s=a+aa+aaa+aaaa+aa…a的值,其中a是一个数字。例如2+22+222+2222+22222(此时
        共有5个数相加),几个数相加有键盘控制。
    1.程序分析:关键是计算出每一项的值。
    2.程序源代码:
    main()
    {
      int a,n,count=1;
      long int sn=0,tn=0;
      printf(“please input a and n\n”);
      scanf("%d,%d",&a,&n);
      printf(“a=%d,n=%d\n”,a,n);
      while(count<=n)
      {
       tn=tn+a;
       sn=sn+tn;
       a=a*10;
       ++count;
      }
    printf(“a+aa+…=%ld\n”,sn);
    }

    【程序19】
    题目:一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6=1+2+3.编程
        找出1000以内的所有完数。

    1. 程序分析:请参照程序<–上页程序14.
      2.程序源代码:
      main()
      {
      static int k[10];
      int i,j,n,s;
      for(j=2;j<1000;j++)
        {
        n=-1;
        s=j;
         for(i=1;i<j;i++)
        {
          if((j%i)0)
          { n++;
           s=s-i;
           k[n]=i;
          }
         }
        if(s
      0)
        {
        printf("%d is a wanshu",j);
        for(i=0;i<n;i++)
       printf("%d,",k[i]);
        printf("%d\n",k[n]);
        }
      }
      }

    【程序20】
    题目:一球从100米高度自由落下,每次落地后反跳回原高度的一半;再落下,求它在
        第10次落地时,共经过多少米?第10次反弹多高?
    1.程序分析:见下面注释
    2.程序源代码:
    main()
    {
    float sn=100.0,hn=sn/2;
    int n;
    for(n=2;n<=10;n++)
      {
       sn=sn+2*hn;/第n次落地时共经过的米数/
       hn=hn/2; /第n次反跳高度/
      }
    printf(“the total of road is %f\n”,sn);
    printf(“the tenth is %f meter\n”,hn);
    }
    【程序21】
    题目:猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个
        第二天早上又将剩下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下
        的一半零一个。到第10天早上想再吃时,见只剩下一个桃子了。求第一天共摘了多少。
    1.程序分析:采取逆向思维的方法,从后往前推断。
    2.程序源代码:
    main()
    {
    int day,x1,x2;
    day=9;
    x2=1;
    while(day>0)
      {x1=(x2+1)*2;/第一天的桃子数是第2天桃子数加1后的2倍/
      x2=x1;
      day–;
      }
    printf(“the total is %d\n”,x1);
    }

    【程序22】
    题目:两个乒乓球队进行比赛,各出三人。甲队为a,b,c三人,乙队为x,y,z三人。已抽签决定
        比赛名单。有人向队员打听比赛的名单。a说他不和x比,c说他不和x,z比,请编程序找出
        三队赛手的名单。
    1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除,
           则表明此数不是素数,反之是素数。       
    2.程序源代码:
    main()
    {
    char i,j,k;/i是a的对手,j是b的对手,k是c的对手/
    for(i=‘x’;i<=‘z’;i++)
      for(j=‘x’;j<=‘z’;j++)
      {
      if(i!=j)
       for(k=‘x’;k<=‘z’;k++)
       { if(i!=k&&j!=k)
        { if(i!=‘x’&&k!=‘x’&&k!=‘z’)
        printf(“order is a–%c\tb–%c\tc–%c\n”,i,j,k);
        }
       }
      }
    }

    【程序23】
    题目:打印出如下图案(菱形)
    *






    1.程序分析:先把图形分成两部分来看待,前四行一个规律,后三行一个规律,利用双重
           for循环,第一层控制行,第二层控制列。
    2.程序源代码:
    main()
    {
    int i,j,k;
    for(i=0;i<=3;i++)
      {
      for(j=0;j<=2-i;j++)
       printf(" “);
      for(k=0;k<=2i;k++)
       printf("
    ”);
      printf("\n");
      }
    for(i=0;i<=2;i++)
      {
      for(j=0;j<=i;j++)
       printf(" “);
      for(k=0;k<=4-2i;k++)
       printf("
    ”);
      printf("\n");
      }
    }

    【程序24】
    题目:有一分数序列:2/1,3/2,5/3,8/5,13/8,21/13…求出这个数列的前20项之和。
    1.程序分析:请抓住分子与分母的变化规律。
    2.程序源代码:
    main()
    {
    int n,t,number=20;
    float a=2,b=1,s=0;
    for(n=1;n<=number;n++)
      {
      s=s+a/b;
      t=a;a=a+b;b=t;/这部分是程序的关键,请读者猜猜t的作用/
      }
    printf(“sum is %9.6f\n”,s);
    }

    【程序25】
    题目:求1+2!+3!+…+20!的和
    1.程序分析:此程序只是把累加变成了累乘。
    2.程序源代码:
    main()
    {
    float n,s=0,t=1;
    for(n=1;n<=20;n++)
      {
      t*=n;
      s+=t;
      }
    printf(“1+2!+3!..+20!=%e\n”,s);
    }

    【程序26】
    题目:利用递归方法求5!。
    1.程序分析:递归公式:fn=fn_14!
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int i;
    int fact();
    for(i=0;i<5;i++)
      printf("\40:%d!=%d\n",i,fact(i));
    }
    int fact(j)
    int j;
    {
    int sum;
    if(j==0)
      sum=1;
    else
      sum=j
    fact(j-1);
    return sum;
    }

    【程序27】
    题目:利用递归函数调用方式,将所输入的5个字符,以相反顺序打印出来。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int i=5;
    void palin(int n);
    printf("\40:");
    palin(i);
    printf("\n");
    }
    void palin(n)
    int n;
    {
    char next;
    if(n<=1)
      {
      next=getchar();
      printf("\n\0:");
      putchar(next);
      }
    else
      {
      next=getchar();
      palin(n-1);
      putchar(next);
      }
    }

    【程序28】
    题目:有5个人坐在一起,问第五个人多少岁?他说比第4个人大2岁。问第4个人岁数,他说比第
        3个人大2岁。问第三个人,又说比第2人大两岁。问第2个人,说比第一个人大两岁。最后
        问第一个人,他说是10岁。请问第五个人多大?
    1.程序分析:利用递归的方法,递归分为回推和递推两个阶段。要想知道第五个人岁数,需知道
           第四人的岁数,依次类推,推到第一人(10岁),再往回推。
    2.程序源代码:
    age(n)
    int n;
    {
    int c;
    if(n==1) c=10;
    else c=age(n-1)+2;
    return©;
    }
    main()
    { printf("%d",age(5));
    }

    【程序29】
    题目:给一个不多于5位的正整数,要求:一、求它是几位数,二、逆序打印出各位数字。

    1. 程序分析:学会分解出每一位数,如下解释:(这里是一种简单的算法,师专数002班赵鑫提供)
      2.程序源代码:
      main( )
      {
      long a,b,c,d,e,x;
      scanf("%ld",&x);
      a=x/10000;/分解出万位/
      b=x%10000/1000;/分解出千位/
      c=x%1000/100;/分解出百位/
      d=x%100/10;/分解出十位/
      e=x%10;/分解出个位/
      if (a!=0) printf(“there are 5, %ld %ld %ld %ld %ld\n”,e,d,c,b,a);
      else if (b!=0) printf(“there are 4, %ld %ld %ld %ld\n”,e,d,c,b);
         else if (c!=0) printf(" there are 3,%ld %ld %ld\n",e,d,c);
           else if (d!=0) printf(“there are 2, %ld %ld\n”,e,d);
             else if (e!=0) printf(" there are 1,%ld\n",e);
      }

    【程序30】
    题目:一个5位数,判断它是不是回文数。即12321是回文数,个位与万位相同,十位与千位相同。   
    1.程序分析:同29例
    2.程序源代码:
    main( )
    {
    long ge,shi,qian,wan,x;
    scanf("%ld",&x);
    wan=x/10000;
    qian=x%10000/1000;
    shi=x%100/10;
    ge=x%10;
    if (gewan&&shiqian)/个位等于万位并且十位等于千位/
      printf(“this number is a huiwen\n”);
    else
      printf(“this number is not a huiwen\n”);
    }
    【程序31】
    题目:请输入星期几的第一个字母来判断一下是星期几,如果第一个字母一样,则继续
        判断第二个字母。
    1.程序分析:用情况语句比较好,如果第一个字母一样,则判断用情况语句或if语句判断第二个字母。
    2.程序源代码:
    #include <stdio.h>
    void main()
    {
    char letter;
    printf(“please input the first letter of someday\n”);
    while ((letter=getch())!=‘Y’)/当所按字母为Y时才结束/
    { switch (letter)
    {case ‘S’:printf(“please input second letter\n”);
          if((letter=getch())‘a’)
           printf(“saturday\n”);
          else if ((letter=getch())
    ‘u’)
              printf(“sunday\n”);
            else printf(“data error\n”);
          break;
    case ‘F’:printf(“friday\n”);break;
    case ‘M’:printf(“monday\n”);break;
    case ‘T’:printf(“please input second letter\n”);
          if((letter=getch())‘u’)
           printf(“tuesday\n”);
          else if ((letter=getch())
    ‘h’)
              printf(“thursday\n”);
            else printf(“data error\n”);
          break;
    case ‘W’:printf(“wednesday\n”);break;
    default: printf(“data error\n”);
       }
      }
    }

    【程序32】
    题目:Press any key to change color, do you want to try it. Please hurry up!
    1.程序分析:            
    2.程序源代码:
    #include <conio.h>
    void main(void)
    {
    int color;
    for (color = 0; color < 8; color++)
      {
      textbackground(color);/设置文本的背景颜色/
      cprintf(“This is color %d\r\n”, color);
      cprintf(“Press any key to continue\r\n”);
      getch();/输入字符看不见/
      }
    }

    【程序33】
    题目:学习gotoxy()与clrscr()函数   
    1.程序分析:
    2.程序源代码:
    #include <conio.h>
    void main(void)
    {
    clrscr();/清屏函数/
    textbackground(2);
    gotoxy(1, 5);/定位函数/
    cprintf(“Output at row 5 column 1\n”);
    textbackground(3);
    gotoxy(20, 10);
    cprintf(“Output at row 10 column 20\n”);
    }

    【程序34】
    题目:练习函数调用

    1. 程序分析:
      2.程序源代码:
      #include <stdio.h>
      void hello_world(void)
      {
      printf(“Hello, world!\n”);
      }
      void three_hellos(void)
      {
      int counter;
      for (counter = 1; counter <= 3; counter++)
      hello_world();/调用此函数/
      }
      void main(void)
      {
      three_hellos();/调用此函数/
      }

    【程序35】
    题目:文本颜色设置
    1.程序分析:
    2.程序源代码:
    #include <conio.h>
    void main(void)
    {
    int color;
    for (color = 1; color < 16; color++)
      {
      textcolor(color);/设置文本颜色/
      cprintf(“This is color %d\r\n”, color);
      }
    textcolor(128 + 15);
    cprintf(“This is blinking\r\n”);
    }

    【程序36】
    题目:求100之内的素数   
    1.程序分析:
    2.程序源代码:
    #include <stdio.h>
    #include “math.h”
    #define N 101
    main()
    {
    int i,j,line,a[N];
    for(i=2;i<N;i++) a[i]=i;
    for(i=2;i<sqrt(N);i++)
      for(j=i+1;j<N;j++)
      {
       if(a[i]!=0&&a[j]!=0)
       if(a[j]%a[i]0)
       a[j]=0;}
    printf("\n");
    for(i=2,line=0;i<N;i++)
    {
      if(a[i]!=0)
      {printf("%5d",a[i]);
      line++;}
      if(line
    10)
      {printf("\n");
    line=0;}
    }
    }

    【程序37】
    题目:对10个数进行排序
    1.程序分析:可以利用选择法,即从后9个比较过程中,选择一个最小的与第一个元素交换,
           下次类推,即用第二个元素与后8个进行比较,并进行交换。       
    2.程序源代码:
    #define N 10
    main()
    {int i,j,min,tem,a[N];
    /input data/
    printf(“please input ten num:\n”);
    for(i=0;i<N;i++)
    {
    printf(“a[%d]=”,i);
    scanf("%d",&a[i]);}
    printf("\n");
    for(i=0;i<N;i++)
    printf("%5d",a[i]);
    printf("\n");
    /sort ten num/
    for(i=0;i<N-1;i++)
    {min=i;
    for(j=i+1;j<N;j++)
    if(a[min]>a[j]) min=j;
    tem=a[i];
    a[i]=a[min];
    a[min]=tem;
    }
    /output data/
    printf(“After sorted \n”);
    for(i=0;i<N;i++)
    printf("%5d",a[i]);
    }

    【程序38】
    题目:求一个3*3矩阵对角线元素之和
    1.程序分析:利用双重for循环控制输入二维数组,再将a[i][i]累加后输出。
    2.程序源代码:
    main()
    {
    float a[3][3],sum=0;
    int i,j;
    printf(“please input rectangle element:\n”);
    for(i=0;i<3;i++)
      for(j=0;j<3;j++)
      scanf("%f",&a[i][j]);
    for(i=0;i<3;i++)
      sum=sum+a[i][i];
    printf(“duijiaoxian he is %6.2f”,sum);
    }

    【程序39】
    题目:有一个已经排好序的数组。现输入一个数,要求按原来的规律将它插入数组中。

    1. 程序分析:首先判断此数是否大于最后一个数,然后再考虑插入中间的数的情况,插入后
            此元素之后的数,依次后移一个位置。
      2.程序源代码:
      main()
      {
      int a[11]={1,4,6,9,13,16,19,28,40,100};
      int temp1,temp2,number,end,i,j;
      printf(“original array is:\n”);
      for(i=0;i<10;i++)
        printf("%5d",a[i]);
      printf("\n");
      printf(“insert a new number:”);
      scanf("%d",&number);
      end=a[9];
      if(number>end)
        a[10]=number;
      else
        {for(i=0;i<10;i++)
         { if(a[i]>number)
          {temp1=a[i];
           a[i]=number;
          for(j=i+1;j<11;j++)
          {temp2=a[j];
           a[j]=temp1;
           temp1=temp2;
          }
          break;
          }
         }
      }
      for(i=0;i<11;i++)
        printf("%6d",a[i]);
      }

    【程序40】
    题目:将一个数组逆序输出。
    1.程序分析:用第一个与最后一个交换。
    2.程序源代码:
    #define N 5
    main()
    { int a[N]={9,6,5,4,1},i,temp;
      printf("\n original array:\n");
      for(i=0;i<N;i++)
      printf("%4d",a[i]);
      for(i=0;i<N/2;i++)
      {temp=a[i];
       a[i]=a[N-i-1];
       a[N-i-1]=temp;
      }
    printf("\n sorted array:\n");
    for(i=0;i<N;i++)
      printf("%4d",a[i]);
    }

    【程序41】
    题目:学习static定义静态变量的用法   
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    varfunc()
    {
    int var=0;
    static int static_var=0;
    printf("\40:var equal %d \n",var);
    printf("\40:static var equal %d \n",static_var);
    printf("\n");
    var++;
    static_var++;
    }
    void main()
    {int i;
      for(i=0;i<3;i++)
       varfunc();
    }

    【程序42】
    题目:学习使用auto定义变量的用法
    1.程序分析:      
    2.程序源代码:
    #include “stdio.h”
    main()
    {int i,num;
    num=2;
      for (i=0;i<3;i++)
      { printf("\40: The num equal %d \n",num);
       num++;
       {
       auto int num=1;
       printf("\40: The internal block num equal %d \n",num);
       num++;
       }
      }
    }

    【程序43】
    题目:学习使用static的另一用法。   
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int i,num;
    num=2;
    for(i=0;i<3;i++)
    {
    printf("\40: The num equal %d \n",num);
    num++;
    {
    static int num=1;
    printf("\40:The internal block num equal %d\n",num);
    num++;
    }
    }
    }

    【程序44】
    题目:学习使用external的用法。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    int a,b,c;
    void add()
    { int a;
    a=3;
    c=a+b;
    }
    void main()
    { a=b=4;
    add();
    printf(“The value of c is equal to %d\n”,c);
    }

    【程序45】
    题目:学习使用register定义变量的方法。
    1.程序分析:
    2.程序源代码:
    void main()
    {
    register int i;
    int tmp=0;
    for(i=1;i<=100;i++)
    tmp+=i;
    printf(“The sum is %d\n”,tmp);
    }

    【程序46】
    题目:宏#define命令练习(1)   
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #define TRUE 1
    #define FALSE 0
    #define SQ(x) (x)*(x)
    void main()
    {
    int num;
    int again=1;
    printf("\40: Program will stop if input value less than 50.\n");
    while(again)
    {
    printf("\40:Please input number==>");
    scanf("%d",&num);
    printf("\40:The square for this number is %d \n",SQ(num));
    if(num>=50)
      again=TRUE;
    else
      again=FALSE;
    }
    }

    【程序47】
    题目:宏#define命令练习(2)
    1.程序分析:            
    2.程序源代码:
    #include “stdio.h”
    #define exchange(a,b) { \ /宏定义中允许包含两道衣裳命令的情形,此时必须在最右边加上""/
                 int t;
                 t=a;
                 a=b;
                 b=t;
                }
    void main(void)
    {
    int x=10;
    int y=20;
    printf(“x=%d; y=%d\n”,x,y);
    exchange(x,y);
    printf(“x=%d; y=%d\n”,x,y);
    }

    【程序48】
    题目:宏#define命令练习(3)   
    1.程序分析:
    2.程序源代码:
    #define LAG >
    #define SMA <
    #define EQ ==
    #include “stdio.h”
    void main()
    { int i=10;
    int j=20;
    if(i LAG j)
    printf("\40: %d larger than %d \n",i,j);
    else if(i EQ j)
    printf("\40: %d equal to %d \n",i,j);
    else if(i SMA j)
    printf("\40:%d smaller than %d \n",i,j);
    else
    printf("\40: No such value.\n");
    }

    【程序49】
    题目:#if #ifdef和#ifndef的综合应用。

    1. 程序分析:
      2.程序源代码:
      #include “stdio.h”
      #define MAX
      #define MAXIMUM(x,y) (x>y)?x:y
      #define MINIMUM(x,y) (x>y)?y:x
      void main()
      { int a=10,b=20;
      #ifdef MAX
      printf("\40: The larger one is %d\n",MAXIMUM(a,b));
      #else
      printf("\40: The lower one is %d\n",MINIMUM(a,b));
      #endif
      #ifndef MIN
      printf("\40: The lower one is %d\n",MINIMUM(a,b));
      #else
      printf("\40: The larger one is %d\n",MAXIMUM(a,b));
      #endif
      #undef MAX
      #ifdef MAX
      printf("\40: The larger one is %d\n",MAXIMUM(a,b));
      #else
      printf("\40: The lower one is %d\n",MINIMUM(a,b));
      #endif
      #define MIN
      #ifndef MIN
      printf("\40: The lower one is %d\n",MINIMUM(a,b));
      #else
      printf("\40: The larger one is %d\n",MAXIMUM(a,b));
      #endif
      }

    【程序50】
    题目:#include 的应用练习   
    1.程序分析:
    2.程序源代码:
    test.h 文件如下:
    #define LAG >
    #define SMA <
    #define EQ ==
    #include “test.h” /一个新文件50.c,包含test.h/
    #include “stdio.h”
    void main()
    { int i=10;
    int j=20;
    if(i LAG j)
    printf("\40: %d larger than %d \n",i,j);
    else if(i EQ j)
    printf("\40: %d equal to %d \n",i,j);
    else if(i SMA j)
    printf("\40:%d smaller than %d \n",i,j);
    else
    printf("\40: No such value.\n");
    }

    【程序51】
    题目:学习使用按位与 & 。   
    1.程序分析:0&0=0; 0&1=0; 1&0=0; 1&1=1
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int a,b;
    a=077;
    b=a&3;
    printf("\40: The a & b(decimal) is %d \n",b);
    b&=7;
    printf("\40: The a & b(decimal) is %d \n",b);
    }

    【程序52】
    题目:学习使用按位或 | 。
    1.程序分析:0|0=0; 0|1=1; 1|0=1; 1|1=1            
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int a,b;
    a=077;
    b=a|3;
    printf("\40: The a & b(decimal) is %d \n",b);
    b|=7;
    printf("\40: The a & b(decimal) is %d \n",b);
    }

    【程序53】
    题目:学习使用按位异或 ^ 。   
    1.程序分析:0^0=0; 0^1=1; 1^0=1; 1^1=0
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int a,b;
    a=077;
    b=a^3;
    printf("\40: The a & b(decimal) is %d \n",b);
    b^=7;
    printf("\40: The a & b(decimal) is %d \n",b);
    }

    【程序54】
    题目:取一个整数a从右端开始的4~7位。
    程序分析:可以这样考虑:
    (1)先使a右移4位。
    (2)设置一个低4位全为1,其余全为0的数。可用(0<<4)
    (3)将上面二者进行&运算。
    2.程序源代码:
    main()
    {
    unsigned a,b,c,d;
    scanf("%o",&a);
    b=a>>4;
    c=(0<<4);
    d=b&c;
    printf("%o\n%o\n",a,d);
    }

    【程序55】
    题目:学习使用按位取反~。   
    1.程序分析:~0=1; ~1=0;
    2.程序源代码:
    #include “stdio.h”
    main()
    {
    int a,b;
    a=234;
    b=~a;
    printf("\40: The a’s 1 complement(decimal) is %d \n",b);
    a=~a;
    printf("\40: The a’s 1 complement(hexidecimal) is %x \n",a);
    }

    【程序56】
    题目:画图,学用circle画圆形。   
    1.程序分析:
    2.程序源代码:
    /circle/
    #include “graphics.h”
    main()
    {int driver,mode,i;
    float j=1,k=1;
    driver=VGA;mode=VGAHI;
    initgraph(&driver,&mode,"");
    setbkcolor(YELLOW);
    for(i=0;i<=25;i++)
    {
    setcolor(8);
    circle(310,250,k);
    k=k+j;
    j=j+0.3;
    }
    }

    【程序57】
    题目:画图,学用line画直线。
    1.程序分析:           
    2.程序源代码:
    #include “graphics.h”
    main()
    {int driver,mode,i;
    float x0,y0,y1,x1;
    float j=12,k;
    driver=VGA;mode=VGAHI;
    initgraph(&driver,&mode,"");
    setbkcolor(GREEN);
    x0=263;y0=263;y1=275;x1=275;
    for(i=0;i<=18;i++)
    {
    setcolor(5);
    line(x0,y0,x0,y1);
    x0=x0-5;
    y0=y0-5;
    x1=x1+5;
    y1=y1+5;
    j=j+10;
    }
    x0=263;y1=275;y0=263;
    for(i=0;i<=20;i++)
    {
    setcolor(5);
    line(x0,y0,x0,y1);
    x0=x0+5;
    y0=y0+5;
    y1=y1-5;
    }
    }

    【程序58】
    题目:画图,学用rectangle画方形。   
    1.程序分析:利用for循环控制100-999个数,每个数分解出个位,十位,百位。
    2.程序源代码:
    #include “graphics.h”
    main()
    {int x0,y0,y1,x1,driver,mode,i;
    driver=VGA;mode=VGAHI;
    initgraph(&driver,&mode,"");
    setbkcolor(YELLOW);
    x0=263;y0=263;y1=275;x1=275;
    for(i=0;i<=18;i++)
    {
    setcolor(1);
    rectangle(x0,y0,x1,y1);
    x0=x0-5;
    y0=y0-5;
    x1=x1+5;
    y1=y1+5;
    }
    settextstyle(DEFAULT_FONT,HORIZ_DIR,2);
    outtextxy(150,40,“How beautiful it is!”);
    line(130,60,480,60);
    setcolor(2);
    circle(269,269,137);
    }

    【程序59】
    题目:画图,综合例子。
    1.程序分析:
    2.程序源代码:

    define PAI 3.1415926

    define B 0.809

    include “graphics.h”

    #include “math.h”
    main()
    {
    int i,j,k,x0,y0,x,y,driver,mode;
    float a;
    driver=CGA;mode=CGAC0;
    initgraph(&driver,&mode,"");
    setcolor(3);
    setbkcolor(GREEN);
    x0=150;y0=100;
    circle(x0,y0,10);
    circle(x0,y0,20);
    circle(x0,y0,50);
    for(i=0;i<16;i++)
    {
      a=(2PAI/16)i;
      x=ceil(x0+48
    cos(a));
      y=ceil(y0+48
    sin(a)B);
      setcolor(2); line(x0,y0,x,y);}
    setcolor(3);circle(x0,y0,60);
    /
    Make 0 time normal size letters /
    settextstyle(DEFAULT_FONT,HORIZ_DIR,0);
    outtextxy(10,170,“press a key”);
    getch();
    setfillstyle(HATCH_FILL,YELLOW);
    floodfill(202,100,WHITE);
    getch();
    for(k=0;k<=500;k++)
    {
      setcolor(3);
      for(i=0;i<=16;i++)
      {
       a=(2
    PAI/16)i+(2PAI/180)k;
       x=ceil(x0+48
    cos(a));
       y=ceil(y0+48+sin(a)B);
       setcolor(2); line(x0,y0,x,y);
      }
      for(j=1;j<=50;j++)
      {
       a=(2
    PAI/16)i+(2PAI/180)k-1;
       x=ceil(x0+48
    cos(a));
       y=ceil(y0+48*sin(a)*B);
       line(x0,y0,x,y);
      }
    }
    restorecrtmode();
    }

    【程序60】
    题目:画图,综合例子。   
    1.程序分析:
    2.程序源代码:
    #include “graphics.h”
    #define LEFT 0
    #define TOP 0
    #define RIGHT 639
    #define BOTTOM 479
    #define LINES 400
    #define MAXCOLOR 15
    main()
    {
    int driver,mode,error;
    int x1,y1;
    int x2,y2;
    int dx1,dy1,dx2,dy2,i=1;
    int count=0;
    int color=0;
    driver=VGA;
    mode=VGAHI;
    initgraph(&driver,&mode,"");
    x1=x2=y1=y2=10;
    dx1=dy1=2;
    dx2=dy2=3;
    while(!kbhit())
    {
      line(x1,y1,x2,y2);
      x1+=dx1;y1+=dy1;
      x2+=dx2;y2+dy2;
      if(x1<=LEFT||x1>=RIGHT)
      dx1=-dx1;
      if(y1<=TOP||y1>=BOTTOM)
       dy1=-dy1;
      if(x2<=LEFT||x2>=RIGHT)
       dx2=-dx2;
      if(y2<=TOP||y2>=BOTTOM)
       dy2=-dy2;
      if(++count>LINES)
      {
       setcolor(color);
       color=(color>=MAXCOLOR)?0:++color;
      }
    }
    closegraph();
    }
    【程序61】
    题目:打印出杨辉三角形(要求打印出10行如下图)   
    1.程序分析:
           1
           1  1
           1  2  1
           1  3  3  1
           1  4  6  4  1
           1  5  10 10 5  1 
    2.程序源代码:
    main()
    {int i,j;
    int a[10][10];
    printf("\n");
    for(i=0;i<10;i++)
      {a[i][0]=1;
      a[i][i]=1;}
    for(i=2;i<10;i++)
      for(j=1;j<i;j++)
      a[i][j]=a[i-1][j-1]+a[i-1][j];
    for(i=0;i<10;i++)
      {for(j=0;j<=i;j++)
      printf("%5d",a[i][j]);
      printf("\n");
      }
    }

    【程序62】
    题目:学习putpixel画点。
    1.程序分析:            
    2.程序源代码:
    #include “stdio.h”
    #include “graphics.h”
    main()
    {
    int i,j,driver=VGA,mode=VGAHI;
    initgraph(&driver,&mode,"");
    setbkcolor(YELLOW);
    for(i=50;i<=230;i+=20)
      for(j=50;j<=230;j++)
      putpixel(i,j,1);
    for(j=50;j<=230;j+=20)
      for(i=50;i<=230;i++)
      putpixel(i,j,1);
    }

    【程序63】
    题目:画椭圆ellipse   
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #include “graphics.h”
    #include “conio.h”
    main()
    {
    int x=360,y=160,driver=VGA,mode=VGAHI;
    int num=20,i;
    int top,bottom;
    initgraph(&driver,&mode,"");
    top=y-30;
    bottom=y-30;
    for(i=0;i<num;i++)
    {
    ellipse(250,250,0,360,top,bottom);
    top-=5;
    bottom+=5;
    }
    getch();
    }

    【程序64】
    题目:利用ellipse and rectangle 画图。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #include “graphics.h”
    #include “conio.h”
    main()
    {
    int driver=VGA,mode=VGAHI;
    int i,num=15,top=50;
    int left=20,right=50;
    initgraph(&driver,&mode,"");
    for(i=0;i<num;i++)
    {
    ellipse(250,250,0,360,right,left);
    ellipse(250,250,0,360,20,top);
    rectangle(20-2i,20-2i,10*(i+2),10*(i+2));
    right+=5;
    left+=5;
    top+=10;
    }
    getch();
    }

    【程序65】
    题目:一个最优美的图案。   
    1.程序分析:
    2.程序源代码:
    #include “graphics.h”
    #include “math.h”
    #include “dos.h”
    #include “conio.h”
    #include “stdlib.h”
    #include “stdio.h”
    #include “stdarg.h”
    #define MAXPTS 15
    #define PI 3.1415926
    struct PTS {
    int x,y;
    };
    double AspectRatio=0.85;
    void LineToDemo(void)
    {
    struct viewporttype vp;
    struct PTS points[MAXPTS];
    int i, j, h, w, xcenter, ycenter;
    int radius, angle, step;
    double rads;
    printf(" MoveTo / LineTo Demonstration" );
    getviewsettings( &vp );
    h = vp.bottom - vp.top;
    w = vp.right - vp.left;
    xcenter = w / 2; /* Determine the center of circle /
    ycenter = h / 2;
    radius = (h - 30) / (AspectRatio * 2);
    step = 360 / MAXPTS; /
    Determine # of increments /
    angle = 0; /
    Begin at zero degrees /
    for( i=0 ; i<MAXPTS ; ++i ){ /
    Determine circle intercepts /
    rads = (double)angle * PI / 180.0; /
    Convert angle to radians /
    points[i].x = xcenter + (int)( cos(rads) * radius );
    points[i].y = ycenter - (int)( sin(rads) * radius * AspectRatio );
    angle += step; /
    Move to next increment /
    }
    circle( xcenter, ycenter, radius ); /
    Draw bounding circle /
    for( i=0 ; i<MAXPTS ; ++i ){ /
    Draw the cords to the circle /
    for( j=i ; j<MAXPTS ; ++j ){ /
    For each remaining intersect /
    moveto(points[i].x, points[i].y); /
    Move to beginning of cord /
    lineto(points[j].x, points[j].y); /
    Draw the cord */
    } } }
    main()
    {int driver,mode;
    driver=CGA;mode=CGAC0;
    initgraph(&driver,&mode,"");
    setcolor(3);
    setbkcolor(GREEN);
    LineToDemo();}

    【程序66】
    题目:输入3个数a,b,c,按大小顺序输出。   
    1.程序分析:利用指针方法。
    2.程序源代码:
    /pointer/
    main()
    {
    int n1,n2,n3;
    int *pointer1,*pointer2,*pointer3;
    printf(“please input 3 number:n1,n2,n3:”);
    scanf("%d,%d,%d",&n1,&n2,&n3);
    pointer1=&n1;
    pointer2=&n2;
    pointer3=&n3;
    if(n1>n2) swap(pointer1,pointer2);
    if(n1>n3) swap(pointer1,pointer3);
    if(n2>n3) swap(pointer2,pointer3);
    printf(“the sorted numbers are:%d,%d,%d\n”,n1,n2,n3);
    }
    swap(p1,p2)
    int *p1,*p2;
    {int p;
    p=*p1;*p1=*p2;*p2=p;
    }

    【程序67】
    题目:输入数组,最大的与第一个元素交换,最小的与最后一个元素交换,输出数组。
    1.程序分析:谭浩强的书中答案有问题。      
    2.程序源代码:
    main()
    {
    int number[10];
    input(number);
    max_min(number);
    output(number);
    }
    input(number)
    int number[10];
    {int i;
    for(i=0;i<9;i++)
      scanf("%d,",&number[i]);
      scanf("%d",&number[9]);
    }
    max_min(array)
    int array[10];
    {int *max,*min,k,l;
    int *p,*arr_end;
    arr_end=array+10;
    max=min=array;
    for(p=array+1;p<arr_end;p++)
      if(*p>*max) max=p;
      else if(*p<*min) min=p;
      k=*max;
      l=*min;
      *p=array[0];array[0]=l;l=*p;
      *p=array[9];array[9]=k;k=*p;
      return;
    }
    output(array)
    int array[10];
    { int *p;
    for(p=array;p<array+9;p++)
      printf("%d,",*p);
    printf("%d\n",array[9]);
    }

    【程序68】
    题目:有n个整数,使其前面各数顺序向后移m个位置,最后m个数变成最前面的m个数
    1.程序分析:
    2.程序源代码:
    main()
    {
    int number[20],n,m,i;
    printf(“the total numbers is:”);
    scanf("%d",&n);
    printf(“back m:”);
    scanf("%d",&m);
    for(i=0;i<n-1;i++)
      scanf("%d,",&number[i]);
    scanf("%d",&number[n-1]);
    move(number,n,m);
    for(i=0;i<n-1;i++)
      printf("%d,",number[i]);
    printf("%d",number[n-1]);
    }
    move(array,n,m)
    int n,m,array[20];
    {
    int p,array_end;
    array_end=
    (array+n-1);
    for(p=array+n-1;p>array;p–)
      p=(p-1);
      *array=array_end;
      m–;
      if(m>0) move(array,n,m);
    }

    【程序69】
    题目:有n个人围成一圈,顺序排号。从第一个人开始报数(从1到3报数),凡报到3的人退出
        圈子,问最后留下的是原来第几号的那位。

    1. 程序分析:
      2.程序源代码:
      #define nmax 50
      main()
      {
      int i,k,m,n,num[nmax],*p;
      printf(“please input the total of numbers:”);
      scanf("%d",&n);
      p=num;
      for(i=0;i<n;i++)
        (p+i)=i+1;
        i=0;
        k=0;
        m=0;
        while(m<n-1)
        {
        if(
      (p+i)!=0) k++;
        if(k3)
        { *(p+i)=0;
        k=0;
        m++;
        }
      i++;
      if(i
      n) i=0;
      }
      while(*p==0) p++;
      printf("%d is left\n",*p);
      }

    【程序70】
    题目:写一个函数,求一个字符串的长度,在main函数中输入字符串,并输出其长度。   
    1.程序分析:
    2.程序源代码:
    main()
    {
    int len;
    char *str[20];
    printf(“please input a string:\n”);
    scanf("%s",str);
    len=length(str);
    printf(“the string has %d characters.”,len);
    }
    length§
    char *p;
    {
    int n;
    n=0;
    while(*p!=’\0’)
    {
      n++;
      p++;
    }
    return n;
    }
    题目:编写input()和output()函数输入,输出5个学生的数据记录。
    1.程序分析:
    2.程序源代码:
    #define N 5
    struct student
    { char num[6];
      char name[8];
      int score[4];
    } stu[N];
    input(stu)
    struct student stu[];
    { int i,j;
      for(i=0;i<N;i++)
      { printf("\n please input %d of %d\n",i+1,N);
       printf(“num: “);
       scanf(”%s”,stu[i].num);
       printf(“name: “);
       scanf(”%s”,stu[i].name);
        for(j=0;j<3;j++)
        { printf(“score %d.”,j+1);
         scanf("%d",&stu[i].score[j]);
        }
       printf("\n");
      }
    }
    print(stu)
    struct student stu[];
    { int i,j;
    printf("\nNo. Name Sco1 Sco2 Sco3\n");
    for(i=0;i<N;i++)
    { printf("%-6s%-10s",stu[i].num,stu[i].name);
      for(j=0;j<3;j++)
       printf("%-8d",stu[i].score[j]);
      printf("\n");
    }
    }
    main()
    {
      input();
      print();
    }

    【程序72】
    题目:创建一个链表。
    1.程序分析:           
    2.程序源代码:
    /creat a list/
    #include “stdlib.h”
    #include “stdio.h”
    struct list
    { int data;
    struct list *next;
    };
    typedef struct list node;
    typedef node *link;
    void main()
    { link ptr,head;
    int num,i;
    ptr=(link)malloc(sizeof(node));
    ptr=head;
    printf(“please input 5 numbers==>\n”);
    for(i=0;i<=4;i++)
    {
      scanf("%d",&num);
      ptr->data=num;
      ptr->next=(link)malloc(sizeof(node));
      if(i==4) ptr->next=NULL;
      else ptr=ptr->next;
    }
    ptr=head;
    while(ptr!=NULL)
    { printf(“The value is ==>%d\n”,ptr->data);
      ptr=ptr->next;
    }
    }

    【程序73】
    题目:反向输出一个链表。   
    1.程序分析:
    2.程序源代码:
    /reverse output a list/
    #include “stdlib.h”
    #include “stdio.h”
    struct list
    { int data;
      struct list *next;
    };
    typedef struct list node;
    typedef node *link;
    void main()
    { link ptr,head,tail; 
      int num,i;
      tail=(link)malloc(sizeof(node));
      tail->next=NULL;
      ptr=tail;
      printf("\nplease input 5 data==>\n");
      for(i=0;i<=4;i++)
      {
       scanf("%d",&num);
       ptr->data=num;
       head=(link)malloc(sizeof(node));
       head->next=ptr;
       ptr=head;
      }
    ptr=ptr->next;
    while(ptr!=NULL)
    { printf(“The value is ==>%d\n”,ptr->data);
      ptr=ptr->next;
    }}

    【程序74】
    题目:连接两个链表。
    1.程序分析:
    2.程序源代码:
    #include “stdlib.h”
    #include “stdio.h”
    struct list
    { int data;
    struct list *next;
    };
    typedef struct list node;
    typedef node *link;
    link delete_node(link pointer,link tmp)
    {if (tmpNULL) /delete first node/
      return pointer->next;
    else
    { if(tmp->next->next
    NULL)/delete last node/
       tmp->next=NULL;
      else /delete the other node/
       tmp->next=tmp->next->next;
      return pointer;
    }
    }
    void selection_sort(link pointer,int num)
    { link tmp,btmp;
      int i,min;
      for(i=0;i<num;i++)
      {
      tmp=pointer;
      min=tmp->data;
      btmp=NULL;
      while(tmp->next)
      { if(min>tmp->next->data)
      {min=tmp->next->data;
       btmp=tmp;
      }
      tmp=tmp->next;
      }
    printf("\40: %d\n",min);
    pointer=delete_node(pointer,btmp);
    }
    }
    link create_list(int array[],int num)
    { link tmp1,tmp2,pointer;
    int i;
    pointer=(link)malloc(sizeof(node));
    pointer->data=array[0];
    tmp1=pointer;
    for(i=1;i<num;i++)
    { tmp2=(link)malloc(sizeof(node));
      tmp2->next=NULL;
      tmp2->data=array[i];
      tmp1->next=tmp2;
      tmp1=tmp1->next;
    }
    return pointer;
    }
    link concatenate(link pointer1,link pointer2)
    { link tmp;
    tmp=pointer1;
    while(tmp->next)
      tmp=tmp->next;
    tmp->next=pointer2;
    return pointer1;
    }
    void main(void)
    { int arr1[]={3,12,8,9,11};
      link ptr;
      ptr=create_list(arr1,5);
      selection_sort(ptr,5);
    }

    【程序75】
    题目:放松一下,算一道简单的题目。
    1.程序分析:
    2.程序源代码:
    main()
    {
    int i,n;
    for(i=1;i<5;i++)
    { n=0;
      if(i!=1)
      n=n+1;
      if(i3)
      n=n+1;
      if(i
    4)
      n=n+1;
      if(i!=4)
      n=n+1;
      if(n==3)
       printf(“zhu hao shi de shi:%c”,64+i);
      }
    }

    【程序76】
    题目:编写一个函数,输入n为偶数时,调用函数求1/2+1/4+…+1/n,当输入n为奇数时,调用函数
        1/1+1/3+…+1/n(利用指针函数)
    1.程序分析:
    2.程序源代码:
    main()
    #include “stdio.h”
    main()
    {
    float peven(),podd(),dcall();
    float sum;
    int n;
    while (1)
    {
      scanf("%d",&n);
      if(n>1)
       break;
    }
    if(n%2==0)
    {
      printf(“Even=”);
      sum=dcall(peven,n);
    }
    else
    {
      printf(“Odd=”);
      sum=dcall(podd,n);
    }
    printf("%f",sum);
    }
    float peven(int n)
    {
    float s;
    int i;
    s=1;
    for(i=2;i<=n;i+=2)
      s+=1/(float)i;
    return(s);
    }
    float podd(n)
    int n;
    {
    float s;
    int i;
    s=0;
    for(i=1;i<=n;i+=2)
      s+=1/(float)i;
    return(s);
    }
    float dcall(fp,n)
    float (*fp)();
    int n;
    {
    float s;
    s=(*fp)(n);
    return(s);
    }

    【程序77】
    题目:填空练习(指向指针的指针)
    1.程序分析:     
    2.程序源代码:
    main()
    { char *s[]={“man”,“woman”,“girl”,“boy”,“sister”};
    char **q;
    int k;
    for(k=0;k<5;k++)
    {       ;/这里填写什么语句/
      printf("%s\n",*q);
    }
    }

    【程序78】
    题目:找到年龄最大的人,并输出。请找出程序中有什么问题。
    1.程序分析:
    2.程序源代码:
    #define N 4
    #include “stdio.h”
    static struct man
    { char name[20];
    int age;
    } person[N]={“li”,18,“wang”,19,“zhang”,20,“sun”,22};
    main()
    {struct man *q,*p;
    int i,m=0;
    p=person;
    for (i=0;i<N;i++)
    {if(mage)
      q=p++;
      m=q->age;}
    printf("%s,%d",(*q).name,(*q).age);
    }

    【程序79】
    题目:字符串排序。
    1.程序分析:
    2.程序源代码:
    main()
    {
    char *str1[20],*str2[20],*str3[20];
    char swap();
    printf(“please input three strings\n”);
    scanf("%s",str1);
    scanf("%s",str2);
    scanf("%s",str3);
    if(strcmp(str1,str2)>0) swap(str1,str2);
    if(strcmp(str1,str3)>0) swap(str1,str3);
    if(strcmp(str2,str3)>0) swap(str2,str3);
    printf(“after being sorted\n”);
    printf("%s\n%s\n%s\n",str1,str2,str3);
    }
    char swap(p1,p2)
    char *p1,*p2;
    {
    char *p[20];
    strcpy(p,p1);strcpy(p1,p2);strcpy(p2,p);
    }

    【程序80】
    题目:海滩上有一堆桃子,五只猴子来分。第一只猴子把这堆桃子凭据分为五份,多了一个,这只
        猴子把多的一个扔入海中,拿走了一份。第二只猴子把剩下的桃子又平均分成五份,又多了
        一个,它同样把多的一个扔入海中,拿走了一份,第三、第四、第五只猴子都是这样做的,
        问海滩上原来最少有多少个桃子?
    1.程序分析:
    2.程序源代码:
    main()
    {int i,m,j,k,count;
    for(i=4;i<10000;i+=4)
    { count=0;
    m=i;
    for(k=0;k<5;k++)
    {
      j=i/45+1;
      i=j;
      if(j%40)
       count++;
      else
       break;
    }
      i=m;
      if(count
    4)
      {printf("%d\n",count);
       break;}
    }
    }
    【程序81】
    题目:809
    ??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数,9*??的结果为3位数。求??代表的两位数,及809*??后的结果。
    1.程序分析:
    2.程序源代码:
    output(long b,long i)
    { printf("\n%ld/%ld=809*%ld+%ld",b,i,i,b%i);
    }
    main()
    {long int a,b,i;
    a=809;
    for(i=10;i<100;i++)
    {b=ia+1;
    if(b>=1000&&b<=10000&&8
    i<100&&9*i>=100)
    output(b,i); }
    }

    【程序82】
    题目:八进制转换为十进制
    1.程序分析:           
    2.程序源代码:
    main()
    { char p,s[6];int n;
    p=s;
    gets§;
    n=0;
    while(
    §!=’\0’)
    {n=n*8+*p-‘0’;
    p++;}
    printf("%d",n);
    }

    【程序83】
    题目:求0—7所能组成的奇数个数。
    1.程序分析:
    2.程序源代码:
    main()
    {
    long sum=4,s=4;
    int j;
    for(j=2;j<=8;j++)/j is place of number/
    { printf("\n%ld",sum);
    if(j<=2)
    s*=7;
    else
    s*=8;
    sum+=s;}
    printf("\nsum=%ld",sum);
    }

    【程序84】
    题目:一个偶数总能表示为两个素数之和。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #include “math.h”
    main()
    { int a,b,c,d;
    scanf("%d",&a);
    for(b=3;b<=a/2;b+=2)
    { for(c=2;c<=sqrt(b);c++)
    if(b%c0) break;
    if(c>sqrt(b))
    d=a-b;
    else
    break;
    for(c=2;c<=sqrt(d);c++)
    if(d%c
    0) break;
    if(c>sqrt(d))
    printf("%d=%d+%d\n",a,b,d);
    }
    }

    【程序85】
    题目:判断一个素数能被几个9整除
    1.程序分析:
    2.程序源代码:
    main()
    { long int m9=9,sum=9;
    int zi,n1=1,c9=1;
    scanf("%d",&zi);
    while(n1!=0)
    { if(!(sum%zi))
    n1=0;
    else
    {m9=m9*10;
    sum=sum+m9;
    c9++;
    }
    }
    printf("%ld,can be divided by %d “9"”,sum,c9);
    }

    【程序86】
    题目:两个字符串连接程序
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    main()
    {char a[]=“acegikm”;
    char b[]=“bdfhjlnpq”;
    char c[80],*p;
    int i=0,j=0,k=0;
    while(a[i]!=’\0’&&b[j]!=’\0’)
    {if (a[i]<b[j])
    { c[k]=a[i];i++;}
    else
    c[k]=b[j++];
    k++;
    }
    c[k]=’\0’;
    if(a[i]==’\0’)
    p=b+j;
    else
    p=a+i;
    strcat(c,p);
    puts©;
    }

    【程序87】
    题目:回答结果(结构体变量传递)
    1.程序分析:     
    2.程序源代码:
    #include “stdio.h”
    struct student
    { int x;
    char c;
    } a;
    main()
    {a.x=3;
    a.c=‘a’;
    f(a);
    printf("%d,%c",a.x,a.c);
    }
    f(struct student b)
    {
    b.x=20;
    b.c=‘y’;
    }

    【程序88】
    题目:读取7个数(1—50)的整数值,每读取一个值,程序打印出该值个数的*。
    1.程序分析:
    2.程序源代码:
    main()
    {int i,a,n=1;
    while(n<=7)
    { do {
        scanf("%d",&a);
        }while(a<1||a>50);
    for(i=1;i<=a;i++)
      printf("*");
    printf("\n");
    n++;}
    getch();
    }

    【程序89】
    题目:某个公司采用公用电话传递数据,数据是四位的整数,在传递过程中是加密的,加密规则如下:
        每位数字都加上5,然后用和除以10的余数代替该数字,再将第一位和第四位交换,第二位和第三位交换。
    1.程序分析:
    2.程序源代码:
    main()
    {int a,i,aa[4],t;
    scanf("%d",&a);
    aa[0]=a%10;
    aa[1]=a%100/10;
    aa[2]=a%1000/100;
    aa[3]=a/1000;
    for(i=0;i<=3;i++)
      {aa[i]+=5;
      aa[i]%=10;
      }
    for(i=0;i<=3/2;i++)
      {t=aa[i];
      aa[i]=aa[3-i];
      aa[3-i]=t;
      }
    for(i=3;i>=0;i–)
    printf("%d",aa[i]);
    }

    【程序90】
    题目:专升本一题,读结果。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #define M 5
    main()
    {int a[M]={1,2,3,4,5};
    int i,j,t;
    i=0;j=M-1;
    while(i<j)
    {t=*(a+i);
    (a+i)=(a+j);
    (a+j)=t;
    i++;j–;
    }
    for(i=0;i<m;i++)
    printf("%d",
    (a+i));
    }
    【程序91】
    题目:时间函数举例1
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    #include “time.h”
    void main()
    { time_t lt; /define a longint time varible/
    lt=time(NULL);/system time and date/
    printf(ctime(<)); /english format output/
    printf(asctime(localtime(<)));/tranfer to tm/
    printf(asctime(gmtime(<))); /tranfer to Greenwich time/
    }

    【程序92】
    题目:时间函数举例2
    1.程序分析:           
    2.程序源代码:
    /calculate time/
    #include “time.h”
    #include “stdio.h”
    main()
    { time_t start,end;
    int i;
    start=time(NULL);
    for(i=0;i<3000;i++)
    { printf("\1\1\1\1\1\1\1\1\1\1\n");}
    end=time(NULL);
    printf("\1: The different is %6.3f\n",difftime(end,start));
    }

    【程序93】
    题目:时间函数举例3
    1.程序分析:
    2.程序源代码:
    /calculate time/
    #include “time.h”
    #include “stdio.h”
    main()
    { clock_t start,end;
    int i;
    double var;
    start=clock();
    for(i=0;i<10000;i++)
    { printf("\1\1\1\1\1\1\1\1\1\1\n");}
    end=clock();
    printf("\1: The different is %6.3f\n",(double)(end-start));
    }

    【程序94】
    题目:时间函数举例4,一个猜数游戏,判断一个人反应快慢。(版主初学时编的)
    1.程序分析:
    2.程序源代码:
    #include “time.h”
    #include “stdlib.h”
    #include “stdio.h”
    main()
    {char c;
    clock_t start,end;
    time_t a,b;
    double var;
    int i,guess;
    srand(time(NULL));
    printf(“do you want to play it.(‘y’ or ‘n’) \n”);
    loop:
    while((c=getchar())‘y’)
    {
    i=rand()%100;
    printf("\nplease input number you guess:\n");
    start=clock();
    a=time(NULL);
    scanf("%d",&guess);
    while(guess!=i)
    {if(guess>i)
    {printf(“please input a little smaller.\n”);
    scanf("%d",&guess);}
    else
    {printf(“please input a little bigger.\n”);
    scanf("%d",&guess);}
    }
    end=clock();
    b=time(NULL);
    printf("\1: It took you %6.3f seconds\n",var=(double)(end-start)/18.2);
    printf("\1: it took you %6.3f seconds\n\n",difftime(b,a));
    if(var<15)
    printf("\1\1 You are very clever! \1\1\n\n");
    else if(var<25)
    printf("\1\1 you are normal! \1\1\n\n");
    else
    printf("\1\1 you are stupid! \1\1\n\n");
    printf("\1\1 Congradulations \1\1\n\n");
    printf(“The number you guess is %d”,i);
    }
    printf("\ndo you want to try it again?(“yy”.or.“n”)\n");
    if((c=getch())
    ‘y’)
    goto loop;
    }

    【程序95】
    题目:家庭财务管理小程序
    1.程序分析:
    2.程序源代码:
    /money management system/
    #include “stdio.h”
    #include “dos.h”
    main()
    {
    FILE *fp;
    struct date d;
    float sum,chm=0.0;
    int len,i,j=0;
    int c;
    char ch[4]="",ch1[16]="",chtime[12]="",chshop[16],chmoney[8];
    pp: clrscr();
    sum=0.0;
    gotoxy(1,1);printf("|---------------------------------------------------------------------------|");
    gotoxy(1,2);printf("| money management system(C1.0) 2000.03 |");
    gotoxy(1,3);printf("|---------------------------------------------------------------------------|");
    gotoxy(1,4);printf("| – money records – | – today cost list – |");
    gotoxy(1,5);printf("| ------------------------ |-------------------------------------|");
    gotoxy(1,6);printf("| date: -------------- | |");
    gotoxy(1,7);printf("| | | | |");
    gotoxy(1,8);printf("| -------------- | |");
    gotoxy(1,9);printf("| thgs: ------------------ | |");
    gotoxy(1,10);printf("| | | | |");
    gotoxy(1,11);printf("| ------------------ | |");
    gotoxy(1,12);printf("| cost: ---------- | |");
    gotoxy(1,13);printf("| | | | |");
    gotoxy(1,14);printf("| ---------- | |");
    gotoxy(1,15);printf("| | |");
    gotoxy(1,16);printf("| | |");
    gotoxy(1,17);printf("| | |");
    gotoxy(1,18);printf("| | |");
    gotoxy(1,19);printf("| | |");
    gotoxy(1,20);printf("| | |");
    gotoxy(1,21);printf("| | |");
    gotoxy(1,22);printf("| | |");
    gotoxy(1,23);printf("|---------------------------------------------------------------------------|");
    i=0;
    getdate(&d);
    sprintf(chtime,"%4d.%02d.%02d",d.da_year,d.da_mon,d.da_day);
    for(;😉
    {
    gotoxy(3,24);printf(" Tab __browse cost list Esc __quit");
    gotoxy(13,10);printf(" “);
    gotoxy(13,13);printf(” “);
    gotoxy(13,7);printf(”%s",chtime);
    j=18;
    ch[0]=getch();
    if(ch[0]==27)
    break;
    strcpy(chshop,"");
    strcpy(chmoney,"");
    if(ch[0]9)
    {
    mm:i=0;
    fp=fopen(“home.dat”,“r+”);
    gotoxy(3,24);printf(" “);
    gotoxy(6,4);printf(” list records “);
    gotoxy(1,5);printf(”|-------------------------------------|");
    gotoxy(41,4);printf(" “);
    gotoxy(41,5);printf(” |");
    while(fscanf(fp,"%10s%14s%f\n",chtime,chshop,&chm)!=EOF)
    { if(i
    36)
    { getch();
    i=0;}
    if ((i%36)<17)
    { gotoxy(4,6+i);
    printf(" “);
    gotoxy(4,6+i);}
    else
    if((i%36)>16)
    { gotoxy(41,4+i-17);
    printf(” “);
    gotoxy(42,4+i-17);}
    i++;
    sum=sum+chm;
    printf(”%10s %-14s %6.1f\n",chtime,chshop,chm);}
    gotoxy(1,23);printf("|---------------------------------------------------------------------------|");
    gotoxy(1,24);printf("| |");
    gotoxy(1,25);printf("|---------------------------------------------------------------------------|");
    gotoxy(10,24);printf(“total is %8.1f$”,sum);
    fclose(fp);
    gotoxy(49,24);printf(“press any key to…”);getch();goto pp;
    }
    else
    {
    while(ch[0]!=’\r’)
    { if(j<10)
    { strncat(chtime,ch,1);
    j++;}
    if(ch[0]==8)
    {
    len=strlen(chtime)-1;
    if(j>15)
    { len=len+1; j=11;}
    strcpy(ch1,"");
    j=j-2;
    strncat(ch1,chtime,len);
    strcpy(chtime,"");
    strncat(chtime,ch1,len-1);
    gotoxy(13,7);printf(" “);}
    gotoxy(13,7);printf(”%s",chtime);ch[0]=getch();
    if(ch[0]==9)
    goto mm;
    if(ch[0]==27)
    exit(1);
    }
    gotoxy(3,24);printf(" “);
    gotoxy(13,10);
    j=0;
    ch[0]=getch();
    while(ch[0]!=’\r’)
    { if (j<14)
    { strncat(chshop,ch,1);
    j++;}
    if(ch[0]==8)
    { len=strlen(chshop)-1;
    strcpy(ch1,”");
    j=j-2;
    strncat(ch1,chshop,len);
    strcpy(chshop,"");
    strncat(chshop,ch1,len-1);
    gotoxy(13,10);printf(" “);}
    gotoxy(13,10);printf(”%s",chshop);ch[0]=getch();}
    gotoxy(13,13);
    j=0;
    ch[0]=getch();
    while(ch[0]!=’\r’)
    { if (j<6)
    { strncat(chmoney,ch,1);
    j++;}
    if(ch[0]==8)
    { len=strlen(chmoney)-1;
    strcpy(ch1,"");
    j=j-2;
    strncat(ch1,chmoney,len);
    strcpy(chmoney,"");
    strncat(chmoney,ch1,len-1);
    gotoxy(13,13);printf(" “);}
    gotoxy(13,13);printf(”%s",chmoney);ch[0]=getch();}
    if((strlen(chshop)==0)||(strlen(chmoney)==0))
    continue;
    if((fp=fopen(“home.dat”,“a+”))!=NULL);
    fprintf(fp,"%10s%14s%6s",chtime,chshop,chmoney);
    fputc(’\n’,fp);
    fclose(fp);
    i++;
    gotoxy(41,5+i);
    printf("%10s %-14s %-6s",chtime,chshop,chmoney);
    }}}

    【程序96】
    题目:计算字符串中子串出现的次数
    1.程序分析:
    2.程序源代码:
    #include “string.h”
    #include “stdio.h”
    main()
    { char str1[20],str2[20],*p1,*p2;
    int sum=0;
    printf(“please input two strings\n”);
    scanf("%s%s",str1,str2);
    p1=str1;p2=str2;
    while(*p1!=’\0’)
    {
    if(*p1==*p2)
    {while(*p1==*p2&&*p2!=’\0’)
    {p1++;
    p2++;}
    }
    else
    p1++;
    if(*p2==’\0’)
    sum++;
    p2=str2;
    }
    printf("%d",sum);
    getch();}

    【程序97】
    题目:从键盘输入一些字符,逐个把它们送到磁盘上去,直到输入一个#为止。
    1.程序分析:     
    2.程序源代码:
    #include “stdio.h”
    main()
    { FILE *fp;
    char ch,filename[10];
    scanf("%s",filename);
    if((fp=fopen(filename,“w”))==NULL)
    {printf(“cannot open file\n”);
    exit(0);}
    ch=getchar();
    ch=getchar();
    while(ch!=’#’)
    {fputc(ch,fp);putchar(ch);
    ch=getchar();
    }
    fclose(fp);
    }

    【程序98】
    题目:从键盘输入一个字符串,将小写字母全部转换成大写字母,然后输出到一个磁盘文件“test”中保存。
        输入的字符串以!结束。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    main()
    {FILE *fp;
    char str[100],filename[10];
    int i=0;
    if((fp=fopen(“test”,“w”))==NULL)
    { printf(“cannot open the file\n”);
    exit(0);}
    printf(“please input a string:\n”);
    gets(str);
    while(str[i]!=’!’)
    { if(str[i]>=‘a’&&str[i]<=‘z’)
    str[i]=str[i]-32;
    fputc(str[i],fp);
    i++;}
    fclose(fp);
    fp=fopen(“test”,“r”);
    fgets(str,strlen(str)+1,fp);
    printf("%s\n",str);
    fclose(fp);
    }

    【程序99】
    题目:有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列),
        输出到一个新文件C中。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    main()
    { FILE *fp;
    int i,j,n,ni;
    char c[160],t,ch;
    if((fp=fopen(“A”,“r”))==NULL)
    {printf(“file A cannot be opened\n”);
    exit(0);}
    printf("\n A contents are :\n");
    for(i=0;(ch=fgetc(fp))!=EOF;i++)
    {c[i]=ch;
    putchar(c[i]);
    }
    fclose(fp);
    ni=i;
    if((fp=fopen(“B”,“r”))==NULL)
    {printf(“file B cannot be opened\n”);
    exit(0);}
    printf("\n B contents are :\n");
    for(i=0;(ch=fgetc(fp))!=EOF;i++)
    {c[i]=ch;
    putchar(c[i]);
    }
    fclose(fp);
    n=i;
    for(i=0;i<n;i++)
    for(j=i+1;j<n;j++)
    if(c[i]>c[j])
    {t=c[i];c[i]=c[j];c[j]=t;}
    printf("\n C file is:\n");
    fp=fopen(“C”,“w”);
    for(i=0;i<n;i++)
    { putc(c[i],fp);
    putchar(c[i]);
    }
    fclose(fp);
    }

    【程序100】
    题目:有五个学生,每个学生有3门课的成绩,从键盘输入以上数据(包括学生号,姓名,三门课成绩),计算出
        平均成绩,况原有的数据和计算出的平均分数存放在磁盘文件"stud"中。
    1.程序分析:
    2.程序源代码:
    #include “stdio.h”
    struct student
    { char num[6];
    char name[8];
    int score[3];
    float avr;
    } stu[5];
    main()
    {int i,j,sum;
    FILE *fp;
    /input/
    for(i=0;i<5;i++)
    { printf("\n please input No. %d score:\n",i);
    printf(“stuNo:”);
    scanf("%s",stu[i].num);
    printf(“name:”);
    scanf("%s",stu[i].name);
    sum=0;
    for(j=0;j<3;j++)
    { printf(“score %d.”,j+1);
    scanf("%d",&stu[i].score[j]);
    sum+=stu[i].score[j];
    }
    stu[i].avr=sum/3.0;
    }
    fp=fopen(“stud”,“w”);
    for(i=0;i<5;i++)
    if(fwrite(&stu[i],sizeof(struct student),1,fp)!=1)
    printf(“file write error\n”);
    fclose(fp);
    }

    展开全文
  • 100 个经典 c 语言例题带答案 经典源程序 100 例 - -1 经典源程序 100 例 程序 1题目有 123 4 个数字能 组成多少个互不相同且无重复数字的三位数都是多少 1.程序分析可填在百位十位 个位的数字都是 12 34 组成所有的...
  • 包含100道c语言经典例题代码 适合初学者
  • C语言经典例题100.pdf

    2021-01-26 18:36:13
    【小甲鱼】C语言课程中提到的例题
  • C语言经典例题.pdf

    2021-09-30 16:47:33
    C语言经典例题.pdf
  • C语言经典例题1000.pdf

    2021-09-30 16:47:34
    C语言经典例题1000.pdf
  • C语言经典例题.doc

    2021-09-09 00:57:49
    C语言经典例题.doc
  • C语言经典例题

    2014-07-25 10:30:17
    C语言经典例题100 题目 代码 初学
  • 精品文档 经典 C 语言程序设计 100 例 程序 1 题目有 1 2 3 4 个数字能组成多少个互不相同且无重复数字的三位数都是多少 程序分析可填在百位十位个位的数字都是1 2 3 4 组成所有的排列后再去掉不满足条件的排列 程序...
  • c语言经典例题集.pdf

    2021-09-30 16:47:37
    c语言经典例题集.pdf
  • C语言经典例题100例
  • c语言经典例题100

    2018-05-02 22:20:03
    c语言新手可以做做,有利于提升实力 c语言新手可以做做,有利于提升实力 c语言新手可以做做,有利于提升实力 c语言新手可以做做,有利于提升实力 c语言新手可以做做,有利于提升实力 c语言新手可以做做,有利于提升...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,989
精华内容 4,795
关键字:

c经典例题