( •̀ ω •́ )y( •̀ ω •́ )y精心整理C两百例【1-60例】，持续更新.....

男娘i 2022-08-28 09:48 12阅读 0赞

## 前言 ##

> 求解二维数组的最大最小元素、利用数组求前n个质数、万年历、数组排序、任意进制转换、回文数、求数组前n项和、求解钢材切割的最佳订单、通过指针比较整数大小、指向数组的指针、寻找指定元素的指针、寻找相同元素的指针、阿拉伯数字转化为罗马数字、字符替换等…

### 文章目录 ###

*   *  前言
     *  1、C的第一个程序
     *  2、运行多个源文件
     *  3、求整数之积
     *  4、比较实数大小
     *  5、字符的输出
     *  6、显示变量所占字节数
     *  7、自增自减运算符
     *  8、数列求和
     *  9、乘法口诀表
     *  10、判断价格区间
     *  11、模拟取款界面
     *  14、用一维数组统计学生成绩
     *  13、二维矩阵实现矩阵装置
     *  14、求解二维数组的最大最小元素
     *  15、利用数组求前n个质数
     *  16、万年历
     *  17、数组排序
     *  18、任意进制转换
     *  19、回文数
     *  20、求数组前n项和
     *  21、求解钢材切割的最佳订单
     *  22、通过指针比较整数大小
     *  23、指向数组的指针
     *  24、寻找指定元素的指针
     *  25、寻找相同元素的指针
     *  26、阿拉伯数字转化为罗马数字
     *  27、字符替换
     *  28、从键盘读入实数
     *  29、字符行排版
     *  30、字符排列
     *  31、判断字符串是否回文
     *  32、通讯录的输入输出
     *  33、扑克牌的结构表示
     *  34、用“结构”统计学生成绩
     *  35、报数游戏
     *  36、模拟家族关系
     *  37、统计文件的字符数
     *  38、同时显示两个文件的内容
     *  39、简单的文本编辑器
     *  40、文件的字数统计程序
     *  41、学生成绩管理程序
     *  42、插入排序
     *  43、希尔排序
     *  44、冒泡排序
     *  45、快速排序
     *  46、选择排序
     *  47、堆排序
     *  48、归并排序
     *  49、基数排序
     *  50、二叉树操作
     *  51、二项式系数递归
     *  52、背包问题
     *  53、顺序表插入和删除
     *  54、链表操作（1）
     *  55、链表操作（2）
     *  56、单链表就地逆置
     *  57、运动会分数统计
     *  58、双链表
     *  59、约瑟夫环
     *  60、记录家庭资料

## 1、C的第一个程序 ##

/* The first C programme */
    #include <stdio.h> /* 包含标准输入输出头文件 */
    void main()						/* 主函数 */
    { 
    	printf("Hello World!\n");	/* 打印输出信息 */
    	getchar();
    }

## 2、运行多个源文件 ##

`main.c`

#include "print.h"
    
    void main(void){ 
    	printHello();
    	getchar();
    }

`print.c`

#include "print.h"
    
    void printHello()
    { 
    	printf("hello word!\n");
    }

`print.h`

#include "stdio.h"
    
    void printHello(void);

## 3、求整数之积 ##

#include <stdio.h>
    
    int main()
    { 
    	int x,y,m;				/* 定义整型变量x，y，m */
    	printf("Please input x and y");	/* 输出提示信息 */
    	scanf("%d%d",&x,&y);			/* 读入两个乘数，赋给x，y变量 */
    	m=x*y;					/* 计算两个乘数的积，赋给变量m */
    	printf("%d * %d = %d\n",x,y,m);		/* 输出结果 */
    
    	return 0;
    }

## 4、比较实数大小 ##

/* 输入两个浮点数，输出它们中的大数 */
    #include <stdio.h>
    int main()
    { 
    	float x, y, c;						    /* 变量定义 */
    	printf("Please input x and y:");	    /* 提示用户输入数据 */
    	scanf("%f %f", &x, &y);
    	c = x> y ? x : y;					    /* 计算c=max(x,y) */
    	printf("MAX of (%f,%f) is %f",x,y,c);	/* 输出c */
    
    	return 0;
    }

## 5、字符的输出 ##

#include <stdio.h>
    
    int main()
    { 
    	char ch, nch;	
    	int count;	
    	int k;		
    
    	printf("Please input a string with a # in the end.\n");
    
    	/** 循环获取字符 */
    	while (scanf("%c", &ch) == 1 && ch != '#')
    	{ 	
    		// 丢弃\n
    		if (ch == '\n')
    			continue;
    		printf("[out]：%c\n", ch);	
    		printf("Please input a string with a # in the end.\n");
    
    	}
    	printf("#\n");				
    
    	return 0;
    }

## 6、显示变量所占字节数 ##

#include <stdio.h>
    
    void main()
    { 
    	/* sizeof() * @func: 是保留字，它的作用是求某类型或某变量类型的字节数 * @param: 传入类型保留字或变量； * return: 返回size_t类型的字节数 */
    
    	/*int型在不同的机器，不同的编译器中的字节数不一样*/
    	/*一般来说在TC2.0编译器中字节数为2,在VC编译器中字节数为4 */
    
    	printf("The bytes of the variables are:\n");
    	printf("int:%d bytes\n", sizeof(int));
    
    	printf("char:%d byte\n", sizeof(char));	/* char型的字节数为1 */
    
    	printf("short:%d bytes\n", sizeof(short));	/* short型的字节数为2 */
    
    	printf("long:%d bytes\n", sizeof(long));	/* long型的字节数为4 */
    
    	printf("float:%d bytes\n", sizeof(float));	/* float型的字节数为4 */
    
    	printf("double:%d bytes\n", sizeof(double));	/* double型的字节数为8 */
    
    	printf("long double:%d bytes\n", sizeof(long double));	/* long double型的字节数为8或10或12 */
    	getchar();
    }

## 7、自增自减运算符 ##

> <赋值过程可以理解为是>

#include <stdio.h>
    
    void main()
    { 
    	int a = 5, b, c, i = 10;
    	b = a++;	
    	c = ++b;	
    
    	printf("a = %d, b = %d, c = %d \n", a, b, c);	/* a = 6, b = 6, c = 6 */
    	printf("i, i++, ++i = %d, %d, %d\n", i, i++, ++i);  /* i, i++, i++ = 12, 11, 10 */
    	printf("%d\n", ++i);							/* 13 */
    	printf("%d\n", --i);							/* 12 */
    	printf("(%d)\n", (i++));						/* 12 */
    	printf("%d\n", i--);							/* 13 */
    	printf("%d\n", -i++);							/* -12 */
    	printf("%d\n", -i--);							/* -13 */
    	
    	getchar();
    }

**自增运算符源码**

int& int::operator++()
    { 
    	*this += 1;
    	return *this;
    }
    
    const int int::operator++(int)
    { 
    	int oldValue = *this;
    	++(*this);
    	return oldValue;
    }

## 8、数列求和 ##

#include <stdio.h>
    #include <stdlib.h>
    
    void main()
    { 
    	int i, j, n;
    	long sum = 0, temp = 0;
    
    	printf("Please input a number to n:\n");
    	scanf("%d", &n);
    	if (n<1)
    	{ 
    		printf("The n must no less than 1!\n");
    		return;
    	}
    
    	for (i = 1; i <= n; i++)
    	{ 
    		temp = 0;	
    		for (j = 1; j <= i; j++)
    			temp += j;
    		sum += temp;
    	}
    	printf("The sum of the sequence(%d) is %d\n", n, sum);
    	
    	system("pause");
    }

## 9、乘法口诀表 ##

#include <stdio.h>
    
    void main(void)
    { 
    	int j, i;
    
    	for (i = 1; i < 10; ++i){ 
    		for (j = 1; j < i+1; ++j){ 
    			printf("%4d * %d", j, i);
    		}
    		printf("\n");
    	}
    	getchar();
    }

## 10、判断价格区间 ##

#include <stdio.h>
    #include <conio.h>
    
    void main()
    { 
    	int Password = 0, Number = 0, price = 58, i = 0;
    	printf("\n====This is a Number Guess Game!====\n");
    	while (Password != 1234)
    	{ 
    		if (i >= 3)
    			return;
    		i++;
    		puts("Please input Password: ");
    		scanf("%d", &Password);
    	}
    
    	i = 0;
    	while (Number != price)
    	{ 
    		do{ 
    			puts("Please input a number between 1 and 100: ");
    			scanf("%d", &Number);
    			printf("Your input number is %d\n", Number);
    		} while (!(Number >= 1 && Number <= 100));
    		if (Number >= 90)
    		{ 
    			printf("Too Bigger! Press any key to try again!\n");
    		}
    		else if (Number >= 70 && Number < 90)
    		{ 
    			printf("Bigger!\n");
    		}
    		else if (Number >= 1 && Number <= 30)
    		{ 
    			printf("Too Small! Press any key to try again!\n");
    		}
    		else if (Number > 30 && Number <= 50)
    		{ 
    			printf("Small! Press any key to try again!\n");
    		}
    		else
    		{ 
    			if (Number == price)
    			{ 
    				printf("OK! You are right! Bye Bye!\n");
    			}
    			else if (Number < price)
    			{ 
    				printf("Sorry,Only a little smaller! Press any key to try again!\n");
    
    			}
    			else if (Number > price)
    				printf(" Sorry, Only a little bigger! Press any key to try again!\n");
    		}
    
    	}
    }

## 11、模拟取款界面 ##

#include <stdio.h>
    #include<stdlib.h>
    void main()
    { 
    	char SelectKey, CreditMoney, DebitMoney;
    	while (1)
    	{ 
    		do{ 
    			puts("=========================");
    			puts("| Please select key: |");
    			puts("| 1. Quary |");
    			puts("| 2. Credit |");
    			puts("| 3. Debit |");
    			puts("| 4. Return |");
    			puts("=========================");
    			SelectKey = getchar();
    			//fflush(stdin);
    		} while (SelectKey != '1' && SelectKey != '2' && SelectKey != '3' && SelectKey != '4');
    		switch (SelectKey)
    		{ 
    		case '1':
    			puts("================================");
    			puts("| Your balance is $1000. |");
    			puts("| Press any key to return... |");
    			puts("================================");
    			getchar();
    			break;
    		case '2':
    			do{ 
    				puts("==================================");
    				puts("| Please select Credit money: |");
    				puts("| 1. $50 |");
    				puts("| 2. $100 |");
    				puts("| 3. Return |");
    				puts("==================================");
    				CreditMoney = getchar();
    				fflush(stdin);
    			} while (CreditMoney != '1' && CreditMoney != '2' && CreditMoney != '3');
    			switch (CreditMoney)
    			{ 
    			case '1':
    				puts("=========================================");
    				puts("| Your Credit money is $50,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("=========================================");
    				getchar();
    				break;
    			case '2':
    				puts("==========================================");
    				puts("| Your Credit money is $100,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("==========================================");
    				getchar();
    				break;
    			case '3':
    				break;
    			}
    			break;
    		case '3':
    			do{ 
    				puts("====================================");
    				puts("| Please select Debit money: |");
    				puts("| 1. $50 |");
    				puts("| 2. $100 |");
    				puts("| 3. $500 |");
    				puts("| 4. $1000 |");
    				puts("| 5. Return |");
    				puts("====================================");
    				DebitMoney = getchar();
    				fflush(stdin);
    			} while (DebitMoney != '1' && DebitMoney != '2' && DebitMoney != '3' \
    				&& DebitMoney != '4' && DebitMoney != '5');
    			switch (DebitMoney)
    			{ 
    			case '1':
    				puts("===========================================");
    				puts("| Your Debit money is $50,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("===========================================");
    				getchar();
    				break;
    			case '2':
    				puts("===========================================");
    				puts("| Your Debit money is $100,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("===========================================");
    				getchar();
    				break;
    			case '3':
    				puts("===========================================");
    				puts("| Your Debit money is $500,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("===========================================");
    				break;
    			case '4':
    				puts("===========================================");
    				puts("| Your Debit money is $1000,Thank you! |");
    				puts("| Press any key to return... |");
    				puts("===========================================");
    				break;
    			case '5':
    				break;
    			}
    			break;
    		case '4':
    			puts("================================");
    			puts("| Thank you for your using! |");
    			puts("| Good bye! |");
    			puts("================================");
    			return;
    		}
    	}
    }

## 14、用一维数组统计学生成绩 ##

#include <stdio.h>
    #include <stdlib.h>
    
    void main()
    { 	
    	int score[1024] = {  0 };
    	int n=0, i;
    	printf("Please enter number：");
    	scanf("%d", &n);
    
    	for (i = 0; i < n; ++i){ 
    		printf("Please enter the score of %d：", i + 1);
    		scanf("%d", &score[i]);
    	}
    
    	for (i = 0; i < n; ++i){ 
    		printf("No. %d's score\n", score[i]);
    	}
    	system("pause");
    }

## 13、二维矩阵实现矩阵装置 ##

/* 用二维数组实现矩阵的转置 */
    #include <stdio.h>
    #include <stdlib.h>
    #define ROW 3
    #define COL 4
    
    void main()
    { 	
    	int matrixA[ROW][COL], matrixB[COL][ROW];	/* 创建二维数组 */
    	int i, j;
    
    	printf("Enter elements of the matrixA,");
    	printf("%d*%d:\n", ROW, COL);
    
    	/* 手动输入矩阵 */
    	for (i = 0; i<ROW; i++)
    	{ 
    		for (j = 0; j<COL; j++)
    		{ 
    			scanf("%d", &matrixA[i][j]);
    		}
    	}
    
    	/* 将矩阵转置 */ 
    	for (i = 0; i<ROW; i++)
    	{ 
    		for (j = 0; j<COL; j++)
    		{ 
    			matrixB[j][i] = matrixA[i][j];
    		}
    	}
    
    	printf("MatrixB,");
    	printf("%d*%d:\n", COL, ROW);
    	for (i = 0; i<COL; i++)
    	{ 
    		for (j = 0; j<ROW; j++)
    		{ 
    			printf("%8d", matrixB[i][j]);
    		}
    		printf("\n");
    	}
    
    	getchar();
    }

## 14、求解二维数组的最大最小元素 ##

#include<stdio.h>
    #include<stdlib.h> 
    #define MAXN 20
    int a[MAXN][MAXN];
    
    
    void main()
    { 
    	int min, max;	/* 存储最大值、最小值 */
    	int row, col, n;
    
    	printf("Please input the order of the matrix:");/* 输入方阵的阶次 */
    	scanf("%d", &n);
    
    	/* 输入矩阵 */
    	printf("Please input the elements of the matrix,\n from a[0][0] to a[%d][%d]:", n - 1, n - 1);
    	for (row = 0; row<n; row++)
    		for (col = 0; col<n; col++)
    			scanf("%d", &a[row][col]);
    
    	/* 查找最大值 */
    	for (min = a[0][0], row = 0; row<n; row++)
    	{ 
    		/* 从每行选出最大数 */
    		for (max = a[row][0], col = 1; col<n; col++)/*从row行选出最大数 */
    		if (max<a[row][col])
    			max = a[row][col];
    		if (min>max)/* 保存至row行的最小数 */
    			min = max;
    	}
    	printf("The minimum of maximum number is %d\n", min);
    
    	/* 查找最小值 */
    	for (max = a[0][0], row = 0; row<n; row++)
    	{ 
    		/* 每行选出最小数 */
    		for (min = a[row][0], col = 1; col<n; col++)/* 从row行选出最小数 */
    		if (min>a[row][col])
    			min = a[row][col];
    		if (max<min)/*保存至row行的最大数 */
    			max = min;
    	}
    	printf("The maximum of minimum numbers is %d\n", max);
    
    	system("pause");
    }

## 15、利用数组求前n个质数 ##

#include<stdio.h>
    #include<stdlib.h>
    
    #define N 50
    void main()
    { 
    	int primes[N];
    	int pc, m, k;
    
    	printf("The first %d prime numbers are:\n", N);
    	primes[0] = 2;		/*2是第一个质数*/
    	pc = 1;				/*表示质数个数，已有第一个质数*/
    	m = 3;				/*被测试的数从3开始*/
    	while (pc<N)
    	{ 
    		/*调整m使它为下一个质数*/
    		k = 0;
    		while (primes[k] * primes[k] <= m){ 
    			if (m%primes[k] == 0)
    			{ 				/*m是合数*/
    				m += 2;		/*让m取下一个奇数*/
    				k = 1;		/*不必用primes[0]=2去测试m，所以k从一开始*/
    			}
    			else
    				k++;			/*继续用下一个质数去测试*/
    		}
    		primes[pc++] = m;
    		m += 2;				/*除2外，其余质数均是奇数*/
    	}
    
    	/*输出primes[0]至primes[pc-1]*/
    	for (k = 0; k<pc; k++)
    		printf("%4d", primes[k]);
    	printf("\n\n Press any key to quit...\n ");
    	system("pause");
    }

## 16、万年历 ##

#include <stdio.h>
    #include <stdlib.h>
    
    long int f(int year, int month)
    { /*f(年，月)＝年－1，如月<3;否则，f(年，月)＝年*/
    	if (month<3) return year - 1;
    	else return year;
    }
    
    long int g(int month)
    { /*g(月)＝月＋13，如月<3;否则，g(月)＝月＋1*/
    	if (month<3) return month + 13;
    	else return month + 1;
    }
    
    long int n(int year, int month, int day)
    { 
    	/*N=1461*f(年、月)/4+153*g(月)/5+日*/
    	return 1461L * f(year, month) / 4 + 153L * g(month) / 5 + day;
    }
    
    int w(int year, int month, int day)
    { 
    	/*w=(N-621049)%7(0<=w<7)*/
    	return(int)((n(year, month, day) % 7 - 621049L % 7 + 7) % 7);
    }
    
    int date[12][6][7] = { 0};
    
    /* 每个月份的最后一天日期 */
    int day_tbl[][12] = {  {  31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
    {  31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } };
    
    
    void main()
    { 
    	int sw, leap, i, j, k, wd, day;
    	int year; 
    	char title[] = "SUN MON TUE WED THU FRI SAT";
    
    	printf("Please input the year whose calendar you want to know: ");/*输入年*/
    	scanf("%d%*c", &year);	/*输入年份值和掠过值后的回车*/
    
    	/* 判闰年 */
    	sw = w(year, 1, 1);			// 判断该年的年初第一天是星期几
    	leap = year % 4 == 0 && year % 100 || year % 400 == 0;
    
    	/* 一年十二个月，将第i＋1月的日期填入日期表 */
    	for (i = 0; i<12; i++)
    		for (wd = 0, day = 1; day <= day_tbl[leap][i]; day++)
    		{ 	
    			date[i][wd][sw] = day;
    			sw = ++sw % 7;				/* 每星期七天，以0至6计数 */
    			if (sw == 0) wd++;			/* 日期表每七天一行，星期天开始新的一行 */
    		}
    	
    	printf("\n|==================The Calendar of Year %d =====================|\n|", year);
    	for (i = 0; i<6; i++)
    	{ /* 先测算第i+1月和第i+7月的最大星期数 */
    		for (wd = 0, k = 0; k<7; k++)/* 日期表的第六行有日期，则wd!=0 */
    			wd += date[i][5][k] + date[i + 6][5][k];
    		wd = wd ? 6 : 5;
    		printf("%2d %s %2d %s |\n|", i + 1, title, i + 7, title);
    		for (j = 0; j<wd; j++)
    		{ 
    			printf(" ");/* 输出四个空白符 */
    
    			/* 左栏为第i+1月，右栏为第i+7月 */
    			for (k = 0; k<7; k++)
    				if (date[i][j][k])
    					printf("%4d", date[i][j][k]);
    				else printf(" ");
    
    			printf(" ");/* 输出十个空白符 */
    
    			for (k = 0; k<7; k++)
    				if (date[i + 6][j][k])
    					printf("%4d", date[i + 6][j][k]);
    				else printf(" ");
    			printf(" |\n|");
    		}
    	}
    	puts("=================================================================|");
    	system("pause");
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASnhpZXBj_size_20_color_FFFFFF_t_70_g_se_x_16]

## 17、数组排序 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void rest(int a[], int n)
    { 
    	int i, low, high, tmp;
    
    	for (i = 0, low = 0, high = n - 1; i <= high;)
    	{ 
    		if (a[i]>0)
    		{ 
    			/*a[i]与a[high]交换，随之high减1*/
    			int tmp = a[i];
    			a[i] = a[high];
    			a[high--] = tmp;
    		}
    		else if (a[i] == 0)
    			i++; /* 掠过该元素 */
    		else
    		{ 
    			/*a[i]与a[low]交换，随之low增1, i增1*/
    			tmp = a[i];
    			a[i++] = a[low];
    			a[low++] = tmp;
    		}
    	}
    }
    int s[] = {  8, 4, 0, -1, 6, 0, -5 };
    
    void main()
    { 
    	int i;
    	printf("The arry before rest is:\n");
    	for (i = 0; i<sizeof(s) / sizeof(s[0]); i++)
    		printf("%4d", s[i]);
    
    	/* 排序 */
    	rest(s, sizeof(s) / sizeof(s[0]));
    
    	printf("\nThe arry after rest is:\n");
    	for (i = 0; i<sizeof(s) / sizeof(s[0]); i++)
    		printf("%4d", s[i]);
    	printf("\n");
    	system("pause");
    }

## 18、任意进制转换 ##

#include<stdlib.h>
    #include<stdio.h>
    
    /* 函数trans将无符号整数n翻译成d（2<＝d<＝16）进制表示的字符串s */
    #define M sizeof(unsigned int)*8
    static char digits[] = "0123456789ABCDEF"; /* 十六进制数字的字符 */
    
    /* * @func：处理进制转换 * @param n：传入要转换的数值 * @param d：转化对应的进制 * @param s：传出参数 */
    int trans(unsigned n, int d, char s[])
    { 
    
    	char buf[M + 1] = { 0};
    	int j, i = M;
    
    	/* 不合理的进制，置s为空字符串 */
    	if (d<2 || d>16)
    	{ 
    		s[0] = '\0';	
    		return 0;	/* 不合理的进制，函数返回0 */
    	}
    	buf[i] = '\0';
    
    	/*译出最低位，对应字符存入对应工作数组中*/
    	do
    	{ 
    		buf[--i] = digits[n%d];	
    		n /= d;
    	} while (n);
    
    	/* 将译出在工作数组中的字符串复制到s */
    	for (j = 0; (s[j] = buf[i]) != '\0'; j++, i++);
    	/* 其中控制条件可简写成s[j]=buf[i] */
    	return j;
    }
    
    
    void main()
    { 
    	unsigned int num = 253;
    	int scale[] = {  2, 8, 10, 16, 1 };
    	char ret[33];
    	int i;
    
    	for (i = 0; i<sizeof(scale) / sizeof(scale[0]); i++)
    	{ 
    		if (trans(num, scale[i], ret))
    			printf("%5d = %s(%d)\n", num, ret, scale[i]);
    		else
    			printf("%5d => (%d) Error! \n", num, scale[i]);
    	}
    	system("pause");
    }

## 19、回文数 ##

#include<stdlib.h>
    #include<stdio.h>
    
    
    /* main函数用于测试circle函数 */
    int num[] = {  232, 27, 851 };
    int scale[] = {  2, 10, 16 };
    
    
    /* 函数circle用于判断正整数n的d进制数表示形式是否是回文数 */
    int circle(int n, int d)
    { 
    	int s = 0, m = n;
    	while(m)
    	{ 
    		s = s*d + m%d;
    		m /= d;
    	}
    
    	return s==n;
    }
     
    
    void main()
    { 
    	int i,j;
    	for (i = 0; i < sizeof(num) / sizeof(num[0]); i++)
    		for (j = 0; j < sizeof(scale) / sizeof(scale[0]); j++)
    			if (circle(num[i], scale[j]))
    				printf("%d -> (%d) is a Circle Number!\n", num[i], scale[j]);
    			else
    				printf("%d -> (%d) is not a Circle Number!\n", num[i], scale[j]);
    
    	system("pause");
    }

## 20、求数组前n项和 ##

#include<stdlib.h>
    #include<stdio.h>
    
    int a[] = {  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
    
    
    void main()
    { 
    	int i, sum = 0;
    
    	for (i = 0; i<sizeof(a) / sizeof(a[0]); i++)
    		sum += a[i];
    	printf("ret：%d\n", sum);
    	system("pause");
    }

## 21、求解钢材切割的最佳订单 ##

#include <stdio.h>
    #include <stdlib.h>
    #define N 20
    #define DELTA 2
    int bestlen;
    int bestsele[N];
    int sele[N];
    int n;
    int orderlen[N];
    int total;
    
    void my_try()
    { 
    	int i, len;
    	for (len = i = 0; i<n; i++)	/* 求当前选中的用料量 */
    		if (sele[i])
    			len += orderlen[i] + DELTA;
    	if (len - DELTA <= total)	/* 注意最后一段可能不需要切割 */
    	{ 
    		/* 找到一个更好的解 */
    		if (bestlen < len)
    		{ 
    			bestlen = len;
    			for (i = 0; i<n; i++)
    				bestsele[i] = sele[i];
    		}
    
    		/* 对所有未选定单逐一作选中尝试循环 */
    		for (i = 0; i<n; i++) 
    			if (!sele[i])
    			{ 
    				sele[i] = 1;	/* 做选中尝试*/
    				my_try();
    				sele[i] = 0;
    			}
    	}
    }
    
    
    void main()
    { 
    	int i;
    	printf("Please enter total length of the steel: ");/* 输入钢材总长 */
    	scanf("%d", &total);
    	printf("Please enter number of order:");  /* 输入定单数 */
    	scanf("%d", &n);
    	printf("Please enter the orders:"); /* 输入各定单 */
    	for (i = 0; i<n; i++)
    		scanf("%d", &orderlen[i]);
    	bestlen = 0;	/*最佳解用料的初值 */
    	for (i = 0; i<n; i++)
    		sele[i] = bestsele[i] = 0;	/*置当前选择和最佳选择初值 */
    	my_try();	/* 调用函数求解 */
    	for (i = 0; i<n; i++) /* 输出结果 */
    		if (bestsele[i])
    			printf("order %d length = %d\n", i + 1, orderlen[i]);
    	system("pause");
    }

## 22、通过指针比较整数大小 ##

#include <stdio.h>
    #include <stdlib.h>
    void main()
    { 
    	int x, y, z, t;	
    	int *xp = &x,	/* 定义指针变量xp,并赋值为x的地址，使xp指向x */
    		*yp = &y,	/* 定义指针变量yp,并赋值为y的地址，使yp指向y */
    		*zp = &z;	/* 定义指针变量zp,并赋值为z的地址，使zp指向z */
    
    	printf("Please input x,y,z: ");
    	scanf("%d %d %d", xp, yp, zp);	/* 通过变量的指针，为变量输入值 */
    	if (*xp>*yp)	/* 通过指向变量的指针引用变量的值 */
    	{ 
    		t = *xp;	/* 通过指向变量的指针引用变量的值 */
    		*xp = *yp;/* 通过指向变量x的指针xp,引用变量x的值 */
    		*yp = t;	/* 通过指向变量y的指针yp,引用变量y的值 */
    	}
    	if (*xp>*zp)	/* 通过指向变量的指针,引用变量的值 */
    	{ 
    		t = *xp;	/* 通过指向变量x的指针xp,引用变量x的值 */
    		*xp = *zp;/* 通过指向变量x的指针xp,引用变量x的值 */
    		*zp = t;	/* 通过指向变量z的指针zp,引用变量z的值 */
    	}
    	if (*yp>*zp)	/* 通过指向变量的指针,引用变量的值 */
    	{ 
    		t = *yp;	/* 通过指向变量的指针,引用变量的值 */
    		*yp = *zp;/* 通过指向变量y的指针yp,引用变量y的值 */
    		*zp = t;/* 通过指向变量z的指针zp,引用变量z的值 */
    	}
    
    	printf("x = %d\ty = %d\tz = %d\n", x, y, z);
    
    	system("pause");
    }

## 23、指向数组的指针 ##

#include <stdio.h>
    #include <stdlib.h>
    
    int a[] = {  1, 2, 3, 4, 5 };
    
    #define N sizeof a/sizeof a[0]
    
    void main()
    { 
    	int j, *p; 
    
    	/* 数组名和下标顺序访问数组的元素 */
    	for (j = 0; j<N; j++)
    		printf("a[%d]\t= %d\t", j, a[j]);
    	printf("\n");
    
    	/* 让指针顺序指向数组的各元素，遍历数组 */
    	for (p = a; p<a + N; p++)
    		printf("*p\t= %d\t", *p);
    	printf("\n");
    
    	/* 指针与游标变量结合，改变游标变量遍历数组 */
    	for (p = a, j = 0; p + j<a + N; j++)
    		printf("*(p+%d)\t= %d\t", j, *(p + j));
    	printf("\n");
    
    	/* 指针与游标变量结合，用指针和下标遍历数组 */
    	for (p = a + N - 1, j = N - 1; j >= 0; j--)
    		printf("p[-%d]\t= %d\t", j, p[-j]);
    
    	system("pause");
    }

## 24、寻找指定元素的指针 ##

#include <stdio.h>
    #include <stdlib.h>
    
    #define MAX 20
    
    
    /* * @param apt：已知数表的首元指针; * @param n：数表中元素个数; * @param key：要寻找的值; * return：返回元素下标 */
    int search(int *apt, int n, int key)
    { 
    	int *p;
    	for (p = apt; p<apt + n; p++)
    	if (*p == key)
    		return p - apt;
    	return -1;
    }
    
    /* * @param apt：已知数表的首元指针; * @param n：数表中元素个数; * @param key：要寻找的值; * return: 返回元素指针 */
    int *find(int *apt, int n, int key)
    { 
    	int *p;
    	for (p = apt; p<apt + n; p++)
    	if (*p == key)
    		return p;
    	return NULL;
    }
    
    int a[] = {  90, 80, 70, 60, 50, 40, 30, 20, 10, 9, 8, 7, 6, 5, 42, 40, 50, 1, 2, 3 };
    void main()
    { 
    	int i, key;
    	printf("The elements of array a is:\n");
    	for (i = 0; i<sizeof(a) / sizeof(a[0]); i++)
    		printf(" %d", a[i]);
    	printf("\nThe address of a[0] is: %d.\n", &a[0]);	// 打印元素首地址
    
    	/* 输入要查找的值 */
    	printf("Please input the key number you want to search: ");
    	scanf("%d", &key);
    
    	i = search(a, sizeof(a) / sizeof(a[0]), key);
    	printf("The label number of the key number %d in the array is: %d.\n", key, i);
    	printf("The point value of the key number %d in the array is: %d.", key, find(a, sizeof(a) / sizeof(a[0]), key));
    
    	system("pause");
    }

## 25、寻找相同元素的指针 ##

#include <stdio.h>
    #include <stdlib.h>
    
    
    /* *@func：在已知两个从小到大有序的数表中寻找都出现的第一个元素的指针; *@param pa: 传入数组1; *@param pb: 传入数组2; *@param an: 传入数组1长度； *@param bn：传入数组2长度； */
    int *search(int *pa,int *pb,int an,int bn)
    { 
    	int *ca,*cb;
    
    	ca = pa; cb = pb;	/* 为ca、cb设定初值 */
    	while(ca < pa+an && cb< pb+bn )
    	{ 
    	/* 在两个数表中找下一个相等的元素 */
    		if(*ca < *cb)		/* 数表1的当前元素<数表2的当前元素 */
    		    ca++;			/* 调整数表1的当前元素指针 */
    		else if(*ca>*cb)	/* 数表1的当前元素>数表2的当前元素 */
    		    cb++;			/* 调整数表2的当前元素指针 */
    		else				/* 数表1的当前元素==数表2的当前元素 */
    			return ca;		/* 在前两个数表中找到相等元素, 则返回 */
    	}
    	return NULL;
    }
    
    void main( )
    { 
    	int *vp,i;
    	int a[]={ 1,3,5,7,9,13,15,27,29,37};
    	int b[]={ 2,4,6,8,10,13,14,27,29,37};
    	int len_a = sizeof(a) / sizeof(a[0]);
    	int len_b = sizeof(b) / sizeof(b[0]);
    
    	// 输出俩行数组
    	puts("The elements of array a is:");
    	for (i = 0; i < len_a; i++)
    		printf(" %d",a[i]);
    	puts("The elements of array b is:");
    	for(i=0;i<sizeof(b)/sizeof(b[0]);i++)
    		printf(" %d",b[i]);
    
    	vp = search(a, b, len_a, len_b);
    
    	if(vp) printf("\nThe first same number in both arrays is %d\n",*vp);
    	else printf("Not found!\n");
    
    	system("pause");
    
    }

## 26、阿拉伯数字转化为罗马数字 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define ROWS 4
    #define COLS 4
    int nums[ROWS][COLS] = {  {  1000, 1000, 1000, 1000 },
    						{  900, 500, 400, 100 },
    						{  90, 50, 40, 10 },
    						{  9, 5, 4, 1 }
    					};
    
    char *roms[ROWS][COLS] = {  {  "m", "m", "m", "m" },
    						{  "cm", "d", "cd", "c" },
    						{  "xc", "l", "xl", "x" },
    						{  "ix", "v", "iv", "i" } 
    					};
    /** 检查参数合理性 */
    void checknum(int val)
    { 
    	if (val<1 || val>9999)
    	{ 
    		printf("The number must be in range 1..9999.\n");
    		exit(0);
    	}
    }
    
    /** 将整数转换成罗马数字表示 */
    void to_roman(int decimal, char roman[])
    { 
    	int power, index;
    	roman[0] = '\0';
    	for (power = 0; power<ROWS; power++)
    		for (index = 0; index<COLS; index++)
    			while (decimal >= nums[power][index])
    			{ 
    				strcat(roman, roms[power][index]);
    				decimal -= nums[power][index];
    			}
    }
    
    void main()
    { 
    	int low;
    	char roman[25];
    
    	printf("请输入第一个整数：");
    	scanf("%d", &low);
    
    	checknum(low);
    
    	to_roman(low, roman);
    	printf("%d\t%s\n", low, roman);
    
    
    	system("pause");
    }

## 27、字符替换 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define MAX 50
    
    /* 将s中出现s1的字符串替换成s2 */
    void rep(char *s, char *s1, char *s2)
    { 
    	char *p;
    
    	for (; *s; s++)							/* 顺序访问字符串s中的每个字符 */
    	{ 
    		for (p = s1; *p && *p != *s; p++);	/* 检查当前字符是否在字符串s1中出现 */
    			if (*p)*s = *(p - s1 + s2);			/* 当前字符在字符串s1中出现，用字符串s2中的对应字符代替s中的字符 */
    	}
    }
    void main()
    { 
    	char s[MAX];	/*="ABCABC";*/
    	char s1[MAX], s2[MAX];
    
    	/* 交互从键盘获取字符串 */ 
    	printf("Please input the string for s:");
    	scanf("%s", s);
    	printf("Please input the string for s1:");
    	scanf("%s", s1);
    	printf("Please input the string for s2:");
    	scanf("%s", s2);
    
    	rep(s, s1, s2);
    	puts("The string of s after displace is:");
    	printf("%s", s);
    
    	system("pause");
    }

## 28、从键盘读入实数 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define ERR 5
    #define OK 6
    
    int status;
    double result, sig, scale;
    
    /** 处理数的符号函数 */
    int sign(int c)
    { 
    	if (c == '-')/*若为负号，置负数标记*/
    		sig = -sig;
    	return sig;
    }
    
    /** 转换整数部分，转换一位整数位 */
    int integer(int c)
    { 
    	result = result*10.0 + c - '0';
    
    	return result;
    }
    
    /** 转换小数部分，转换一位小数位 */
    int decimal(int c)
    { 
    	result += (c - '0')*scale;
    	scale /= 10.0;
    
    	return scale;
    }
    
    
    /** 状态表 */
    int statbl[][4] = {  {  1, 2, 3, ERR },	/*0*/
    					{  ERR, 2, 3, ERR },	/*1*/
    					{  OK, 2, 4, OK },	/*2*/
    					{  ERR, 4, ERR, ERR },/*3*/
    					{  OK, 4, OK, OK }   /*4*/
    };										
    
    
    /*转换函数表*/
    int(*funtbl[][4])(int) = {  {  sign, integer, NULL, NULL },
    						{  NULL, integer, NULL, NULL },
    						{  NULL, integer, NULL, NULL },
    						{  NULL, decimal, NULL, NULL },
    						{  NULL, decimal, NULL, NULL }
    					};
    
    int readreal(double *dp)
    { 
    	int c, ckind;
    	sig = 1.0;
    	result = 0.0;
    	scale = 0.1;
    
    	/* 跳过前导空白符 */
    	while ((c = getchar()) == ' ' || c == '\n' || c == '\t');
    	status = 0;									/* 置初始状态 */
    	for (;;)
    	{ 
    		/* 分类当前字符 */
    		if (c == '+' || c == '-') 
    			ckind = 0;							/* 数的符号字符 */
    		else if (c >= '0'&&c <= '9') 
    			ckind = 1;							/* 数字符 */
    		else if (c == '.') 
    			ckind = 2;							/* 小数点 */
    		else 
    			ckind = 3;							/* 其它字符 */
    
    		/* 字符转换 */
    		if (funtbl[status][ckind])				/* 如有转换函数 */
    			(*funtbl[status][ckind])(c);		/* 执行相应的函数 */
    		status = statbl[status][ckind];			/* 设置新的状态 */
    		if (status == ERR || status == OK) break;/* 结束：出错或成功 */
    		c = getchar();
    	}
    	ungetc(c, stdin);							/* 归还数德结束符 */
    	if (status == OK)
    	{ 
    		*dp = result *sig;						/* 读入数按指针参数赋给相应变量 */
    		return 1;
    	}
    	return -1;				
    }
    
    void main()
    { 
    	double x;
    	printf("Please input real numbers (use nonreal char to end input): ");
    	while (readreal(&x) == 1)
    		printf("The real number you input is: %f ", x);
    
    	system("pause");
    }

## 29、字符行排版 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    /* 字符排版函数,将字符行内单字之间的空白字符平均分配插入到单字之间*/
    #define N 80
    
    void edit(char *s)
    { 
    	int i, sp, w, inw, v, r;
    	char buf[N], *str;
    	for (inw = sp = w = i = 0; s[i]; i++)
    	{ 
    		/* 统计空白个数*/
    		if (s[i] == ' ')
    		{ 	
    			sp++;
    			inw = 0;	/* 置空白符状态*/
    		}
    		else if (!inw)
    		{ 
    			w++;		/* 统计单字个数*/
    			inw = 1;	/* 置单字状态*/
    		}
    	}
    
    	/* 单字数不超过1, 不排版 */
    	if (w <= 1)
    		return;	
    	v = sp / (w - 1);	/* 每个间隔平均空白符 */
    	r = sp % (w - 1);	/* 多余的空白符 */
    	strcpy(buf, s);
    	for (str = buf;;)
    	{ 
    		while (*str == ' ')str++;  /* 掠过空白符 */
    		for (; *str&&*str != ' ';) /* 复制单字 */
    			*s++ = *str++;b
    		if (--w == 0)
    			return;					/* 全部单字复制完毕，返回 */
    		for (i = 0; i<v; i++)
    			*s++ = ' ';				/* 插入间隔空白符 */
    		if (r)
    		{ 
    			*s++ = ' ';				/* 插入一个多余空白符 */
    			r--;
    		}
    	}
    }
    char buff[N];
    
    void main()		
    { 
    	printf("This is a typeset program!\nPlease input a character line:");
    	gets(buff);
    	edit(buff);
    	printf("\nThe character line after typeset is:\n\n%s", buff);
    
    	system("pause");
    }

## 30、字符排列 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    /* 字符串的所有字符排列函数，用已知字符串s中的所有字符，生成由其中n个字符组成的所有字符排列 */
    #define N 20
    char w[N];
    void perm(int n, char *s)
    { 
    	char s1[N];
    	int i;
    	if (n<1)
    		printf("%s\n", w); /* 一个排列生成输出 */
    	else
    	{ 
    		strcpy(s1, s);	/* 保存本层次可使用的字符 */
    		for (i = 0; *(s1 + i); i++)	/* 依次选本层次可用字符 */
    		{ 
    			*(w + n - 1) = *(s1 + i);/* 将选用字符填入正在生成的字符排列中 */
    			*(s1 + i) = *s1;
    			*s1 = *(w + n - 1);
    			perm(n - 1, s1 + 1);	 /* 递归 */
    		}
    	}
    }
    
    void main()
    { 
    	int n = 2;
    	char s[N];
    	w[n] = '\0';
    	printf("This is a char permutation program!\nPlease input a string:");
    	scanf("%s", s);
    	printf("Please input the char number of permuted:");
    	scanf("%d", &n);
    	printf("The permuted chars are:");
    	perm(n, s);
    
    	system("pause");
    }

## 31、判断字符串是否回文 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define MAX 50
    
    int cycle(char *s)
    { 
    	char *h, *t;
    
    	/* * 使用俩个指针分别指向字符串数组的头部和尾部，判断俩个字符是否相等 */
    	for (h = s, t = s + strlen(s) - 1; t>h; h++, t--)
    	if (*h != *t) break;
    	return t <= h;
    }
    
    void main()
    { 
    	char s[MAX];
    
    	while (1)
    	{ 
    		printf("Please input the string you want to judge (input ^ to quit):");
    		scanf("%s", s);
    		if (s[0] == '^') break;
    		if (strlen(s) <= 2) continue;
    		if (cycle(s))
    			printf("%s是回文数\n", s);
    		else
    			printf("%s不是回文数\n", s);
    	}
    
    	system("pause");
    }

## 32、通讯录的输入输出 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define ZIPLEN 10
    #define PHONLEN 15
    
    typedef struct addrbook
    { 
    	char *name;			/*姓名*/
    	char *address;		/*地址*/
    	char zip[ZIPLEN];	/*邮政编码*/
    	char phone[PHONLEN];/*电话号码*/
    }addrBook;
    
    int readaddr(addrBook *);
    void writeaddr(addrBook*);
    
    
    void main()
    { 
    	addrBook p[100];
    	int i, j;
    	for (i = 0; readaddr(p + i); i++);
    	for (j = 0; j<i; j++) writeaddr(p + j);
    
    	system("pause");
    }
    
    /* 函数readaddr用于输入一个通信录函数 */
    int readaddr(addrBook *dpt)
    { 
    	int len;
    	char buf[120];							/* 输入字符串的缓冲区 */
    
    	/* 输入姓名 */
    	printf("Please input the Name:");	
    	if (scanf("%s", buf) == 1)
    	{ 
    		len = strlen(buf);
    		dpt->name = (char *)malloc(len + 1);/* 申请存贮姓名的空间 */
    		strcpy(dpt->name, buf);
    	}
    	else return 0;						/*Ctrl+Z结束输入*/
    
    	/* 输入地址 */
    	printf("Please input the Address:");
    	if (scanf("%s", buf) == 1)
    	{ 
    		len = strlen(buf);
    		dpt->address = (char *)malloc(len + 1);/*申请存贮地址的空间*/
    		strcpy(dpt->address, buf);
    	}
    	else
    	{ 
    		free(dpt->name);/* 释放存贮姓名的空间 */
    		return 0;
    	}
    
    	/* 输入邮编 */
    	printf("Please input the Zip code:");
    	if (scanf("%s", buf) == 1)
    		strncpy(dpt->zip, buf, ZIPLEN - 1);
    	else
    	{ 
    		free(dpt->name);/*释放存贮姓名的空间*/
    		free(dpt->address);/*释放存贮地址的空间*/
    		return 0;
    	}
    
    	/* 输入电话号码 */
    	printf("Please input the Phone number:");
    	if (scanf("%s", buf) == 1)
    		strncpy(dpt->phone, buf, PHONLEN - 1);
    	else
    	{ 
    		free(dpt->name);
    		free(dpt->address);
    		return 0;
    	}
    	return 1;
    }
    
    /* 函数writeaddr用于输出通讯录 */
    void writeaddr(addrBook *dpt)
    { 
    	printf("Name : %s\n", dpt->name);		/*输出姓名*/
    	printf("Address : %s\n", dpt->address);	/*输出地址*/
    	printf("Zip : %s\n", dpt->zip);			/*输出邮编*/
    	printf("Phone : %s\n\n", dpt->phone);	/*输出电话号码*/
    }

## 33、扑克牌的结构表示 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    enum suits{  CLUBS=0, DIAMONDS, HEARTS, SPADES } suit;
    typedef struct card
    { 
    	enum suits suit;
    	char value[3];
    }Card;
    
    Card deck[52];
    char cardval[][3] = {  "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
    char suitsname[][9] = {  "CLUBS", "DIAMONDS", "HEARTS", "SPADES" };
    
    void main()
    { 
    	int i, j, k;
    
    	for (i = 0; i <= 12; i++)
    	for (k = CLUBS; k <= SPADES; k++)
    	{ 
    		j = i * 4 + k;
    		deck[j].suit = (enum suits)k;
    		strcpy(deck[j].value, cardval[i]);
    	}
    	for (j = 0; j<52; j++)
    		printf("(%s%3s)%c", suitsname[deck[j].suit], deck[j].value, j % 4 == 3 ? '\n' : '\t');
    
    	system("pause");
    }

## 34、用“结构”统计学生成绩 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    
    #define N 200
    #define SCORES 5
    #define NUMLEN 10
    
    typedef struct std_type{ 
    	char no[NUMLEN];		/* 学号 */
    	char *name;				/* 名字符串指针 */
    	int scores[SCORES];		/* 五门功课的成绩 */
    }stdType;
    
    stdType students[N];
    int order[N];
    int total[N];
    
    /* [函数]输入一个学生信息函数 */
    int readastu(stdType *spt)
    { 
    	int len, j;
    	char buf[120];/*输入字符串的缓冲区*/
    
    	/*输入学号*/
    	printf("Number : ");
    	if (scanf("%s", buf) == 1)
    		strncpy(spt->no, buf, NUMLEN - 1);
    	else
    		return 0;/*Ctrl+Z结束输入*/
    
    	/*输入姓名*/
    	printf("Name : ");
    	if (scanf("%s", buf) == 1)
    	{ 
    		len = strlen(buf);
    		spt->name = (char *)malloc(len + 1);/*申请存贮姓名的空间*/
    		strcpy(spt->name, buf);
    	}
    	else return 0;/*Ctrl+Z结束输入*/
    
    	/*输入成绩*/
    	printf("Scores : ");
    	for (j = 0; j<SCORES; j++)
    	if (scanf("%d", spt->scores + j) != 1)
    		break;
    	if (j == 0)/*一个成绩也未输入*/
    	{ 
    		free(spt->name);/* 释放存贮姓名的空间 */
    		return 0;
    	}
    	for (; j<SCORES; j++)/* 少数未输入的成绩用0分代之 */
    		spt->scores[j] = 0;
    	return 1;
    }
    
    /* [函数]输出一个学生信息的函数 */
    void writeastu(stdType *spt)
    { 
    	int i;
    
    	printf("Number : %s\n", spt->no);/*输出学号*/
    	printf("Name : %s\n", spt->name);/*输出姓名*/
    	printf("Scores : ");/*输出成绩*/
    	for (i = 0; i<SCORES; i++)
    		printf("%4d", spt->scores[i]);
    	printf("\n\n");
    }
    
    void main()
    { 
    	int n, i, j, t;
    
    	for (n = 0; readastu(students + n); n++);
    	/*采用冒泡法对学生信息数组排序*/
    	for (i = 0; i<n; i++)
    	{ 
    		order[i] = i;/*预置第i个输入的学生*/
    		for (t = 0, j = 0; j<SCORES; j++)/*求第i个学生的总分*/
    			t += students[i].scores[j];
    		total[i] = t;
    	}
    	/*冒泡排序*/
    	for (i = 0; i < n - 1; i++)/* 共扫视n-1遍 */
    	for (j = 0; j < n - 1 - i; j++)
    	if (total[order[j]]<total[order[j + 1]])
    	{ /*交换名次*/
    		t = order[j];
    		order[j] = order[j + 1];
    		order[j + 1] = t;
    	}
    	for (j = 0; j<n; j++)/*输出*/
    		writeastu(students + order[j]);
    	system("pause");
    }

## 35、报数游戏 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    struct ele{ 
    	int no;
    	struct ele *next;
    };
    
    void main()
    { 
    	int n, m, i;
    	struct ele *h, *u, *p;
    
    	printf("Please input n&m:");
    	scanf("%d %d", &n, &m);		/*输入n和m*/
    	h = u = (struct ele *)malloc(sizeof(struct ele));/*形成首表元*/
    	h->no = 1;
    	for (i = 2; i <= n; i++)	/*形成其余的n-1个表元*/
    	{ 
    		u->next = (struct ele *)malloc(sizeof(struct ele));
    		u = u->next;
    		u->no = i;				/*第i个表元置编号i*/
    	}
    	u->next = h;				/*末表元后继首表元，形成环*/
    	printf("The numbers of who will quit the cycle in turn are:");
    	while (n)
    	{ 
    		for (i = 1; i<m; i++)		/*掠过m－1个表元*/
    			u = u->next;
    		p = u->next;				/*p指向第m个表元*/
    		u->next = p->next;			/*第m个表元从环中脱钩*/
    		printf("%4d", p->no);
    		free(p);					/*释放第m个表元占用的空间*/
    		n--;
    	}
    	system("pause");
    }

## 36、模拟家族关系 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #include <stdio.h>
    #define CHILDREN 5
    
    typedef struct person{ 
    	char *name;							/*名字符串指针*/
    	char sex;							/*性别：男用字符'M'；女用字符'F'*/
    	struct person *father;				/*指向父亲*/
    	struct person *mother;				/*指向母亲*/
    	struct person *mate;				/*指向配偶*/
    	struct person *children[CHILDREN];	/*指向子女*/
    }Person;
    
    /* 增加新人 */
    Person *add_person(char *name, char sex)
    { 
    	Person *p;
    	int index;
    
    	p = (Person *)malloc(sizeof(Person));
    	p->name = (char *)malloc(strlen(name) + 1);
    	strcpy(p->name, name);
    	p->sex = sex;
    	p->father = NULL;
    	p->mother = NULL;
    	p->mate = NULL;
    	for (index = 0; index<CHILDREN; index++)
    		p->children[index] = NULL;
    	return p;
    }
    
    /* 建立父－子关系 */
    void father_child(Person *father, Person *child)
    { 
    	int index;
    
    	for (index = 0; index < CHILDREN - 1; index++)	/* 寻找一个空缺的子女指针 */
    		if (father->children[index] == NULL)		/*若没有空缺，则填在最后 */
    			break;
    	father->children[index] = child;				/* 建立父－子关系 */
    	child->father = father;
    }
    /* 建立母－子关系 */
    void mother_child(Person *mother, Person *child)
    { 
    	int index;
    	for (index = 0; index<CHILDREN - 1; index++)	/*寻找一个空缺的子女指针*/
    		if (mother->children[index] == NULL)		/*若没有空缺，则填在最后*/
    			break;
    	mother->children[index] = child;				/*建立母－子关系*/
    }
    
    /* 建立配偶关系 */
    void mate(Person *h, Person *w)
    { 
    
    	h->mate = w;	/*建立配偶关系*/
    	w->mate = h;
    }
    
    /* 检查两人是否是堂兄妹 */
    int brothersinlaw(Person *p1, Person *p2)
    { 
    	Person *f1, *f2;
    
    	if (p1 == NULL || p2 == NULL || p1 == p2) return 0;
    	if (p1->sex == p2->sex) return 0;			/* 根据性别不可能是堂兄妹 */
    	f1 = p1->father;
    	f2 = p2->father;
    	if (f1 != NULL && f1 == f2) return 0;		/* 是兄妹，不是堂兄妹 */
    	while (f1 != NULL&&f2 != NULL&&f1 != f2)	/* 考虑远房情况 */
    	{ 
    		f1 = f1->father;
    		f2 = f2->father;
    		if (f1 != NULL&&f2 != NULL&&f1 == f2) return 1;
    	}
    	return 0;
    }
    
    /* 用于输出人物p的姓名，性别和各种关系 */
    void print_relate(Person *p)
    { 
    	int index, i;
    	if (p->name == NULL)
    		return;
    	if (p->sex == 'M')
    		printf("%s is male.", p->name);
    	else
    		printf("%s is female.", p->name);
    	if (p->father != NULL)
    		printf("%s's father is %s.", p->name, p->father->name);
    	if (p->mother != NULL)
    		printf("%s's mother is %s.", p->name, p->mother->name);
    	printf("\n");
    	if (p->mate != NULL)
    	if (p->sex == 'M')
    		printf("His wife is %s.", p->mate->name);
    	else
    		printf("Her husband is %s.", p->mate->name);
    	if (p->children != NULL)
    	{ 
    		for (index = 0; index<CHILDREN - 1; index++)/*寻找一个空缺的子女指针*/
    		if (p->children[index] == NULL)/*若没有空缺，index为子女个数 */
    			break;
    		if (index>0)
    			printf(" Children are:");
    		for (i = 0; i<index; i++)
    			printf(" %s", p->children[i]->name);
    	}
    	printf("\n");
    
    }
    void main()
    { 
    	char *name[8] = {  "John", "Kate", "Maggie", "Herry", "Jason", "Peter", "Marry", "Jenny" };
    	char male = 'M', female = 'F';
    	Person *pGrandfather, *pFather1, *pFather2, *pMother1, *pMother2, *pSon, *pDaughter, *pCousin;
    	// 添加任务信息
    	pGrandfather = add_person(name[0], male);
    	pFather1 = add_person(name[3], male);
    	pFather2 = add_person(name[4], male);
    	pMother1 = add_person(name[1], female);
    	pMother2 = add_person(name[2], female);
    	pSon = add_person(name[5], male);
    	pDaughter = add_person(name[6], female);
    	pCousin = add_person(name[7], female);
    
    	// 父子关系
    	father_child(pGrandfather, pFather1);
    	father_child(pGrandfather, pFather2);
    	father_child(pFather1, pSon);
    	father_child(pFather1, pDaughter);
    	father_child(pFather2, pCousin);
    	
    	// 配偶关系
    	mate(pFather1, pMother1);
    	mate(pFather2, pMother2);
    
    	// 母子关系
    	mother_child(pMother1, pSon);
    	mother_child(pMother1, pDaughter);
    	mother_child(pMother2, pCousin);
    
    	/* 输出各种关系 */
    	print_relate(pGrandfather);
    	print_relate(pFather1);
    	print_relate(pFather2);
    	print_relate(pMother1);
    	print_relate(pMother2);
    	print_relate(pSon);
    	print_relate(pDaughter);
    	print_relate(pCousin);
    
    
    	if (!brothersinlaw(pDaughter, pCousin))
    		printf("%s and %s are not brothers (sisters) in law.\n", pDaughter->name, pCousin->name);
    	else
    		printf("%s and %s are brothers (sisters) in law.\n", pDaughter->name, pCousin->name);
    	if (!brothersinlaw(pSon, pCousin))
    		printf("%s and %s are not brothers (sisters) in law.\n", pSon->name, pCousin->name);
    	else
    		printf("%s and %s are brothers (sisters) in law.\n", pSon->name, pCousin->name);
    	if (!brothersinlaw(pSon, pDaughter))
    		printf("%s and %s are not brothers (sisters) in law.\n", pSon->name, pDaughter->name);
    	else
    		printf("%s and %s are brothers (sisters) in law.\n", pSon->name, pDaughter->name);
    
    	system("pause");
    }

## 37、统计文件的字符数 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    void main()
    { 
    	char fname[80];	/*存贮文件名*/
    	char buf[1024];
    	FILE *rfp;
    	long count;		/*文件字符计数器*/
    
    	printf("Please input the file's name:\n");
    	scanf("%s", fname);
    	if ((rfp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		exit(1);
    	}
    	count = 0;
    	while (fgets(buf, 1024, rfp) != NULL)
    		count += strlen(buf);
    	fclose(rfp);
    	printf("There are %ld characters in file %s.\n", count, fname);
    
    	system("pause");
    }

## 38、同时显示两个文件的内容 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define PAGELINE 20
    #define PAGESPLINE 2
    #define TXTWIDTH 30
    #define TXTGAP 10
    
    void linecount()/*完成对输出行的计数和一页满后，输出空行*/
    { 
    	static int pline = 0;
    	int i;
    
    	if (++pline == PAGELINE)
    	{ 
    		for (i = 0; i<PAGESPLINE; i++)/*输出一页后的空行*/
    			printf("\n");
    		pline = 0;
    	}
    }
    
    int readline(FILE *fpt)/*完成从指定的文件中读出一行多至30个字符并输出*/
    { 
    	int c, cpos = 0;
    
    	while ((c = fgetc(fpt)) != '\n')
    	{ 
    		if (feof(fpt))
    			break;/*文件结束推出循环*/
    		printf("%c", c);
    		cpos++;
    		if (cpos >= TXTWIDTH)
    			break;
    	}
    	return cpos;/*返回读入并输出的字符数*/
    }
    
    void main()
    { 
    	FILE *fpt1, *fpt2;
    	char fname1[20], fname2[20];			/*存贮文件名*/
    	int fill1, fill2;			/*分别记录两个文件当前行读入并输出的字符数*/
    
    	printf("Enter file 1 name：");
    	scanf("%s", fname1);
    	fpt1 = fopen(fname1, "r");	/*打开文件1*/
    	if (fpt1 == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname1);
    		exit(1);
    	}
    
    	printf("Enter file 2 name：");
    	fpt2 = fopen(fname2, "r");	/*打开文件2*/
    	if (fpt2 == NULL)
    	{ 
    		fclose(fpt1);
    		exit(2);
    	}
    
    	while (!feof(fpt1) || !feof(fpt2))	/* 在有文件还未结束时循环 */
    	{ 
    		fill1 = fill2 = 0;
    		if (!feof(fpt1)) fill1 = readline(fpt1);/* 在文件未结束时读文件 */
    		printf("%*c", TXTWIDTH - fill1 + TXTGAP, ' ');
    		if (!feof(fpt2)) fill2 = readline(fpt2);/* 在文件未结束时读文件 */
    		printf("%*c%2d\n", TXTWIDTH - fill2 + 4, ' ', fill1 + fill2);
    		linecount();					/* 调用行计数函数 */
    	}
    	system("pause");
    }

## 39、简单的文本编辑器 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    
    /* 根据命令对文件进行编辑，创建，保存，删除，退出，追加等操作 */
    
    typedef enum fileoper
    { 
    	EDIT = 'i',
    	CREAT = 'c',
    	SAVE = 's',
    	DEL = 'd',
    	APPEND = 'a',
    	QUIT = 'q'
    }fileOper;
    
    /* * @func：编辑文本，需要先打开/创建文件 */
    void edit_text(FILE *fp){ 
    	int i = 0;
    	char buf[1024] = {  0 };
    	char *content[20];
    	while (gets(buf) != NULL || buf != "\n")
    	{ 
    		if (buf == "\n") content;
    		if (buf[0] == '^') break;
    		content[i] = (char *)malloc(sizeof(char)* strlen(buf)+1);
    		strcpy(content[i], buf);
    		i++;
    	}
    	for (int j = 0; j < i; ++j){ 
    		fputs(content[j], fp);
    		free(content[j]);
    		content[j] = NULL;
    	}
    	
    	fclose(fp);
    }
    
    /** 创建文件 */
    FILE *create_file(const char *filename){ 
    	FILE *fp = fopen(filename, "w");
    	if (fp != NULL){ 
    		printf("文件创建成功...\n");
    		return fp;
    	}
    	return NULL;
    }
    
    void del_file(const char *filename){ 
    	if (remove(filename) == 0)
    		printf("%s删除成功...\n", filename);
    	else
    		printf("%s文件删除失败...\n", filename);
    }
    
    void quit_edit(FILE *fp){ 
    	if (fclose(fp) == 0)
    		printf("文件关闭成功...\n");
    
    }
    
    void append_text(const char *filename, FILE *fp){ 
    	FILE *fp_append = freopen(filename, "a+", fp);
    	fseek(fp_append, 0, SEEK_END);  // 将文件指针设置到文件末尾
    	edit_text(fp_append);
    }
    
    void main()
    { 
    	char ch;
    	char filename[20];
    	FILE *fp = NULL;
    	printf("--正在使用文件操作系统\n");
    	printf("-------i. 编辑-------\n");
    	printf("-------c. 创建-------\n");
    	printf("-------s. 保存-------\n");
    	printf("-------d. 删除-------\n");
    	printf("-------a. 追加-------\n");
    	printf("-------q. 退出-------\n");
    	while (1)
    	{ 
    		printf("--请输入文件操作命令：");
    
    		ch = getchar();
    		fflush(stdin);
    
    		switch (ch){ 
    		case EDIT:
    			if (fp == NULL){ 
    				printf("请先创建文件/打开文件在进行相应操作...");
    				break;
    			}
    			edit_text(fp);
    			break;
    		case CREAT:
    			printf("请输入创建的文件名：");
    			if (scanf("%s", filename) == 1)
    				
    				fp = create_file(filename);
    			else
    				printf("ERROR：输入有误...");
    			fflush(stdin);
    			break;
    		case APPEND:
    			printf("请输入追加的文件名：");
    			if (scanf("%s", filename) != 1){ 
    				printf("ERROR：输入有误...");
    				break;
    			}
    			if (fp == NULL){ 
    				break;
    			}
    			append_text(filename, fp);
    			fflush(stdin);
    			break;
    		case DEL:
    			printf("请输入要删除的文件名：");
    			if (scanf("%s", filename) == 1)
    				del_file(filename);
    			else
    				printf("ERROR：输入有误...");
    			break;
    		case QUIT:
    			if (fp == NULL){ 
    				printf("请先创建文件/打开文件在进行相应操作...");
    				break;
    			}
    			quit_edit(fp);
    			break;
    		default:
    			;
    		}
    	}
    
    	system("pause");
    }

## 40、文件的字数统计程序 ##

#include<stdio.h>
    #include<stdlib.h>
    /* 该程序实现统计一个或多个文件的行数、字数和字符数。 一个行由一个换行符限定，一个字由空格分隔（包括空白符、制表符和换行符）， 字符是指文件中的所有字符。要求程序另设三个任选的参数， 让用户指定他所要的统计。它们是： 1 统计文件行数 w 统计文件字数 c 统计文件字符数 若用户未指定任选的参数，则表示三个统计都要。 运行本程序时的参数按一下格式给出： -l -w -c 文件 文件 ... 文件 其中，前三个任选参数l、w、c的出现与否和出现顺序任意， 或任意组合在一起出现，如：-lwc，-cwl，-lw，-wl，-lc，-cl，－cw等。 */
    
    void main(int argc, char **argv)
    { 
    	FILE *fp;
    	int lflg, wflg, cflg; /* l, w, c三个标志 */
    	int inline_, inword; /* 行内和字内标志 */
    	int ccount, wcount, lcount; /* 字符，字，行 计数器 */
    	int c;
    	char *s;
    	lflg = wflg = cflg = 0;
    	if (argc<2)
    	{ 
    		printf("To run this program, usage: program -l -w -c file1 file2 ... filen \n");
    		exit(0);
    	}
    	while (--argc >= 1 && (*++argv)[0] == '-')
    	{ 
    		for (s = argv[0] + 1; *s != '\0'; s++)
    		{ 
    			switch (*s)
    			{ 
    			case 'l':
    				lflg = 1;
    				break;
    			case 'w':
    				wflg = 1;
    				break;
    			case 'c':
    				cflg = 1;
    				break;
    			default:
    				puts("To run this program, usage: program -l -w -c file1 file2 ... filen");
    				exit(0);
    			}
    		}
    	}
    	if (lflg == 0 && wflg == 0 && cflg == 0)
    		lflg = wflg = cflg = 1;
    	lcount = wcount = ccount = 0;
    	while (--argc >= 0)
    	{ 
    		if ((fp = fopen(*argv++, "r")) == NULL)	/* 以只读方式打开文件 */
    		{ 
    			fprintf(stderr, "Can't open %s.\n", *argv);
    			continue;
    		}
    		inword = inline_ = 0;
    		while ((c = fgetc(fp)) != EOF)
    		{ 
    			if (cflg)
    				ccount++;
    			if (wflg)
    			if (c == '\n' || c == ' ' || c == '\t')
    				inword = 0;
    			else if (inword == 0)
    			{ 
    				wcount++;
    				inword = 1;
    			}
    			if (lflg)
    			if (c == '\n')
    				inline_ = 0;
    			else if (inline_ == 0)
    			{ 
    				lcount++;
    				inline_ = 1;
    			}
    		}
    		fclose(fp);	/* 关闭文件 */
    	}
    	if (lflg)
    		printf(" Lines = %d\n", lcount);
    	if (wflg)
    		printf(" Words = %d\n", wcount);
    	if (cflg)
    		printf(" Characters = %d\n", ccount);
    }

## 41、学生成绩管理程序 ##

#define _CRT_SECURE_NO_WARNINGS
    #include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    
    /* 学生成绩管理程序 编制一个统计学生考试分数的管理程序。 设学生成绩已以一个学生一个记录的形式存储在文件中， 每位学生记录包含的信息有：姓名，学号和各门功课的成绩。 程序具有以下几项功能：求出各门课程的总分，平均分，按姓名， 按学号寻找其记录并显示，浏览全部学生成绩和按总分由高到低显示学生信息等。 */
    #define SWN 3 /* 课程数 */
    #define NAMELEN 20 /* 姓名最大字符数 */
    #define CODELEN 10 /* 学号最大字符数 */
    #define FNAMELEN 80 /* 文件名最大字符数 */
    #define BUFLEN 80 /* 缓冲区最大字符数 */
    
    /* 课程名称表 */
    char schoolwork[SWN][NAMELEN + 1] = {  "Chinese", "Mathematic", "English" };
    struct record
    { 
    	char	name[NAMELEN + 1];	/* 姓名 */
    	char 	code[CODELEN + 1];	/* 学号 */
    	int 	marks[SWN];			/* 各课程成绩 */
    	int total;					/* 总分 */
    }stu;
    
    struct node
    { 
    	char	name[NAMELEN + 1];	/* 姓名 */
    	char 	code[CODELEN + 1];	/* 学号 */
    	int 	marks[SWN];			/* 各课程成绩 */
    	int 	total;				/* 总分 */
    	struct	node *next;			/* 后续表元指针 */
    }*head;							/* 链表首指针 */
    
    int total[SWN];					/* 各课程总分 */
    FILE *stfpt;					/* 文件指针 */
    char stuf[FNAMELEN];			/* 文件名 */
    
    /** 从指定文件读入一个记录, 使用fscanf读取，一次读取一行*/
    int read_record(FILE *fpt, struct record *rpt)
    { 
    	char buf[BUFLEN];
    	int i;
    	if (fscanf(fpt, "%s", buf) != 1)	// 读取姓名 
    		return 0;						/* 文件结束 */ 
    	strncpy(rpt->name, buf, NAMELEN);	
    	fscanf(fpt, "%s", buf);				// 读取学号
    	strncpy(rpt->code, buf, CODELEN);
    	for (i = 0; i < SWN; i++)			// 读取成绩
    		fscanf(fpt, "%d", &rpt->marks[i]);
    
    	for (rpt->total = 0, i = 0; i<SWN; i++)
    		rpt->total += rpt->marks[i];
    	return 1;
    }
    
    /** 对指定文件写入一个记录 */
    void write_record(FILE *fpt, struct record *rpt)
    { 
    	int i;
    	fprintf(fpt, "%s\n", rpt->name);
    	fprintf(fpt, "%s\n", rpt->code);
    	for (i = 0; i<SWN; i++)
    		fprintf(fpt, "%d\n", rpt->marks[i]);
    	return;
    }
    
    /** 显示学生记录 */
    void displaystu(struct record *rpt)
    { 
    	int i;
    	printf("\nName : %s\n", rpt->name);
    	printf("Code : %s\n", rpt->code);
    	printf("Marks :\n");
    	for (i = 0; i<SWN; i++)
    		printf(" %-15s : %4d\n", schoolwork[i], rpt->marks[i]);
    	printf("Total : %4d\n", rpt->total);
    }
    
    /** 计算各单科总分 */
    int totalmark(char *fname)
    { 
    	FILE *fp;
    	struct record s;
    	int count, i;
    	if ((fp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		return 0;
    	}
    	// 初始化为0
    	for (i = 0; i<SWN; i++)
    		total[i] = 0;
    	count = 0;
    	// 将各科成绩相加
    	while (read_record(fp, &s) != 0)
    	{ 
    		for (i = 0; i<SWN; i++)
    			total[i] += s.marks[i];
    		count++;
    	}
    	fclose(fp);
    	return count;	/* 返回记录数 */
    }
    
    /* 列表显示学生信息 */
    void liststu(char *fname)
    { 
    	FILE *fp;
    	struct record s;
    	if ((fp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		return;
    	}
    	while (read_record(fp, &s) != 0)
    	{ 
    		displaystu(&s);
    		printf("\n Press ENTER to continue...\n");
    		while (getchar() != '\n');
    	}
    	fclose(fp);
    	return;
    }
    
    /* 构造链表 */
    struct node *makelist(char *fname)
    { 
    	FILE *fp;
    	struct record s;
    	struct node *p, *u, *v, *h;
    	int i;
    	if ((fp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		return NULL;
    	}
    	h = NULL;
    	p = (struct node *)malloc(sizeof(struct node));
    	u = (struct node *)malloc(sizeof(struct node));
    	while (read_record(fp, (struct record *)p) != 0)
    	{ 
    		v = h;
    		while (v&&p->total <= v->total)
    		{ 
    			u = v;
    			v = v->next;
    		}
    		if (v == h)
    			h = p;
    		else
    			u->next = p;
    		p->next = v;
    		p = (struct node *)malloc(sizeof(struct node));
    	}
    	free(p);
    	fclose(fp);
    	return h;
    }
    
    /* 顺序显示链表各表元 */
    void displaylist(struct node *h)
    { 
    	while (h != NULL)
    	{ 
    		displaystu((struct record *)h);
    		printf("\n Press ENTER to continue...\n");
    		while (getchar() != '\n');
    		h = h->next;
    	}
    	return;
    }
    /* 按学生姓名查找学生记录 */
    int retrievebyn(char *fname, char *key)
    { 
    	FILE *fp;
    	int c;
    	struct record s;
    	if ((fp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		return 0;
    	}
    	c = 0;
    	while (read_record(fp, &s) != 0)
    	{ 
    		if (strcmp(s.name, key) == 0)
    		{ 
    			displaystu(&s);
    			c++;
    		}
    	}
    	fclose(fp);
    	if (c == 0)
    		printf("The student %s is not in the file %s.\n", key, fname);
    	return 1;
    }
    
    /* 按学生学号查找学生记录 */
    int retrievebyc(char *fname, char *key)
    { 
    	FILE *fp;
    	int c;
    	struct record s;
    	if ((fp = fopen(fname, "r")) == NULL)
    	{ 
    		printf("Can't open file %s.\n", fname);
    		return 0;
    	}
    	c = 0;
    	while (read_record(fp, &s) != 0)
    	{ 
    		if (strcmp(s.code, key) == 0)
    		{ 
    			displaystu(&s);
    			c++;
    			break;
    		}
    	}
    	fclose(fp);
    	if (c == 0)
    		printf("The student %s is not in the file %s.\n", key, fname);
    	return 1;
    }
    
    void main()
    { 
    	int i, j, n;
    	char c;
    	char buf[BUFLEN];
    	FILE *fp;
    	struct record s;
    	printf("Please input the students marks record file's name: ");
    	scanf("%s", stuf);
    	/* 判断该学生的档案是否存在 */ 
    	if ((fp = fopen(stuf, "r")) == NULL)
    	{ 
    		printf("The file %s doesn't exit, do you want to creat it? (Y/N) ", stuf);
    		getchar();
    		c = getchar();
    		if (c == 'Y' || c == 'y')
    		{ 
    			fp = fopen(stuf, "w");
    			printf("Please input the record number you want to write to the file: ");
    			scanf("%d", &n);
    			/* 循环将学生信息录入 */
    			for (i = 0; i<n; i++)
    			{ 
    				printf("Input the student's name: ");
    				scanf("%s", &s.name);
    				printf("Input the student's code: ");
    				scanf("%s", &s.code);
    				for (j = 0; j<SWN; j++)
    				{ 
    					printf("Input the %s mark: ", schoolwork[j]);
    					scanf("%d", &s.marks[j]);
    				}
    				write_record(fp, &s);	// 写入文件
    			}
    			fclose(fp);
    		}
    	}
    	fclose(fp);
    	getchar();
    	puts("---------------------------------------------------");
    	puts("Now you can input a command to manage the records.");
    	puts("m : mean of the marks.");
    	puts("t : total of the marks.");
    	puts("n : search record by student's name.");
    	puts("c : search record by student's code.");
    	puts("l : list all the records.");
    	puts("s : sort and list the records by the total.");
    	puts("q : quit!");
    	while (1)
    	{ 
    		printf("Please enter your choice：");
    		scanf(" %c", &c);		/* 输入选择命令 */
    		if (c == 'q' || c == 'Q')
    		{ 
    			puts("\n Thank you for your using.");
    			break;		/* q，结束程序运行 */
    		}
    		switch (c)
    		{ 
    
    		/* 计算平均分 */
    		case 'm': 
    		case 'M':
    			if ((n = totalmark(stuf)) == 0)
    			{ 
    				puts("Error!");
    				break;
    			}
    			printf("\n");
    			for (i = 0; i<SWN; i++)
    				printf("%-15s's average is: %.2f.\n", schoolwork[i], (float)total[i] / n);
    			break;
    
    		/* 计算总分 */
    		case 't': 
    		case 'T':
    			if ((n = totalmark(stuf)) == 0)
    			{ 
    				puts("Error!");
    				break;
    			}
    			printf("\n");
    			for (i = 0; i<SWN; i++)
    				printf("%-15s's total mark is: %d.\n", schoolwork[i], total[i]);
    			break;
    
    		/* 按学生的姓名寻找记录 */
    		case 'n': 
    		case 'N':
    			printf("Please input the student's name you want to search: ");
    			scanf("%s", buf);
    			retrievebyn(stuf, buf);
    			break;
    
    		/* 按学生的学号寻找记录 */
    		case 'c': 
    		case 'C':
    			printf("Please input the student's code you want to search: ");
    			scanf("%s", buf);
    			retrievebyc(stuf, buf);
    			break;
    
    		/* 列出所有学生记录 */
    		case 'l':
    		case 'L':
    			liststu(stuf);
    			break;
    
    		/* 按总分从高到低排列显示 */
    		case 's':
    		case 'S':
    			if ((head = makelist(stuf)) != NULL)
    				displaylist(head);
    			break;
    		default: break;
    		}
    	}
    }

## 42、插入排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    /** 对数组R中的记录R[1..n]按递增序进行插入排序 */
    void Insert_Sort(int n)
    {  
    	int i, j;
    	for (i = 2; i <= n; i++) /* 依次插入R[2]，…，R[n] */
    		if (R[i]<R[i - 1])			// 若前面的大于后面的
    		{ 
    			R[0] = R[i];			/* 应在原有位置上 */
    			j = i - 1;				/* R[0]是哨兵，且是R[i]的副本 */
    
    			/* 从右向左在有序区R[1．．i-1]中查找R[i]的插入位置 */
    			do{ 						
    				R[j + 1] = R[j];	/* 将关键字大于R[i]的记录后移 */
    				j--;
    			} while (R[0]<R[j]);	/* 当R[i]≥R[j]时终止 */
    			R[j + 1] = R[0];		/* R[i]插入到正确的位置上 */
    		}
    }
    
    
    // R[0] 暂不存储数据，用来排序暂存数据
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Insert_Sort(n);
    	printf("\nThe sequence after insert_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 43、希尔排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    /* 采用自下向上扫描，对R做冒泡排序，将R[0]作为存储单元 */
    void Bubble_Sort(int n)
    {  
    	int i, j;		
    	int flag;								/* 交换标志 */
    
    	for (i = 1; i < n; i++){ 				/* 最多做n-1趟排序 */
    		flag = 0;							/* 本趟排序开始前，交换标志应为假 */
    		for (j = n - 1; j >= i; j--)		/* 对当前无序区R[i..n]自下向上扫描 */
    			if (R[j + 1] < R[j]){ 			/* 交换记录 */
    				R[0] = R[j + 1];			/* R[0]不是哨兵，仅做暂存单元 */
    				R[j + 1] = R[j];
    				R[j] = R[0];
    				flag = 1;					/* 发生了交换，故将交换标志置为真 */
    			}
    		if (!flag)							/* 本趟排序未发生交换，提前终止算法 */
    			return;
    	}
    }
    
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Bubble_Sort(n);
    	printf("\nThe sequence after bubble_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    
    	system("pause");
    }

## 44、冒泡排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    
    #define MAX 255
    int R[MAX];
    
    /** 调用Partition(R，low，high)时，对R[low..high]做划分 */
    int Partition(int i, int j)
    { 
    	/* 并返回基准记录的位置 */
    	int pivot = R[i];			/* 用区间的第1个记录作为基准 */
    	while (i < j){ 				/* 从区间两端交替向中间扫描，直至i=j为止 */
    		while (i < j && R[j] >= pivot) /* pivot相当于在位置i上 */
    			j--;				/* 从右向左扫描，查找第1个关键字小于pivot.key的记录R[j] */
    		if (i < j)				/* 表示找到的R[j]的关键字<pivot.key */
    			R[i++] = R[j];		/* 相当于交换R[i]和R[j]，交换后i指针加1 */
    		while (i < j && R[i] <= pivot) /* pivot相当于在位置j上*/
    			i++;				/* 从左向右扫描，查找第1个关键字大于pivot.key的记录R[i] */
    		if (i < j)				/* 表示找到了R[i]，使R[i].key>pivot.key */
    			R[j--] = R[i];		/* 相当于交换R[i]和R[j]，交换后j指针减1 */
    	} 
    	R[i] = pivot;				/* 基准记录已被最后定位*/
    	return i;
    } 
    
    /* 对R[low..high]快速排序 */
    void Quick_Sort(int low, int high)
    {  
    	int pivotpos;								/* 划分后的基准记录的位置 */
    
    	if (low < high){ 							/* 仅当区间长度大于1时才须排序 */
    		pivotpos = Partition(low, high);		/* 对R[low..high]做划分 */
    		Quick_Sort(low, pivotpos - 1);			/* 对左区间递归排序 */
    		Quick_Sort(pivotpos + 1, high);			/* 对右区间递归排序 */
    	}
    } 
    
    
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	puts("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Quick_Sort(1, n);
    	printf("\nThe sequence after quick_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 45、快速排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    /* 希尔排序中的一趟排序，d为当前增量 */
    void ShellPass(int d, int n)
    { 
    	int i, j;
    	for (i = d + 1; i <= n; i++)	/* 将R[d+1．．n]分别插入各组当前的有序区 */
    	if (R[i]<R[i - d])
    	{ 
    		R[0] = R[i]; j = i - d;		/* R[0]只是暂存单元，不是哨兵 */
    		do { 						/* 查找R[i]的插入位置 */
    			R[j + d] = R[j];		/* 后移记录 */
    			j = j - d;				/* 查找前一记录 */
    		} while (j>0 && R[0]<R[j]);
    		R[j + d] = R[0];			/* 插入R[i]到正确的位置上 */
    	}
    } 
    
    void  Shell_Sort(int n)
    { 
    	int increment = n;					/* 增量初值，不妨设n>0 */
    	do { 
    		increment = increment / 3 + 1;  /* 求下一增量 */
    		ShellPass(increment, n);		/* 一趟增量为increment的Shell插入排序 */
    	} while (increment > 1);
    } 
    
    
    void main()
    { 
    	int i, n;
    
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Shell_Sort(n);
    	printf("\nThe sequence after shell_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 46、选择排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    
    void Select_Sort(int n)
    { 
    	int i, j, k;
    	for (i = 1; i<n; i++)
    	{ /* 做第i趟排序(1≤i≤n-1) */
    		k = i;
    		for (j = i + 1; j <= n; j++)	/* 在当前无序区R[i..n]中选key最小的记录R[k] */
    		if (R[j]<R[k])
    			k = j;						/* k记下目前找到的最小关键字所在的位置 */
    		if (k != i)
    		{ 								/* 交换R[i]和R[k] */
    			R[0] = R[i]; R[i] = R[k]; R[k] = R[0]; /* R[0]作暂存单元 */
    		} 
    	} 
    } 
    
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Select_Sort(n);
    	printf("\nThe sequence after select_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 47、堆排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    void Heapify(int s, int m)
    { 
    	int j, temp;			/*对R[1..n]进行堆调整，用temp做暂存单元 */
    	temp = R[s];
    	j = 2 * s;
    	while (j <= m)
    	{ 
    		if (R[j] > R[j + 1] && j<m) j++;
    		if (temp < R[j]) break;
    		R[s] = R[j];
    		s = j;
    		j = j * 2;
    	}
    	R[s] = temp;
    } 
    
    
    /* 由一个无序的序列建成一个堆 */
    void BuildHeap(int n)
    { 
    	int i;
    	for (i = n / 2; i>0; i--)
    		Heapify(i, n);
    }
    
    /* 对R[1..n]进行堆排序，不妨用R[0]做暂存单元 */
    void Heap_Sort(int n)
    { 
    	int i;
    	BuildHeap(n);									/* 将R[1-n]建成初始堆 */
    	for (i = n; i>1; i--)
    	{ 												/* 对当前无序区R[1..i]进行堆排序，共做n-1趟。 */
    		R[0] = R[1]; R[1] = R[i]; R[i] = R[0];		/* 将堆顶和堆中最后一个记录交换 */
    		Heapify(1, i - 1);							/* 将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质 */
    	} 
    } 
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Heap_Sort(n);
    	printf("\nThe sequence after Big heap_sort is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 48、归并排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 255
    int R[MAX];
    
    /* 将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的 */
    void Merge(int low, int m, int high)
    { 
    	/* 子文件R[low..high] */
    	int i = low, j = m + 1, p = 0;		/* 置初始值 */
    	int *R1;							/* R1是局部向量，若p定义为此类型指针速度更快 */
    	R1 = (int *)malloc((high - low + 1)*sizeof(int));
    	if (!R1)							/* 申请空间失败 */
    	{ 
    		puts("Insufficient memory available!");
    		return;
    	}
    	while (i <= m&&j <= high)			/* 两子文件非空时取其小者输出到R1[p]上 */
    		R1[p++] = (R[i] <= R[j]) ? R[i++] : R[j++];
    	while (i <= m)						/* 若第1个子文件非空，则复制剩余记录到R1中 */
    		R1[p++] = R[i++];
    	while (j <= high)					/* 若第2个子文件非空，则复制剩余记录到R1中 */
    		R1[p++] = R[j++];
    	for (p = 0, i = low; i <= high; p++, i++)
    		R[i] = R1[p];					/* 归并完成后将结果复制回R[low..high] */
    } 
    
    /* 用分治法对R[low..high]进行二路归并排序 */
    void Merge_SortDC(int low, int high)
    { 
    	int mid;
    	if (low<high)	/* 区间长度大于1 */
    	{ 									
    		mid = (low + high) / 2;			/* 分解 */
    		Merge_SortDC(low, mid);			/* 递归地对R[low..mid]排序 */
    		Merge_SortDC(mid + 1, high);	/* 递归地对R[mid+1..high]排序 */
    		Merge(low, mid, high);			/* 组合，将两个有序区归并为一个有序区 */
    	}
    }
    
    
    void main()
    { 
    	int i, n;
    	printf("Please input total element number of the sequence:");
    	scanf("%d", &n);
    	if (n <= 0 || n>MAX)
    	{ 
    		printf("n must more than 0 and less than %d.\n", MAX);
    		exit(0);
    	}
    	printf("Please input the elements one by one:");
    	for (i = 1; i <= n; i++)
    		scanf("%d", &R[i]);
    	printf("The sequence you input is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	Merge_SortDC(1, n);
    	printf("\nThe sequence after merge_sortDC is:");
    	for (i = 1; i <= n; i++)
    		printf("%4d", R[i]);
    	system("pause");
    }

## 49、基数排序 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 5
    
    // 链表
    typedef struct node
    { 
    	int k;
    	struct node *next;
    } *lnode;
    
    // 输入函数
    lnode my_input(int *d)
    { 
    	lnode head, temp, terminal;	 // 头节点、临时结点、尾结点
    	char s[MAX + 1];
    	printf("Input the records ('0' to end input):");
    	scanf("%s", s);
    	head = NULL;
    	*d = 0;
    	terminal = NULL;
    	while (s[0] != '0')
    	{ 
    		temp = (lnode)malloc(sizeof(struct node));
    		if (strlen(s) > *d)
    			*d = strlen(s);
    		temp->k = atoi(s);
    		if (head == NULL)
    		{ 
    			head = temp;
    			terminal = temp;
    		}
    		else
    		{ 
    			terminal->next = temp;
    			terminal = temp;
    		}
    		scanf("%s", s);
    	}
    	terminal->next = NULL;
    
    	return head;
    }
    
    void my_output(lnode h)
    { 
    	lnode t = h;	// 将h暂存，后循环为了不然h的指向改变
    	printf("\n");
    	while (t != NULL)
    	{ 
    		printf("%d ", t->k);
    		t = t->next;
    	}
    }
    
    /* 排序函数 */
    lnode Radix_Sort(lnode head, int d)
    { 
    	lnode p, q, h, t;
    	int i, j, x, radix = 1;
    
    	h = (lnode)malloc(10 * sizeof(struct node));
    	t = (lnode)malloc(10 * sizeof(struct node));
    
    	for (i = d; i >= 1; i--)
    	{ 
    		for (j = 0; j <= 9; j++)
    		{ 
    			h[j].next = NULL;
    			t[j].next = NULL;
    		}
    		p = head;
    		while (p != NULL)
    		{ 
    			x = ((p->k) / radix) % 10;
    			if (h[x].next == NULL)
    			{ 
    				h[x].next = p;
    				t[x].next = p;
    			}
    			else
    			{ 
    				q = t[x].next;
    				q->next = p;
    				t[x].next = p;
    			}
    			p = p->next;
    		}
    
    		j = 0;
    		while (h[j].next == NULL)
    			j++;
    		head = h[j].next;
    		q = t[j].next;
    		for (x = j + 1; x <= 9; x++)
    		if (h[x].next != NULL)
    		{ 
    			q->next = h[x].next;
    			q = t[x].next;
    		}
    		q->next = NULL;
    		radix *= 10;
    		printf("\n---------------------\n");
    	}
    	return head;
    }
    
    /* 释放空间 */
    void my_free(lnode h)
    { 
    	lnode temp = h;
    	while (temp)
    	{ 
    		h = temp->next;
    		free(temp);
    		temp = h;
    	}
    }
    
    void main()
    { 
    	lnode h;
    	int d;
    	h = my_input(&d);
    	puts("The sequence you input is:");
    	my_output(h);
    	h = Radix_Sort(h, d);
    	puts("\nThe sequence after radix_sort is:");
    	my_output(h);
    	my_free(h);
    	system("pause");
    }

## 50、二叉树操作 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    /* 节点 */
    struct node { 
    	int				value;
    	struct node* 	left;
    	struct node* 	right;
    };
    
    typedef struct node  NODE;
    typedef struct node* PNODE;
    
    /* 创建新节点 */
    void new_node(PNODE* n, int value) { 
    
    	*n = (PNODE)malloc(sizeof(NODE));
    	if (*n != NULL) { 
    		(*n)->value = value;
    		(*n)->left = NULL;
    		(*n)->right = NULL;
    	}
    }
    
    /* 释放空间 */
    void free_node(PNODE* n) { 
    	if ((*n) != NULL) { 
    		free(*n);
    		*n = NULL;
    	}
    }
    
    /* 释放树 */
    void free_tree(PNODE* n) { 
    	if (*n == NULL) return;
    	if ((*n)->left != NULL) { 
    		free_tree(&((*n)->left));
    	}
    	if ((*n)->right != NULL) { 
    		free_tree(&((*n)->right));
    	}
    	free_node(n);
    }
    /* 查找结点 */
    PNODE find_node(PNODE n, int value) { 
    	if (n == NULL) { 
    		return NULL;
    	}
    	else if (n->value == value) { 
    		return n;
    	}
    	else if (value <= n->value) { 
    		return find_node(n->left, value);
    	}
    	else { 
    		return find_node(n->right, value);
    	}
    }
    /* 插入结点 */
    void insert_node(PNODE* n, int value) { 
    	if (*n == NULL) { 
    		new_node(n, value);
    	}
    	else if (value == (*n)->value) { 
    		return;
    	}
    	else if (value < (*n)->value) { 
    		insert_node(&((*n)->left), value);
    	}
    	else { 
    		insert_node(&((*n)->right), value);
    	}
    }
    /* 最长路径 */
    int get_max_depth(PNODE n) { 
    	int left = 0;
    	int right = 0;
    	if (n == NULL) { 
    		return 0;
    	}
    	if (n->left != NULL) { 
    		left = 1 + get_max_depth(n->left);
    	}
    	if (n->right != NULL) { 
    		right = 1 + get_max_depth(n->right);
    	}
    	return (left > right ? left : right);
    }
    /* 最短路径 */
    int get_min_depth(PNODE n) { 
    	int left = 0;
    	int right = 0;
    	if (n == NULL) { 
    		return 0;
    	}
    	if (n->left != NULL) { 
    		left = 1 + get_min_depth(n->left);
    	}
    	if (n->right != NULL) { 
    		right = 1 + get_min_depth(n->right);
    	}
    	return (left < right ? left : right);
    }
    
    /* 获取节点数目 */
    int get_num_nodes(PNODE n) { 
    	int left = 0;
    	int right = 0;
    	if (n == NULL) { 
    		return 0;
    	}
    	if (n->left != NULL) { 
    		left = get_num_nodes(n->left);
    	}
    	if (n->right != NULL) { 
    		right = get_num_nodes(n->right);
    	}
    	return (left + 1 + right);
    }
    /* 最短路径长度 */
    int get_min_value(PNODE n) { 
    	if (n == NULL) return 0;
    	if (n->left == NULL) { 
    		return n->value;
    	}
    	else { 
    		return get_min_value(n->left);
    	}
    }
    /* 最长路径长度 */
    int get_max_value(PNODE n) { 
    	if (n == NULL) return 0;
    	if (n->right == NULL) { 
    		return n->value;
    	}
    	else { 
    		return get_max_value(n->right);
    	}
    }
    /* 删除结点 */
    void deletenode(PNODE *n) { 
    	PNODE tmp = NULL;
    	if (n == NULL) return;
    	if ((*n)->right == NULL) { 
    		tmp = *n;
    		*n = (*n)->left;
    		free_node(n);
    	}
    	else if ((*n)->left == NULL) { 
    		tmp = *n;
    		*n = (*n)->right;
    		free_node(n);
    	}
    	else { 
    		for (tmp = (*n)->right; tmp->left != NULL; tmp = tmp->left);
    		tmp->left = (*n)->left;
    		tmp = (*n);
    		*n = (*n)->right;
    		free_node(&tmp);
    	}
    }
    
    /* 根据值删除节点 */
    void delete_node(PNODE *n, int value) { 
    	PNODE node;
    	if (n == NULL) return;
    	node = find_node(*n, value);
    	if ((*n)->value == value) { 
    		deletenode(n);
    	}
    	else if (value < (*n)->value) { 
    		delete_node(&((*n)->left), value);
    	}
    	else { 
    		delete_node(&((*n)->right), value);
    	}
    }
    
    /* 前序遍历 */
    void pre_order_traversal(PNODE n)
    { 
    	if (n != NULL) { 
    		printf("%i ", n->value);
    		pre_order_traversal(n->left);
    		pre_order_traversal(n->right);
    	}
    }
    
    /* 中序遍历 */
    void in_order_traversal(PNODE n)
    { 
    	if (n != NULL) { 
    		in_order_traversal(n->left);
    		printf("%i ", n->value);
    		in_order_traversal(n->right);
    	}
    }
    
    /* 后序遍历 */
    void post_order_traversal(PNODE n)
    { 
    	if (n != NULL) { 
    		post_order_traversal(n->left);
    		post_order_traversal(n->right);
    		printf("%i ", n->value);
    	}
    }
    
    int main() { 
    	char buf[50];
    	int  option;
    	PNODE tree = NULL;
    	PNODE node = NULL;
    	while (1) { 
    		printf("--------------------------\n");
    		printf("Options are:\n\n");
    		printf(" 0 Exit\n");
    		printf(" 1 Insert node\n");
    		printf(" 2 Delete node\n");
    		printf(" 3 Find node\n");
    		printf(" 4 Pre order traversal\n");
    		printf(" 5 In order traversal\n");
    		printf(" 6 Post order traversal\n");
    		printf(" 7 Max depth\n");
    		printf(" 8 Min depth\n");
    		printf(" 9 Max value\n");
    		printf(" 10 Min value\n");
    		printf(" 11 Node Count\n\n");
    		printf("--------------------------\n");
    		printf("Select an option: ");
    		fgets(buf, sizeof(buf), stdin);
    		sscanf(buf, "%i", &option);
    		printf("--------------------------\n");
    		if (option < 0 || option > 11) { 
    			fprintf(stderr, "Invalid option");
    			continue;
    		}
    		switch (option) { 
    		case 0:
    			exit(0);
    		case 1:
    			printf("Enter number to insert: ");
    			fgets(buf, sizeof(buf), stdin);
    			sscanf(buf, "%i", &option);
    			printf("\n\n");
    			insert_node(&tree, option);
    			break;
    		case 2:
    			printf("Enter number to delete: ");
    			fgets(buf, sizeof(buf), stdin);
    			sscanf(buf, "%i", &option);
    			printf("\n\n");
    			delete_node(&tree, option);
    			break;
    		case 3:
    			printf("Enter number to find: ");
    			fgets(buf, sizeof(buf), stdin);
    			sscanf(buf, "%i", &option);
    			printf("\n\n");
    			node = find_node(tree, option);
    			if (node != NULL) { 
    				printf("Found node\n\n");
    			}
    			else { 
    				printf("Couldn't find node\n\n");
    			}
    			break;
    		case 4:
    			printf("Pre order traversal: ");
    			pre_order_traversal(tree);
    			printf("\n\n");
    			break;
    		case 5:
    			printf("In order traversal: ");
    			in_order_traversal(tree);
    			printf("\n\n");
    			break;
    		case 6:
    			printf("Post order traversal: ");
    			post_order_traversal(tree);
    			printf("\n\n");
    			break;
    		case 7:
    			printf("Max depth is %i\n\n", get_max_depth(tree));
    			break;
    		case 8:
    			printf("Min depth is %i\n\n", get_min_depth(tree));
    			break;
    		case 9:
    			printf("Max value is %i\n\n", get_max_value(tree));
    			break;
    		case 10:
    			printf("Min value is %i\n\n", get_min_value(tree));
    			break;
    		case 11:
    			printf("Node Count is %i\n\n", get_num_nodes(tree));
    			break;
    		}
    	}
    	return 0;
    }

## 51、二项式系数递归 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    int binom(int n, int i);
    void main(void)
    { 
    	int int1;
    	int int2;
    	//打印两项式
    	printf("NOTE: Entering a figure other than a number will \ncause the program to crash.");
    	printf("Formula computation is in B(n,i) N, 1st integer >= 2nd, I, Integer.\n");
    	printf("n!\n");
    	printf("B(n,i)= ----------\n");
    	printf("k!(n-i)!\n");
    	printf("Warning: Program has no error checking!\n");
    	printf("Enter an integer :");
    	scanf("%d", &int1);
    	printf("Enter a second integer :");
    	scanf("%d", &int2);
    	printf("Binomial Coefficiant : %d", binom(int1, int2));
    
    	system("pause");
    }
    //算法计算
    int binom(int n, int i)
    { 
    	int n1;
    	int n2;
    	if ((i == 0) || (n == i))
    	{ 
    		return 1;
    	}
    	else
    	{ 
    		n1 = binom(n - 1, i);
    		n2 = binom(n - 1, i - 1);
    		return n1 + n2;
    	}
    }

## 52、背包问题 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 100
    
    struct Bag
    { 
    	int weight;
    	int value;
    }Bag[MAX];
    
    int a[MAX];
    int Value = 0;
    int Weight;
    
    int comb(int m, int k)
    { 
    	int i, j;
    	int wei, val;
    	for (i = m; i >= k; i--)
    	{ 
    		a[k] = i;
    		if (k>1)
    			comb(i - 1, k - 1);
    		else
    		{ 
    			wei = 0;							/* 预值0 */
    			val = 0;
    			for (j = a[0]; j>0; j--)            /* 每一种组合求它们的重量和价值 */
    			{ 
    				wei = wei + Bag[a[j]].weight;
    				val = val + Bag[a[j]].value;
    			}
    			if (wei <= Weight && val>Value)		/* 判断是否满足条件进行附值 */
    				Value = val;
    		}
    	}
    	return Value;
    }
    void main()
    { 
    	int num, subnum;
    	int l;
    
    	printf("输入背包的总个数:");								/* 输入背包的总个数 */
    	scanf("%d", &num);
    	printf("输入背包的重量和价值", num);						/* 输入背包的重量和价值 */
    	for (l = 1; l <= num; l++)
    		scanf("%d,%d", &Bag[l].weight, &Bag[l].value);
    	printf("输入满足要求背包的个数:");						/* 输入要求背包的个数 */
    	scanf("%d", &subnum);
    	printf("输入满足条件的重量:", subnum);					/* 输入满足条件的重量*/
    	scanf("%d", &Weight);
    	a[0] = subnum;
    	printf("the max value is:%d", comb(num, subnum));
    	system("pause");
    }

## 53、顺序表插入和删除 ##

#define ListSize 100/* 假定表空间大小为100 */
    #include <stdio.h>
    #include <stdlib.h>
    
    /* 从0开始计， 表空间大小应为101了 */
    void Error(char * message)
    { 
    	printf("错误:%s\n", message);
    	exit(1);
    }
    struct Seqlist{ 
    	int  data[ListSize];	/* 向量data用于存放表结点 */
    	int length;				/* 当前的表长度 */
    };
    
    
    /** * @func：将新结点x插入L所指的顺序表的第i个结点ai的位置上 * @param x：新结点 * @param i：插入的位置 */
    void InsertList(struct Seqlist *L, int x, int i)
    { 
    	
    	int j;
    	if (i < 0 || i > L->length)
    		Error("position error");/* 非法位置，退出 */
    	if (L->length >= ListSize)
    		Error("overflow");
    	for (j = L->length - 1; j >= i; j--)
    		L->data[j + 1] = L->data[j];
    	L->data[i] = x;
    	L->length++;
    }
    
    /** * @func从L所指的顺序表中删除第i个结点ai * @param i：删除的位置 */
    void DeleteList(struct Seqlist *L, int i)
    { 
    	int j;
    	if (i< 0 || i > L->length - 1)
    		Error(" position error");
    	for (j = i + 1; j < L->length; j++)
    		L->data[j - 1] = L->data[j]; /* 结点前移 */
    	L->length--; /* 表长减小 */
    }
    
    /** 初始化链表 */
    void Initlist(struct Seqlist *L)
    { 
    	L->length = 0;
    }
    
    void main()
    { 
    	/* 创建并初始化链表 */
    	struct Seqlist *SEQA;
    	int i;
    	SEQA = (struct Seqlist *)malloc(sizeof(struct Seqlist));
    	Initlist(SEQA);
    
    	/* 插入数据 */ 
    	for (i = 0; i<ListSize; i++)
    	{ 
    		InsertList(SEQA, i, i);
    		printf("%d\n", SEQA->data[i]);
    	}
    	/* 删除数据 */
    	DeleteList(SEQA, 99);
    
    	/* 打印数据 */
    	for (i = 0; i<ListSize - 1; i++)
    	{ 
    		printf("%d\n", SEQA->data[i]);
    	}
    }

## 54、链表操作（1） ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define N 10
    
    
    /** 链表结构 */
    typedef struct node
    { 
    	char name[20];
    	struct node *link;
    }stud;
    
    /* 创建链表 */
    stud * creat_link()
    { 
    	stud *p, *head, *s;
    	int i, n;
    	printf("Please input the number of linklist:");
    	scanf("%d", &n);
    	/* 创建头结点 */
    	if ((head = (stud *)malloc(sizeof(stud))) == NULL)
    	{ 
    		printf("cannot find space!");
    		exit(0);
    	}
    	head->name[0] = '\0';
    	head->link = NULL;
    	p = head;
    
    	/* 循环创建多个结点 */
    	for (i = 0; i<n; i++)
    	{ 
    		if ((s = (stud *)malloc(sizeof(stud))) == NULL)
    		{ 
    			printf("cannot find space!");
    			exit(0);
    		}
    		p->link = s;
    		printf("please input %d student's name: ", i + 1);
    		scanf("%s", s->name);
    		s->link = NULL;
    		p = s;
    	}
    
    	return head;
    }
    
    /** 查找相应的值 */
    stud * search(stud *h, char *x)
    { 
    	stud *p;
    	char *y;
    	p = h->link;
    	while (p != NULL)
    	{ 
    		y = p->name;
    		if (strcmp(y, x) == 0)
    			return(p);
    		else p = p->link;
    	}
    	if (p == NULL)
    		printf("data not find!");
    	return 0;
    }
    
    
    stud * search2(stud *h, char *x)
    { 
    	stud *p, *s;
    	char *y;
    	p = h->link;
    	s = h;
    	while (p != NULL)
    	{ 
    		y = p->name;
    		if (strcmp(y, x) == 0)
    			return(s);
    		else
    		{ 
    			p = p->link;
    			s = s->link;
    		}
    	}
    	if (p == NULL)
    		printf("data not find!");
    	return 0;
    }
    
    
    /* 插入数据 */
    void insert_node(stud *p)
    { 
    	char stuname[20];
    	stud *s;
    	if ((s = (stud *)malloc(sizeof(stud))) == NULL)
    	{ 
    		printf("cannot find space!");
    		exit(0);
    	}
    	printf("please input the student's name: ");
    	scanf("%s", stuname);
    	strcpy(s->name, stuname);
    	s->link = p->link;
    	p->link = s;
    }
    
    /** 删除数据 */
    void del_node(stud *x, stud *y)
    { 
    	stud *s;
    	s = y;
    	x->link = y->link;
    	free(s);
    }
    
    /* 打印数据 */
    void my_print(stud *h)
    { 
    	stud *p;
    	p = h->link;
    	printf("Now the link list is:\n");
    	while (p != NULL)
    	{ 
    		printf("%s ", &*(p->name));
    		p = p->link;
    	}
    	printf("\n");
    }
    
    /** 退出函数 */
    void quit()
    { 
    	puts("\n Thank you for your using!\n Press any key to quit...");
    	exit(0);
    }
    
    /** 菜单 */
    void menu(void)
    { 
    	printf(" simple linklise realization of c\n");
    	printf(" ||=====================================||\n");
    	printf(" || ||\n");
    	printf(" || [1] create linklist ||\n");
    	printf(" || [2] seach ||\n");
    	printf(" || [3] insert ||\n");
    	printf(" || [4] delete ||\n");
    	printf(" || [5] print ||\n");
    	printf(" || [6] exit ||\n");
    	printf(" || ||\n");
    	printf(" || if no list exist,create first ||\n");
    	printf(" || ||\n");
    	printf(" ||=====================================||\n");
    	printf(" Please input your choose(1-6): ");
    }
    
    void main()
    { 
    	int choose;
    	stud *head, *searchpoint, *forepoint;
    	char fullname[20];
    
    
    	while (1)
    	{ 
    		menu();
    		scanf("%d", &choose);
    		switch (choose)
    		{ 
    		case 1:
    			head = creat_link();
    			puts("Linklist created successfully! \nPress any key to return...");
    			getchar();
    			break;
    		case 2:
    			printf("Input the student's name which you want to find:\n");
    			scanf("%s", fullname);
    			searchpoint = search(head, fullname);
    			printf("The stud name you want to find is:%s", *&searchpoint->name);
    			getchar();
    			getchar();
    			break;
    		case 3:
    			insert_node(head);
    			my_print(head);
    			getchar(); getchar();
    			break;
    		case 4:
    			my_print(head);
    			printf("\nInput the student's name which you want to delete:\n");
    			scanf("%s", fullname);
    			searchpoint = search(head, fullname);
    			forepoint = search2(head, fullname);
    			del_node(forepoint, searchpoint);
    			my_print(head);
    			puts("\nDelete successfully! Press any key to return...");
    			getchar();
    			getchar();
    			break;
    		case 5:my_print(head);
    			getchar(); getchar();
    			break;
    		case 6:quit();
    			break;
    		default:
    			printf("Illegal letter! Press any key to return...");
    			menu();
    			getchar();
    		}
    	}
    }

## 55、链表操作（2） ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define List_INIT_SIZE 100 //线性表的存储空间初始大小
    #define LIST_INCREMENT 10 //分配增量
    #define OVERFLOW -2
    #define OK 1
    #define ERROR -1
    #define TRUE 1
    #define FALSE 0
    typedef int  ElemType;
    
    
    typedef struct{ 
    	ElemType *elem;  //存储空间基址
    	int   length;    //当前长度
    	int   size;      //当前存储容量(sizeof(ElemType)为单位)
    }SqList;
    
    /** 初始化链表 */
    int InitList(SqList &L)
    { 
    	//构建一个线性表L
    	L.elem = (ElemType*)malloc(List_INIT_SIZE*sizeof(ElemType));
    	if (!L.elem)
    	{ 
    		exit(OVERFLOW);
    	}
    	L.length = 0;				// 长度初始化为0
    	L.size = List_INIT_SIZE;	// 初始化容量
    	return OK;
    }
    
    /** 销毁链表 */
    void DestoryList(SqList &L)
    { 
    	if (!L.elem)
    	{ 
    		delete L.elem;		// 释放空间
    		L.elem = NULL;
    	}
    	L.length = 0;			// 长度及容量置为0
    	L.size = 0;
    }
    
    /** 清空链表 */
    void ClearList(SqList &L)
    { 
    	L.elem = NULL;	
    	L.length = 0;
    	L.size = List_INIT_SIZE;
    }
    
    /* 判断链表是否为空 */
    int isEmpty(SqList L)
    { 
    	if (L.length > 0)
    	{ 
    		return TRUE;
    	}
    	else
    	{ 
    		return FALSE;
    	}
    }
    
    /** 获取链表长度 */
    int ListLength(SqList L)
    { 
    	return L.length;
    }
    
    /** 插入数据 */
    int ListInsert(SqList &L, int i, ElemType e)
    { 
    	if (i<1 || i>ListLength(L) + 1)		// 需满足条件1<i<ListLength(L)+1
    	{ 
    		return ERROR;
    	}
    	ElemType * NewBase;					// 新的基址
    	if (L.length > L.size)				//空间已满
    	{ 
    		NewBase = (ElemType*)malloc((L.size + LIST_INCREMENT)*sizeof(ElemType));  //申请新的空间
    		if (!NewBase)
    		{ 
    			exit(OVERFLOW);
    		}
    		L.elem = NewBase;				// 将新的数据存入
    		L.size += LIST_INCREMENT;		// 增加一倍的容量
    		delete NewBase;
    		NewBase = NULL;
    	}
    	ElemType *p;
    	ElemType *temp;
    	p = &(L.elem[i - 1]);				//取得i的位置，即插入位置
    	for (temp = &(L.elem[L.length - 1]); temp>p; --temp)  //将插入点后的所有元素向后移动一位
    	{ 
    		*(temp + 1) = *temp;
    	}
    	*p = e;
    	++L.length;
    	return OK;
    }
    
    /* 根据数值删除 */
    int ListDelete(SqList &L, int i, ElemType &e)
    { 
    	if (i<0 || i>ListLength(L)) { 
    		return ERROR;
    	}
    	ElemType *p;
    	p = &(L.elem[i - 1]);
    	e = *p;
    	ElemType *pos;
    	pos = &(L.elem[L.length - 1]);
    	for (++p; p <= pos; ++p){ 
    		*(p - 1) = *p;
    	}
    	--L.length;
    	return OK;
    }
    
    
    void main(){ 
    	SqList list;
    	ElemType e;
    	InitList(list);			// 初始化
    	ListInsert(list, 1, 1);
    	ListInsert(list, 2, 2);
    	ListInsert(list, 3, 3);
    	ListInsert(list, 4, 4);
    	ListInsert(list, 5, 5);	// 插入数据
    	for (int i = 0; i<list.length; i++){ 
    		printf("%d\n", list.elem[i]);
    	}
    
    	ListDelete(list, 2, e);
    	for (int i = 0; i<list.length; i++){ 
    		printf("%d\n", list.elem[i]);
    	}	printf("%d\n", list.length);
    
    	system("pause");
    }

## 56、单链表就地逆置 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    #define NULL 0 /* 宏定义 */
    
    /** 定义结点类型的数据结构 */
    typedef struct node 
    { 
    	char c;				/* 数据域，类型为字符型 */
    	struct node *next;	/* 指针域，类型为本结构体类型 */
    }Node, *L;				/* 类型重定义，即Node和*L和struct node等价 */
    
    void main()
    { 
    	L l, p, q, r;					/*用 指针类型定义三个结点类型的指针 */
    	char ch;
    	l = (L)malloc(sizeof(Node));	/* 分配内存空间 */
    	l->c = '\0';					/* 为头结点的数据域赋值，值为空 */
    	l->next = NULL;					/* 指明下一个结点目前不存在 */
    	q = l;							/* q为游动指针，链表结点的连结要用 */
    	printf("Input a character:\n");
    	scanf("%c", &ch);
    	getchar();
    	while (ch != '0')				/* 输入0表示输入结束 */
    	{ 
    		p = (L)malloc(sizeof(Node));	/* 为新输入的数据分配内存空间 */
    		p->c = ch;
    		p->next = NULL;					/* 新输入的结点在链表的最后，即它的后面没有其它元素 */
    		q->next = p;					/* q用于将上一个元素链接至当前新元素 */
    		q = p;							/* q自己移到当前最后一个元素，以备继续链接所用 */
    		scanf("%c", &ch);
    		getchar();
    	}
    
    	/*以上完成了单链表的创建*/
    	q = l->next;
    	p = q->next;
    	r = p->next;
    	q->next = NULL;
    	while (r != NULL)
    	{ 
    		p->next = q;
    		q = p;
    		p = r;
    		if (r->next != NULL)			/* r后面还有结点，则逆置继续 */
    			r = r->next;
    		else
    			break;
    	}
    	r->next = q;
    	l->next = r;					// 头结点指向最后一个结点
    
    	q = l;							/* 输入整个链表前，先将q移到链表头，l一般不动 */
    	while (q->next != NULL)			/* 若q所指向的元素后面还有其它元素，则将该元素的数据输出 */
    	{ 
    		printf("%c-->", q->next->c); /* q->next->c表示q所指向的下一个元素的数据 */
    		q = q->next;				 /* 完成该元素的输出后，q移至下一个元素重复输出操作 */
    	}
    	printf("\n");
    	system("pause");
    }

## 57、运动会分数统计 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    #define n 4
    #define m 3
    #define w 2
    
    // 定义表示成绩的结构体
    struct achievement  
    { 
    	int schoolnumber;	//学校编号
    	char name[20];		//姓名
    	int mark;			//分数
    	int result;
    };
    
    // 表示项目的结构体
    struct pro     
    { 
    	int tag;			//项目编号
    	struct achievement ach[5];
    	int number;
    };
    
    struct Node
    { 
    	struct pro date;
    	struct Node *next;
    };
    
    /** 初始化单链表 */
    void ListInitiate(struct Node * *head)    
    { 
    	if ((*head = (struct Node*)malloc(sizeof(struct Node))) == NULL) exit(1);
    	(*head)->next = NULL;
    }
    
    void main()
    { 
    	int i, j, t;
    	int x[n] = {  0 }; int y[n] = {  0 };
    	struct Node *head;
    	struct Node *p;
    	struct Node *q;
    	ListInitiate(&head);
    	p = head;
    
    	/** 输入成绩 */
    	for (i = 0; i<m + w; i++)      
    	{ 
    		j = i + 1;
    		printf("请输入第%d个项目的信息\n", j);
    		p->date.number = j;
    		printf("所取的名次数为:");
    		scanf("%d", &p->date.tag);
    		while (p->date.tag != 3 && p->date.tag != 5)
    		{ 
    			printf("输入有误，请重新输入!");
    			printf("所取的名次数为:");
    			scanf("%d", &p->date.tag);
    		}
    		t = 1;
    		while (t <= p->date.tag)
    		{ 
    			printf("第%d名的名字:", t);
    			scanf("%s", &p->date.ach[t - 1].name);
    			printf("第%d名的学校:", t);
    			scanf("%d", &p->date.ach[t - 1].schoolnumber);
    			printf("第%d名的分数:", t);
    			scanf("%d", &p->date.ach[t - 1].mark);
    			p->date.ach[t - 1].result = t;
    			t++;
    		}
    		q = (struct Node*)malloc(sizeof(struct Node));  //生成新结点
    		p->next = q;
    		p = q;
    		p->next = NULL;
    	}
    
    	/** 产生成绩单 */
    	for (i = 0; i<n; i++)     
    	{ 
    		j = i + 1;
    		printf("学校%d成绩单\n", j);
    		p = head;
    		do
    		{ 
    			t = 1;
    			while (t <= p->date.tag)
    			{ 
    				if (p->date.ach[t - 1].schoolnumber == j)
    				{ 
    					printf("获奖项目:%d ", p->date.number);
    					printf("名次:%d \n", p->date.ach[t - 1].result);
    					printf("获奖人姓名:%s ", p->date.ach[t - 1].name);
    					printf("所得分数:%d ", p->date.ach[t - 1].mark);
    					if (p->date.number <= m)
    						x[i] = x[i] + p->date.ach[t - 1].mark;
    					else
    						y[i] = y[i] + p->date.ach[t - 1].mark;
    				}
    				t++;
    			}
    			p = p->next;
    		} while (p != NULL);
    		printf("\n男子团体总分:%d ", x[i]);
    		printf("女子团体总分:%d \n", y[i]);
    		printf("\n团体总分:%d\n", x[i] + y[i]);
    	}
    }

## 58、双链表 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    #define N 10
    
    /** 双链表的结构定义 */
    typedef struct node
    { 
    	char name[20];
    	struct node *llink, *rlink;
    }stud;
    
    /** 双链表的创建 */
    stud * creat(int n)
    { 
    	stud *p, *h, *s;
    	int i;
    	/* 创建头结点 */
    	if ((h = (stud *)malloc(sizeof(stud))) == NULL)
    	{ 
    		printf("cannot find space!\n");
    		exit(0);
    	}
    	h->name[0] = '\0';
    	h->llink = NULL;
    	h->rlink = NULL;
    	p = h;
    
    	/* 循环插入数据 */
    	for (i = 0; i<n; i++)
    	{ 
    		if ((s = (stud *)malloc(sizeof(stud))) == NULL)
    		{ 
    			printf("cannot find space!\n");
    			exit(0);
    		}
    		p->rlink = s;
    		printf("Please input the %d man's name: ", i + 1);
    		scanf("%s", s->name);
    		s->llink = p;
    		s->rlink = NULL;
    		p = s;
    		h->llink = s;
    	}
    	p->rlink = h;
    
    	return h;
    }
    
    /** 根据数值查找 */
    stud * search(stud *h, char *x)
    { 
    	stud *p;
    	char *y;
    	p = h->rlink;
    	while (p != h)
    	{ 
    		y = p->name;
    		if (strcmp(y, x) == 0)
    			return(p);
    		else p = p->rlink;
    	}
    	printf("cannot find data!\n");
    
    	return NULL;
    }
    
    /** 打印输出 */
    void print(stud *h)
    { 
    	stud *p;
    	p = h->rlink;
    	printf("\nNow the double list is:\n");
    	while (p != h)
    	{ 
    		printf("%s ", &*(p->name));
    		p = p->rlink;
    	}
    	printf("\n");
    }
    
    /*删除*/
    void del(stud *p)
    { 
    	(p->rlink)->llink = p->llink;
    	(p->llink)->rlink = p->rlink;
    	free(p);
    }
    
    /*主函数*/
    void main()
    { 
    	int number;
    	char studname[20];
    	stud *head, *searchpoint;
    	number = N;
    	printf("Please input the size of the list:");
    	scanf("%d", &number);
    	head = creat(number);
    	print(head);
    	printf("\nPlease input the name which you want to find:");
    	scanf("%s", studname);
    	searchpoint = search(head, studname);
    	printf("the name you want to find is:%s\n", *&searchpoint->name);
    	del(searchpoint);
    	print(head);
    	system("pause");
    }

## 59、约瑟夫环 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define N 7 //定义N=7，表示有7个链表单元
    #define OVERFLOW 0
    #define OK 1
    
    /** 定义链表结构 */
    typedef struct LNode{                              
    	int password;
    	int order;
    	struct LNode *next;
    }LNode, *LinkList;
    
    int  PassW[N] = {  3, 1, 7, 2, 4, 8, 4 };
    void  Joseph(LinkList p, int m, int x);          //声明函数
    
    int main()
    { 
    	int  i, m;
    	LinkList  Lhead, p, q;						//定义三个指向链表结构的指针
    	Lhead = (LinkList)malloc(sizeof(LNode));	//初始化头节点
    	if (!Lhead)return OVERFLOW;                 //分配空间失败返回
    	Lhead->password = PassW[0];
    	Lhead->order = 1;
    	Lhead->next = NULL;
    	p = Lhead;
    
    	/* 初始化循环列表中的密码值 */
    	for (i = 1; i<7; i++){ 
    		if (!(q = (LinkList)malloc(sizeof(LNode))))return OVERFLOW;
    		q->password = PassW[i];                      
    		q->order = i + 1;
    		p->next = q; p = q;							 //新创建一个指针节点并使p->next指向它,再使p=q
    	}
    	p->next = Lhead;								 //使p->next指向头节点,从而形成循环链表
    	printf("请输入第一次计数值m: ");
    	scanf("%d", &m);                                 //用户输入第一次计数值m
    	printf("第一次计数值m= %d \n", m);
    	Joseph(p, m, N);
    	return OK;
    }
    
    
    void  Joseph(LinkList p, int m, int x){ 
    	LinkList q;
    	int i;
    	if (x == 0) return;                         // 链表中没有节点的话,立即返回上一层函数
    	q = p;
    	m %= x;										// m对x求余,从而求出链表中的第几个单元是所求节点
    	if (m == 0)m = x;							// 若m刚好可以整除x,则令m=x,因为如果m=0,则不进行下一个
    	// for循环,那样就无法使q指向要删除节点,p指向他的的前一节点,那样则无法进行删除操作 
    	for (i = 1; i <= m; i++){ 
    		p = q;
    		q = p->next;							// 使q指向要删除的节点,p指向q的前一个节点
    	}
    	p->next = q->next;                          // 从循环链表中删除q指向的节点
    	i = q->password;
    	printf("%d ", q->order);
    	free(q);                                    // 释放q指向的空间
    	Joseph(p, i, x - 1);
    }

## 60、记录家庭资料 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    #include <ctype.h>
    
    /** 函数声明 */
    struct Family *get_person(void);   
    char related(struct Family *pmember1, struct Family *pmember2);
    char set_ancestry(struct Family *pmember1, struct Family *pmember2);
    
    /* 日期结构 */
    struct Date
    { 
    	int day;
    	int month;
    	int year;
    };
    
    /** 家族结构 */
    struct Family                      
    { 
    	struct Date dob;
    	char name[20];
    	char father[20];
    	char mother[20];
    	struct Family *next;            /* Pointer to next structure */
    	struct Family *previous;        /* Pointer to previous structure */
    	struct Family *p_to_pa;         /* Pointer to father structure */
    	struct Family *p_to_ma;         /* Pointer to mother structure */
    };
    
    void main()
    { 
    	struct Family *first = NULL;	// 头指针
    	struct Family *current = NULL;  // 当前指针
    	struct Family *last = NULL;     // 尾指针
    
    	char more = '\0';              
    
    	// 进入死循环
    	while (1)
    	{ 
    		printf("Do you want to enter details of a%s person (Y or N)? ",
    			first != NULL ? "nother " : "");
    		scanf(" %c", &more);
    		if (tolower(more) == 'n')
    			break;
    
    		current = get_person();
    
    		if (first == NULL)
    		{ 
    			first = current;            /* Set pointer to first Family */
    			last = current;             /* Remember for next iteration */
    		}
    		else
    		{ 
    			last->next = current;		/* Set next address for previous Family */
    			current->previous = last;	/* Set previous address for current */
    			last = current;				/* Remember for next iteration */
    		}
    	}
    
    	current = first;
    
    	while (current->next != NULL)		/* Check for relation for each person in */
    	{ 									/* the list up to second to last */
    		int parents = 0;				/* Declare parent count local to this block */
    		last = current->next;			/* Get the pointer to the next */
    
    		while (last != NULL)			/* This loop tests current person */
    		{ 								/* against all the remainder in the list */
    			if (related(current, last))         /* Found a parent ? */
    			if (++parents == 2)			/* Yes, update count and check it */
    				break;					/* Exit inner loop if both parents found */
    
    			last = last->next;			/* Get the address of the next */
    		}
    		current = current->next;		/* Next in the list to check */
    	}
    
    	/* 输出数据 */
    	current = first;
    
    	while (current != NULL)				/* Output Family data in correct order */
    	{ 
    		printf("\n%s was born %d/%d/%d, and has %s and %s as parents.",
    			current->name, current->dob.day, current->dob.month,
    			current->dob.year, current->father, current->mother);
    		if (current->p_to_pa != NULL)
    			printf("\n\t%s's birth date is %d/%d/%d ",
    			current->father, current->p_to_pa->dob.day,
    			current->p_to_pa->dob.month,
    			current->p_to_pa->dob.year);
    		if (current->p_to_ma != NULL)
    			printf("and %s's birth date is %d/%d/%d.\n ",
    			current->mother, current->p_to_ma->dob.day,
    			current->p_to_ma->dob.month,
    			current->p_to_ma->dob.year);
    
    		current = current->next;		/* current points to next in list */
    	}
    
    	/* 释放空间 */
    	current = first;
    	while (current->next != NULL)
    	{ 
    		last = current;					/* Save pointer to enable memory to be freed */
    		current = current->next;		/* current points to next in list */
    		free(last);						/* Free memory for last */
    	}
    }
    
    /** 输入家庭成员 */
    struct Family *get_person(void)
    { 
    	/* 临时结构体 */
    	struct Family *temp;         
    
    	temp = (struct Family*) malloc(sizeof(struct Family));
    	printf("Enter the name of the person: ");
    	scanf("%s", temp->name);         /* 家族名称 */
    	printf("Enter %s's date of birth (day month year); ", temp->name);
    	scanf("%d %d %d", &temp->dob.day, &temp->dob.month, &temp->dob.year);
    	printf("Who is %s's father? ", temp->name);
    	scanf("%s", temp->father);        /* 父亲 */
    	printf("Who is %s's mother? ", temp->name);
    	scanf("%s", temp->mother);      /*母亲 */
    	temp->next = temp->previous = NULL; /* Set pointers to NULL */
    	temp->p_to_pa = temp->p_to_ma = NULL;    /* Set pointers to NULL */
    	return temp;    
    }
    
    /** 建立关系 */
    char set_ancestry(struct Family *pmember1, struct Family *pmember2)
    { 
    	if (strcmp(pmember1->father, pmember2->name) == 0)
    	{ 
    		pmember1->p_to_pa = pmember2;
    		return 1;
    	}
    	if (strcmp(pmember1->mother, pmember2->name) == 0)
    	{ 
    		pmember1->p_to_ma = pmember2;
    		return 1;
    	}
    	else
    		return 0;
    }
    
    /** 返回关系 */
    char related(struct Family *pmember1, struct Family *pmember2)
    { 
    	return set_ancestry(pmember1, pmember2) ||
    		set_ancestry(pmember2, pmember1);
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASnhpZXBj_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/63fafa38806b48699ff5b98443b2b007.png