c语言练习

3. C语言预备知识

3.1 字符常量

题目：

熟悉 C 语言程序的字符常量输出的基本编写

源代码：

#define _CRT_SECURE_NO_WARNINGS 1 
#include<stdio.h>
int main() {
	int a1 = 20, a2 = 345, a3 = 700, a4 = 22;
	int b1 = 56720, b2 = 9999, b3 = 20098, b4 = 2;
	int c1 = 233, c2 = 205, c3 = 1, c4 = 6666;
	int d1 = 34, d2 = 0, d3 = 23, d4 = 23006783;

	printf("%d %d %d %d\n", a1, a2, a3, a4);
	printf("%d %d %d %d\n", b1, b2, b3, b4);
	printf("%d %d %d %d\n", c1, c2, c3, c4);
	printf("%d %d %d %d\n", d1, d2, d3, d4);
	return 0;
}

运行结果：

3.2 字符常量输出(2

题目：

熟悉 C 语言程序的字符常量输出的基本编写

说明：

%-9d中，d 表示以十进制输出，9 表示最少占 9 个字符的宽度，宽度不足以空格补齐，-表示左对齐。 综合起来，%-9d表示以十进制输出，左对齐，宽度最小为 9 个字符。

源代码：

#define _CRT_SECURE_NO_WARNINGS 1 
#include<stdio.h>
int main() {
	int a1 = 20, a2 = 345, a3 = 700, a4 = 22;
	int b1 = 56720, b2 = 9999, b3 = 20098, b4 = 2;
	int c1 = 233, c2 = 205, c3 = 1, c4 = 6666;
	int d1 = 34, d2 = 0, d3 = 23, d4 = 23006783;

	printf("%-9d %-9d %-9d %-9d\n", a1, a2, a3, a4);
	printf("%-9d %-9d %-9d %-9d\n", b1, b2, b3, b4);
	printf("%-9d %-9d %-9d %-9d\n", c1, c2, c3, c4);
	printf("%-9d %-9d %-9d %-9d\n", d1, d2, d3, d4);
	return 0;
}

运行结果：

3.3 字符常量输出(3

题目：

熟悉 C 语言程序的字符常量输出的基本编写

说明：

n 的指定输出宽度为 10，234 的宽度为 3，所以前边要补上 7 个空格 f 的指定输出宽度为 12，9.800000 的宽度为 8，所以前边要补上 4 个空格 str 的指定输出宽度为 8，"http://c.biancheng.net" 的宽度为 22，超过了 8，所以指定输出 宽度不再起作用，而是按照 str 的实际宽度输出

源代码：

int main(){
    int n = 234;
    float f = 9.8;
    char c = '@';
    char *str = "http://c.biancheng.net";
    printf("%10d%12f%4c%8s", n, f, c, str);
    return 0;
}

运行结果：

3.4 字符常量输出(4

题目：

熟悉 C 语言程序的字符常量输出的基本编写

说明：

对于n，.precision 表示最小输出宽度。n 本身的宽度为 6，当 precision 为 9 时，大于 6， 要在 n 的前面补 3 个 0；当 precision 为 4 时，小于 6，不再起作用 对于f，.precision 表示输出精度。f 的小数部分有 6 位数字，当 precision 为 2 或者 4 时， 都小于 6，要按照四舍五入的原则截断小数；当 precision 为 10 时，大于 6，要在小数的 后面补四个 0 对于str，.precision 表示最大输出宽度。str 本身的宽度为 9，当 precision 为 5 时，小 于 9，要截取 str 的前 5 个字符；当 precision 为 15 时，大于 9，不再起作用

源代码：

int main() {
	int n = 123456;
	double f = 882.923672;
	char* str = "abcdefghi";
	printf("n: %.9d %.4d\n", n, n);
	printf("f: %.2lf %.4lf %.101f\n", f, f, f);
	printf("str: %.5s %.15s\n", str, str);
	return 0;
}

运行结果：

3.5 字符常量输出(5

题目：

熟悉 C 语言程序的字符常量输出的基本编写

说明： 当以%10d 输出 m 时，是右对齐，所以在 192 前面补七个空格；当以%-10d 输出 m 时， 是左对齐，所以在 192 后面补七个空格 m 是正数，以%+d 输出时要带上正号；n 是负数，以%+d 输出时要带上负号 m 是正数，以% d 输出时要在前面加空格；n 是负数，以% d 输出时要在前面加负号 %.0f 表示保留 0 位小数，也就是只输出整数部分，不输出小数部分 默认情况下，这种输 出形式是不带小数点的，但是如果有了#标志，那么就要在整数的后面“硬加上”一个小数点， 以和纯整数区分开

源代码：

int main() {
	int m = 192, n = -943;
	float f = 84.342;
	printf("m=%10d,m=%-10d\n", m, m);//演示 - 的用法
	printf("m=%+d,n=%+d\n", m, n);//演示 + 的用法
	printf("m = % d, n = % d\n", m, n);//演示空格的用法
	printf("f=%0.f,f=%#0.f\n", f, f);//演示#的用法
    return 0;
}

运行结果：

4. 顺序结构程序设计

4.1 scanf 函数的用法

题目：

熟悉 C 语言程序的scanf 函数的用法

说明：

从键盘输入 12，按下回车键，scanf() 就会读取输入数据并赋值给变量 a；本次输入结束，接着执行下一个 scanf() 函数，再从键盘输入 60，按下回车键，就会将 60 赋值 给变量 b，都是同样的道理。 第 8 行代码中，scanf() 有两个以空格分隔的%d，后面还跟 着两个变量，这要求我们一次性输入两个整数，并分别赋值给 c 和 d。 注意"%d %d"之间 是有空格的，所以输入数据时也要有空格。 对于 scanf()，输入数据的格式要和控制字符串 的格式保持一致。

源代码：

#include <stdio.h>
#include <stdlib.h>
//案例1
int main()
{
    int a = 0,b = 0,c = 0,d = 0;
    scanf("%d",&a);
    scanf("%d",&b);
    printf("a+b=%d\n",a+b);
    scanf("%d %d",&c,&d);
    printf("c*d=%d\n",c*d);
    return 0;
}

运行结果：

4.2 %p格式控制符

题目：

熟悉 C 语言程序的%P格式控制符用法

说明：

%p 是一个新的格式控制符，它表示以十六进制的形式（带小写的前缀）输出数据的地址。 如果写作%P，那么十六进制的前缀也将变成大写形式

源代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a = 'F';
    int b = 12;
    int c = 452;
    printf("&a=%p,&b=%p,&c=%p\n",&a,&b,&c);
    return 0;
}

运行结果：

4.3 格式控制字符串的用法

题目：

熟悉 C 语言程序的格式控制字符串的用法

说明：

第一个 scanf() 的格式控制字符串为"%d %d"，中间有一个空格，而我们却输入了 10 20， 中间有多个空格 第二个 scanf() 的格式控制字符串为"%d %d"，中间有多个空格，而 我们却输入了 100 200，中间只有一个空格。这说明 scanf() 对输入数据之间的空格的处 理比较宽松，并不要求空格数严格对应，多几个少几个无所谓，只要有空格就行 第三个 scanf() 的控制字符串为"%d, %d, %d"，中间以逗号分隔，所以输入的整数也要以逗号分 隔 第四个 scanf() 要求整数之间以 is bigger than 分隔。 用户每次按下回车键，程序就会认为完成了一次输入操作，scanf() 开始读取用户输入的内 容，并根据格式控制字符串从中提取有效数据，只要用户输入的内容和格式控制字符串匹配， 就能够正确提取。 本质上讲，用户输入的内容都是字符串，scanf() 完成的是从字符串中提取有效数据的过程

源代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a,b,c;
    scanf("%d %d",&a,&b);
    printf("a+b=%d\n", a+b);

    scanf("%d %d",&a,&b);
    printf("a+b=%d\n",a+b);

    scanf("%d %d %d",&a,&b,&c);
    printf("a+b+c=%d\n",a+b+c);

    scanf("%d is bigger than %d",&a,&b);
    printf("a-b=%d\n",a-b);
    return 0;
}

运行结果：

4.4 变量赋值的用法

题目：

熟悉 C 语言程序的变量赋值的用法

说明：

前两个整数被正确读取后，剩下了 a10，而第三个 scanf() 要求输入两个十进制的整数，a10 无论如何也不符合要求，所以只能读取失败。

输出结果也证明了这一点，c 和 d 的值并没有被改变。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a = 1,b = 2,c = 3,d = 4; //修改处：给变量赋予不同的初始值
    scanf("%d",&a);
    scanf("%d",&a);
    printf("a=%d,b=%d\n",a,b);
    scanf("%d %d",&c,&d);
    printf("c=%d,d=%d\n",c,d);

    return 0;
}

运行结果：

4.5 scanf 函数的用法(2

题目：

熟悉 C 语言程序的变量赋值的用法

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char letter;
    int age;
    char url[30];
    float price;

    scanf("%c",&letter);
    scanf("%d",&age);
    scanf("%s",url);
    scanf("%f",&price);

    printf("26个英文字母最后一个是 %c \n",letter);
    printf("我的网站已经成立%d年了,网站是%s,开通VIP会员的价格是 %g \n", age,url,price);

    return 0;
}

运行结果：

4.6 三个数找最大值

题目：

三个数找最大值

源代码：

#include <stdio.h>
#include <stdlib.h>
int max(int x,int y){
    int t;
    t=x>y?x:y;
    return t;
}
int main()
{
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    int maxs=max(a,max(b,c));
    printf("%d",maxs);
}

运行结果：

4.7 素数判断

题目：

素数判断

源代码：

#include <stdio.h>
int main() {
    int n;
    printf("请输入一个1-100之间的整数：\n");
    scanf("%d", &n);

    int m = 0;
    for (int i = 2; i < n; i++ ) {
        if(n % i  == 0) {
            m++;
        }
    }
    if (m == 0) {
        printf("%d是素数\n", n);
    } else {
        printf("%d不是素数\n", n);
    }
    return 0;
}

运行结果：

4.8 编程输出如图所示的三角形

题目：

编程输出如图所示的三角形

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b;
    for(a=0;a<4;++a){
    for(b=0;b<=a;++b){
        printf("☆");
    }
        printf("\n");

    }
    return 0;
}

运行结果：

4.9 求圆面积和圆周长，给定圆半径值为5

题目：

编程求圆面积和圆周长 给定圆半径值为 5

（1）定义浮点型变量使用关键字 double

（2）浮点型数据输出的格式控制符是 %lf

（3）C 语言中没有∏这个符号，编写程序时直 接使用 3.14159

（4）C 语言中没有求次方的运算符，半径的平 方需用乘号（r*r）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    double radius;//半径
    double area;//面积
    double perimeter;//周长

    printf("圆半径: ");
    scanf("%lf",&radius);
    //printf("圆半径: %lf \n",&radius);
    area = 3.14159 *(radius*radius);
    printf("圆面积: %lf \n",area);
    perimeter = 2 * 3.14159 * radius;
    printf("圆周长: %lf \n",perimeter);
    return 0;
}

运行结果：

5. 顺序结构程序设计

5.1 printf( )函数的编程练习

题目：

编程输出如图所示的三角形

源代码：

#include <stdio.h>
#include <stdlib.h>
//printf实现五角星
int main()
{
    printf("*\n");
    printf("**\n");
    printf("***\n");
    printf("****\n");
    return 0;
}

运行结果：

5.2 scanf( )函数编程练习、练习除号的使用规则(1

题目：

编写一个摄氏温度与华氏温度之间的转换程序， 转换公式是：F=9/5C+32

该公式中的“C”是一个从键盘输入的已知量； “F”是通过公式计算并打印出来的未知量。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    float c,f;
    printf("请输入一个摄氏温度值：");
    scanf("%f",&c);
    f=(9.0/5.0*c)+32.0;
    printf("对应的华氏温度是：%f\n",f);
    return 0;
}

运行结果：

5.3 scanf( )函数编程练习、练习除号的使用规则(2

题目：

编写程序，从键盘上输入两个电阻值，求它们并联电阻值和串联电阻值，输 出结果保留两位小数

提示：

并联电阻 RP = R1*R2/R1+R2

串联电阻 RS = R1+R2

（1）scanf( )函数可以写成 scanf("%d,%d", &r1, &r2);

（2）结果保留两位小数的格式说明符是“%.2lf”。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int r1,r2;
    double rp,rs;

    printf("请输入两个电阻值：");
    scanf("%d,%d",&r1,&r2);

    rp=1.0/(1.0/r1+1.0/r2);
    rs=r1+r2;

    printf("并联电阻值：%.2lf\n",rp);
    printf("串联电阻值：%.2lf",rs);
    return 0;
}

运行结果：

5.4 scanf( )函数编程练习、练习除号的使用规则(3

题目：

从键盘输入两个两位的正整数，按照以下格式组装成一个四位的正整数。例如：输入12和34，组装成的四位数是1324。

提示：

（1）首先利用“除号”和“求余号”分别把两个两位正 整数的十位数、个位数分离开；再经过数学运算组装成一个四位数。

（2）scanf( )函数可以写成 scanf("%d%d", &a, &b);

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b,c,d,e,f,j,h;
    printf("请输入两个两位的正整数:");
    scanf("%d%d",&a,&b);
    //个
    c=a%10;
    d=b%10;
    //十
    e=a/10;
    f=b/10;

    j=c*10+d;
    h=e*10+f;
    printf("组合成的四位正整数是：%d%d\n",h,j);
    return 0;
}

运行结果：

5.5 字符的输入和输出(1

题目：

使用以下指定的方法编写程序，打印如图所示图形。

提示：

使用 printf 函数的“%c”格式打印该图形。 用“%c”打印字符时，一个“%c”只能打印一个字符。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char a,b,c,d;
    a='a';
    b='b';
    c='c';
    d='d';

    printf("%c\n",a);
    printf("%c",b);
    printf("%c\n",b);
    printf("%c",c);
    printf("%c",c);
    printf("%c\n",c);
    printf("%c",d);
    printf("%c",d);
    printf("%c",d);
    printf("%c\n",d);

    return 0;
}

运行结果：

5.6 字符的输入和输出(2

题目：

从键盘输入3个数字字符，将它们分别转换为对应的整数值 （即字符’0’转换为整数0，字符’1’转换为整数1，依次类推），然后求3个整数的 平均值。

提示：

本题的变量定义可参考如下：

char a, b, c; //变量a,b,c保存输入的3个数字字符

int x, y, z; //变量x,y,z保存转换后的3个整数

double aver; //变量aver保存求出的平均值

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char a,b,c;
    int x,y,z;
    double aver;
    printf("请输入3个数字字符：");
    scanf("%c%c%c",&a,&b,&c);

    x=a-48;
    y=b-48;
    z=c-48;

    aver=(x+y+z)/3.0;

    printf("平均值 = %2lf",aver);
    return 0;
}

运行结果：

5.7 数学函数的使用

题目：

输入三角形的三条边长，求三角形的面积。

提示：

（1）本题的变量定义可参考如下： int a, b, c; double x, s;

（2）scanf( )函数可以写成 scanf("%d,%d,%d", &a, &b, &c);

（3）计算三角形面积的公式是：

$s = \sqrt{x*(x - a)*(x - b)*(x - c)}其中 x = \frac{1}{2}*(a + b + c)$

（4）求 x 的开方值的库函数是 sqrt(x)，使用时需包含头文件 math.h

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int a,b,c;
    double x,s;
    printf("请输入三角形的三边：");
    scanf("%d,%d,%d",&a,&b,&c);

    x=1.0/2.0*(a+b+c);
    s=sqrt(x*(x-a)*(x-b)*(x-c));
    printf("三角形面积为：%lf",s);
    return 0;
}

运行结果：

6. 选择结构程序设计

6.1 单分支 if 语句编程练习

题目：

从键盘任意输入 3 个整数，选出其中的最大数并打印。

提示：

（1） 要判断最大数，需对每两个数作两两比较。

（2） 可以使用 3 个单分支 if 语句编写程序。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b,c;
    printf("请输入3个整数：");
    scanf("%d,%d,%d",&a,&b,&c);
    if(a>b&&c<a)
        printf("最大数是：%d",a);
    if(b>c&&b>a)
        printf("最大数是：%d",b);
    if(c>a&&c>b)
        printf("最大数是：%d",c);
    return 0;
}

运行结果：

6.2 双分支 if 语句编程练习

题目：

从键盘输入三个正整数，判断否能构成三角形的三边？

如果能，就按照以下 提示的数学公式计算三角形的面积；如果不能，就输出“不能构成三角形”的 提示信息。

提示：

（1） 该题属于“双分支 if-else 语句”结构。

（2） 能构成三角形的逻辑条件是：任意的两边之和均要大于第三边。

（3） 计算三角形面积的公式是：

$s = \sqrt{x*(x - a)*(x - b)*(x - c)}其中 x = \frac{1}{2}*(a + b + c)$

（4）本题的变量定义可参考如下：int a, b, c; double x, s;

（5）本题要用到求开方值的数学库函数 sqrt( )，需包含头文件 math.h

例如：写成 sqrt(x) 即能够求出 x 的开方值。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int a,b,c;
    double x,s;
    printf("请输入三个整数：");
    scanf("%d,%d,%d",&a,&b,&c);
    if(a+b>c&&a+c>b&&b+c>a){
    x=1.0/2.0*(a+b+c);
    s=sqrt(x*(x-a)*(x-b)*(x-c));
    printf("三角形面积为：%lf",s);
    }else{
    printf("不能构成三角形");
}
    return 0;
}

运行结果：

6.3 多分支 if 语句编程练习

题目：

从键盘输入一个合法的算术运算符（+、-、*、/）及两个实数，使用 if 语句 编写程序，根据输入的运算符判断对这两个实数进行何种运算，并打印运算结果（要求结果保留两位小数）。

提示：

（1）该题属于“多分支 if 语句”结构。

（2）运算符是字符，存放运算符的变量是 char 型，scanf( )输入时应使用%c。

（3）本题的变量定义可参考如下：char fu; double x, y, z;

（4）但是不允许使用 switch 语句编写该题程序。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char fu;
    double x,y,z;

    printf("请输入1个算术运算符和2个浮点数：");
    scanf("%c,%lf,%lf",&fu,&x,&y);
    if(fu=='+'){
        z=x+y;
        printf("%lf + %lf = %lf",x,y,z);
    }else if(fu=='-'){
        z=x-y;
        printf("%lf - %lf = %lf",x,y,z);
    }else if(fu=='*'){
        z=x*y;
        printf("%lf * %lf = %lf",x,y,z);
    }
    else if(fu=='/'){
        z=x/y;
        printf("%lf / %lf = %lf",x,y,z);
    }else{
        printf("运算符非法，无法参与运算");
    }
    //printf("%c\n",fu);
    //printf("%lf和%lf",x,y);
    return 0;
}

运行结果：

6.4 if 语句的嵌套结构编程练习

题目：

从键盘输入3个正整数，判断否能构成三角形的三边？

如果能，判断是构成 哪一种三角形（正三角形，还是等腰三角形，还是直角三角形，还是普通三角形）；

如果不能，就输出“不能构成三角形”的提示信息。

提示：

（1）该题属于“if 语句的嵌套”结构。

（2）外层 if 语句是双分支结构，判断能否构成三角形（能构成三角形的逻辑条 件是：任意两边之和均要大于第三边）。

（3）内层 if 语句是多分支结构，第一步判断等边三角形，第二步判断等腰三角形，第三步判断直角三角形，最后是普通三角形。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b,c;
    printf("请输入三个整数：");
    scanf("%d,%d,%d",&a,&b,&c);

    if(a+b>c&&a+c>b&&b+c>a){
    if(a==b&&b==c){
    printf("能构成等边三角形");
    }else if(a==b&&b!=c){
    printf("能构成等腰三角形");
    }else if(a<b&&b<c){
    printf("能构成直角三角形");
    }else{
    printf("能构成普通三角形");
    }
    }else{
    printf("不能构成三角形");
}
    return 0;
}

运行结果：

6.5 switch 语句编程练习

题目：

输入一个年份和一个月份，使用 switch 语句编程判断并打印该月的天数。

提示：

（1）本题先使用if语句判断输入月份的有效性，如果月份有效，再使用switch 语句判断月份对应的天数。

（2）为简化题目难度，本题不对年份作有效性判断，默认输入的是一个有效年 份。只对月份作有效性判断，当输入月份无效时，要给出提示信息。 （3）对于2月份的处理需要判断闰年，闰年的判断参考教材P62例3.8。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int year,month;
    printf("请输入一个年份和一个月份:");
    scanf("%d,%d",&year,&month);
    if(month<13){
        switch(month){
        case 1:
            printf("%d年%月有31天",year,month);break;
        case 2:
            if((year%4==0&&year%100!=0)||(year%400==0)){
            printf("%d年%月有29天",year,month);
            }else{
            printf("%d年%月有28天",year,month);break;
            }
        case 3:
            printf("%d年%月有31天",year,month);break;
        case 4:
            printf("%d年%月有30天",year,month);break;
        case 5:
            printf("%d年%月有31天",year,month);break;
        case 6:
            printf("%d年%月有30天",year,month);break;
        case 7:
            printf("%d年%月有31天",year,month);break;
        case 8:
            printf("%d年%月有31天",year,month);break;
        case 9:
            printf("%d年%月有30天",year,month);break;
        case 10:
            printf("%d年%月有31天",year,month);break;
        case 11:
            printf("%d年%月有30天",year,month);break;
        case 12:
            printf("%d年%月有31天",year,month);break;
        }

    }else{
    printf("输入的月份为非法值\n");
    }
    return 0;
}

运行结果：

7. 循环结构程序设计

7.1 while语句编程练习

题目：

使用 while 语句编程计算 “1+2+3+4+ … +100 ”

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i = 1,sum = 0;
    while(i<=100)
{
    sum=sum + i;
    i++;
}
    printf("1+2+3+4...+100=%d\n",sum);
    return 0;
}

运行结果：

7.2 while语句编程练习(2

题目：

从键盘输入一行字符（以回车作为输入结束标志），统计输入字符 的个数。（使用 while 语句）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i;
    char c;
    i=0;
    printf("键盘输入一行字符:");
    c=getchar();
    while(c!='\n'){
        c=getchar();
        i++;
    }
    printf("%d",i);
    return 0;
}

运行结果：

7.3 do-while语句编程练习(1

题目：

使用 do-while 语句编程计算 “1+2+3+4+ … +100 ”

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i=1,sum=0;
    do{
        sum = sum+i;
        i++;
    }while(i<=100);
    printf("1+2+3+4...+100=%d\n",sum);
    return 0;
}

运行结果：

7.5 while语句编程练习(3

题目：

根据以下公式求∏ 的值，当某项小于 0.0005 时停止迭代。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    double s=1;
    float pi,sum=0,t=1,n=1;
    while(fabs(s)>=1e-6){
        pi+=s;
        t=n/(2*n+1);
        s*=t;
        n++;
    }
    pi=pi*2;
    printf("pi=%lf",pi);
    return 0;
}

运行结果：

7.6 for语句编程练习(1

题目：

编程求斐波拉契数列的前 20 项。

（斐波拉契数列的第 1、2 项分别 为 0、1，以后各项的值都是前两项之和）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int f1=0,f2=1,f3;
    int i;
    printf("%d\t%d",f1,f2);
    for(i=3;i<=20;i++){
        f3=f1+f2;
        printf("%d\t",f3);
        f1=f2;
        f2=f3;
    }
    return 0;
}

运行结果：

7.7 for语句编程练习(2

题目：

编程求所有的水仙花数。（所谓水仙花数是指一个三位数，其各位 数字的立法和等于该数本身。例如：153 是水仙花数，因为 153=13+53+33）

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int ge,shi,bai,i,sum;
    for(i=100;i<1000;i++){
        ge=i%10;
        shi=i%100/10;
        bai=i/100;
        sum=pow(ge,3)+pow(shi,3)+pow(bai,3);
        if(i==sum){
            printf("%d\t",i);

        }
    }
    return 0;
}

运行结果：

7.8 while语句编程练习(4

题目：

使用 while 语句编程求 100 以内能被 5 整除但不能同时被 7 整除的数，并统 计找到的数的个数。

提示：

（1）该题变量可定义为：int i, sum=0;

（2）整除问题使用求余号“%”。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,sum=0;
    printf("100以内能被5整除但不能同时被7整除的数是：\n");
    i=1;
    while(i<101){
        if(i%5==0&&i%7!=0){
            printf("%d\t",i);
            sum++;
        }

        i++;
    }
    printf("\n符合条件的数有%d个",sum);
    return 0;
}

运行结果：

7.9 while语句编程练习(5

题目：

使用 while 语句编程计算π的近似值，公式如下，直到最后一项的绝对值小 于

$E=10^-6$

为止。

$\frac {π}{4}≈1-\frac {1}{3}+\frac {1}{5}-\frac {1}{7}+.....$

提示：

（1） 本题变量可定义为 double zi, mu, t, sum; // zi, mu, t 分别用来保存分子、分母、当前项 请同学自己思考这些变量的初值各为多少？

（2） 本题需用到求绝对值的库函数 fabs( )，并包含头文件 math.h

（3） 本题的循环体里有 4 个通式：

①分子的通式、②分母的通式、③当前项 的通式、④求和的通式

（4）可以将 +1、-1、+1、-1 …… 依次看作每一项的分子。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    float pi,sum=0,t=1,n=1;
    int sign=1;
    while(fabs(t)>=1e-6){
       sum+=t;
       n+=2;
       sign*=-1;
       t=sign/n;
    }
    pi=sum*4;
    printf("pai的近似值=%lf",pi);
    return 0;
}

运行结果：

7.10 while语句编程练习(6

题目：

使用 while 语句编程求以下表达式的值，直到某一项的值小于 10 -6就结束循环，即

$E=10^-6$

若 x=2.5，函数值 f(x)为：12.182493。

$f(x)=1+x+\frac {x^2}{2！}+.....+\frac {x^n}{n！}$

提示：

（1） 本题循环次数不确定，由某一项的值小于 10 -6 作为循环的结束标志。

（2）该题变量可定义为：int i=1; double x=2.5, zi=2.5, mu=1, t, sum=1;

（3）注意观察可知，每相邻两项，后一项的分子等于前一项的分子乘以x，后一 项的分母等于前一项的分母乘以 i 值。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int i=1;
    double x=2.5,zi=2.5,mu=1,sum=1;
    printf("表达式的值为：\n");
     while(sum>1e-6)
    {
        zi=zi*x;
        mu = mu*i;
        sum=sum+zi/mu;
        i++;
    }
    printf("%lf\n",sum);
    return 0;
}

运行结果：

7.11 do-while语句编程练习(3

题目：

使用 do-while 语句编程计算以下式子，直到某一项的绝对值 小于 0.000001 为止。并打印最后一项的 n 值。

$sum=1-\frac {1}{2!}+\frac {1}{3!}-\frac {1}{4!}+...+(-1)^n-1*\frac {1}{n!}$

提示：

（1）该题变量可定义为 int n; double fu, mu, t, sum;

请同学自己思考这些变量的初值各为多少？

（2）本题可使用求绝对值的库函数 fabs( )，并包含头文件 math.h。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int i=1;
    double sum=0,t=1;
    do
    {
        sum+=t*(i%2?1:-1);
        t/=++i;
    }while(t>=1e-6);
    printf("sum=%lf\n",sum);
    printf("最后一项n=%d",i-1);
    return 0;
}

运行结果：

7.12 for语句编程练习(3

题目：

使用 for 语句编程求以下表达式的值，如果从键盘输入 20 赋值给变量 n

提示：

（1）该题变量可定义为 int i, n; double t=1, sum=1;

（2）本题需用到求开方值的数学函数 sqrt( )，并包含头文件 math.h

$S=1+(1+\sqrt{2})+(1+\sqrt{2}+\sqrt{3})+......+(1+\sqrt{2}+\sqrt{3}+\sqrt{n})$

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    int i,n;
    double t=1,sum=1;
    printf("请输入变量n：\n");
    scanf("%d",&n);
    for(i=2;i<n;i++){
        t=t+sqrt(i);
        sum=sum+t;
    }
    printf("结果为:%lf",sum);
    return 0;
}

运行结果：

7.13 for语句编程练习(4

题目：

使用 for 语句编程求以下表达式的值

$Sum=1+\frac {1}{1+2}+\frac {1}{1+2+3}+...+\frac {1}{1+2+...+10}$

提示：

（1）注意观察可知相邻两项中，后一项的分母是前一项的分母加 i 值。 （2）该题变量可定义为：int i=1; double mu=0, t, sum=0;

其中 i 是循环变量，mu 保存每一次循环的当前项的分母，t 保存每一次循 环的当前项，sum 保存 N 项式的总和。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i = 1;
    double mu = 0,t,sum=0;
    t=10;
    printf("表达式的值为：\n");
    for(i;i<=t;i++){
        for(int s=1;s<=i;s++){
        mu +=s;
    }
        sum +=1/mu;
    }
    printf("sum=%lf",sum);
    return 0;
}

运行结果：

8. 循环结构程序设计

8.1 for语句编程练习(1

题目：

用循环结构编程打印以下图形

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,k;
    for(i=1;i<=4;i++)
    {
        for(k=1;k<=2*i-1;k++)
        {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

运行结果：

8.2 for语句编程练习(2

题目：

用循环结构编程打印该图形

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,j,k;
    for(i=1;i<=4;i++)
    {
        for(j=1;j<=4-i;j++)
        {
            printf(" ");
        }
        for(k=1;k<=2*i-1;k++)
        {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

运行结果：

8.3 for语句编程练习(3

题目：

求 300 以内能被 17 整除的最大数

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,n=0;
    printf("300以内能被17整除的最大数：");
    for(i=1;i<=300;i++)
    {
        if(i%17==0)
        {
            printf("%d\t",i);

        }
    }
    return 0;
}

运行结果：

8.4 while语句编程练习(1

题目：

打印 300 以内不能同时被 5 和 17 整除的数

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,sum=0;
    printf("300以内不能被5整除同时不能被17整除的数是：\n");
    i=1;
    while(i<301){
        if(i%5!=0&&i%17!=0){
            printf("%d\t",i);
            sum++;
        }

        i++;
    }
    printf("\n符合条件的数有%d个",sum);
    return 0;
}

运行结果：

8.5 for语句编程练习(4

题目：

从键盘输入一个正整数，判断是否是素数

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n,i,flag=1;
    printf("请输入一个整数：");
    scanf("%d",&n);
    for(i=2;i<n;i++)
    {
        if(n%i==0)
        {
            flag = 0;
            break;
        }
    }
    if(flag==1)
    {
        printf("%d是素数\n",n);
    }
    else if(flag==0)
    {
        printf("%d不是素数\n",n);
    }
    return 0;
}

运行结果：

8.6 for语句编程练习(5

题目：

猜数游戏：

任意设置一个整数，请用户从键盘上输入数据猜想设值的数是什么，告诉用户是猜大了还是小了。3 次以内猜对，用户获胜。

否则，告诉用户设置的数据 是什么。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int num=30,k,i;
    printf("请猜数：\n");
    scanf("%d",&k);
    for(i=1;i<3;i++)
    {
        if(num>k)
        {
            printf("猜小了,请重新猜数：\n");
            scanf("%d",&k);
        }
        else if(num<k)
        {
            printf("猜大了,请重新猜数：\n");
            scanf("%d",&k);
        }
        else
        {
            printf("猜对了!!!!");
            printf("%d",num);
        }
    }
    printf("用户设置的数据为：%d",num);
    return 0;
}

运行结果：

8.7 for语句编程练习(6

题目：

使用 for 语句的嵌套结构编程打印九-九乘法表，运行效果如图所示

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,j,sum;
    for(i=1;i<10;i++)
    {
        for(j=1;j<10;j++)
        {
            if(i>=j)
            {
                printf("%d*%d=%d\t",i,j,i*j);
            }
        }
        printf("\n");
    }
    return 0;
}

运行结果：

8.8 for语句编程练习(7

题目：

使用 for 语句的嵌套结构编程打印如图所示图形

不得将图形以普通字符的形式直接打印出来， 每次循环只打印一个“*”号

提示：

将菱形分为两部分处理，上半部分是正三角， 使用一组for语句的嵌套结构打印，下半部分是倒三 角，使用另外一组for语句的嵌套结构打印。

源代码：

8.9 break 语句编程练习(1

题目：

从键盘输入2个正整数，求它们的最大公约数和最小公倍数。运行效果如图

提示：

（1）本题的变量可定义为 int i, a, b,max, min; 其中 i 是循环变量；a、b保存输入的2个正整数；max、min分别保存a 和b中的较大值和较小值。

(2) 求最大公约数的方法是：从a和b中较小的数开始递减循环，直到 2 为止， 判断在此范围内a和b是否能同时整除某数，如果有，则该数就是a和b的最大公 约数。当找到了最大公约数时便利用 break; 语句结束循环。例如：求6和9的最 大公约数时，查找范围是6 - 2，在此范围内，判断6和9能同时整除3，则3就是 它们的最大公约数。

(3) 求最小公约数的方法是：从a和b中较大的数开始递增循环，直到 a*b 为止， 判断在此范围内是否有数能同时被a和b整除，如果有，则该数就是a和b的最小 公倍数。当找到了最小公倍数时便利用 break; 语句结束循环。例如：求6和9 的最小公倍数时，查找范围是9 - 54，在此范围内，判断18能被6和9同时整除, 则18就是它们的最小公约数。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,a,b,max,min,result;
    printf("请输入2个正整数：");
    scanf("%d,%d",&a,&b);

    if(a>b)
    {
        max = a;
        min = b;
    }
    else
    {
        max = b;
        min = a;
    }
    for(i=min;i>=1;i--)
    {
        if(a%i==0&&b%i==0)
        {
            result = i;
            printf("%d和%d的最大公约数是：%d\n",a,b,result);
            break;
        }
    }
    for(i=max;i<=a*b;i++)
    {
        if(i%a==0&&i%b==0)
        {
            printf("%d和%d的最大公倍数是：%d",a,b,i);
            break;
        }
    }

    return 0;
}

运行结果：

8.10 break 语句编程练习(2

题目：

编程求3到100之间的所有素数，并统计素数的个数。

提示：

该题的结构是双层循环嵌套，变量可定义为 int i, j, sum=0;

i变量是外循环变量，控制循环范围是3 ~ 100。

j变量是内循环变量，内循环 用来判断每一次外循环的 i 值是否是素数。

sum变量是统计个数的变量。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
   int i,j,sum=0;
   printf("3到100之间的所有素数是：\n");
   for(i=3;i<=100;i++)
   {
       for(j=2;j<=i;j++)
       {
           if(i%j==0)
           {
               if(i==j)
                {
                    printf("%d\t",j);
                    sum++;
                }
                break;
           }
       }
   }
   printf("\n素数的个数 = %d",sum);
    return 0;
}

运行结果：

8.11 continue 语句编程练习

题目：

使用continue语句编程判断1到100之间能被5或7整除，但不能同时被5和7 整除的所有数，并统计数的个数。

提示：

（1） 该题的结构是循环嵌套选择。

（2） 注意：continue语句的功能是结束本次循环，提前进入下一次循环。即一 旦continue语句被执行，则continue语句之后的语句将被跳过。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,n = 0;
    printf("1到100之间能被5或7整除，但不能同时被5和7整除的数是：\n");
    for(i=1;i<=100;i++)
    {
        if(i%5!=0&&i%7!=0 || (i%5==0&&i%7==0))
        {
            continue;
        }
        printf("%d\t",i);
        n++;
    }
    printf("\n满足要求的数的个数=%d",n);
    return 0;
}

运行结果：

9. 数组

9.1 一维数组编程练习(1

题目：

从键盘输入10个整数到数组中，分别按顺序和逆序输出这 10 个数。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10];
    printf("请输入十个整数到数组里：\n");
    for(int i=0;i<10;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("顺序循环数组：\n");
    for(int i=0;i<10;i++)
    {
        printf("%d\t",a[i]);
    }
    printf("逆序循环数组：\n");
    for(int i=9;i>=0;i--)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

运行结果：

9.2 一维数组编程练习(2

题目：

从键盘输入 10 个整数放在一维数组中，求这 10 个数中的最大值和最小值。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10],min,max;
    printf("请输入十个整数到数组里：\n");
    for(int i=0;i<10;i++)
    {
        scanf("%d",&a[i]);
    }
    max=a[0],min=a[0];
    for(int i=0;i<10;i++)
    {
        if(min>a[i])
        {
            min=a[i];
        }
        else if(max<a[i])
        {
            max=a[i];
        }
    }
    printf("最大值为：%d\n",max);
    printf("最小值为：%d\n",min);
    return 0;
}

运行结果：

9.3 一维数组编程练习(3

题目：

先对数组的第 1、2 个元素进行初始化，然后利用数组求斐波拉契数列的前 20 项并打印结果。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i ,a[20]={1,1};
    for(i=2;i<=19;i++)
    {
        a[i]=a[i-2]+a[i-1];
    }
    printf("斐波拉契数列的前 20 项为：\n");
    for(i=0;i<=19;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

运行结果：

9.4 一维数组编程练习(4

题目：

从数组中存放了 5 个整数，使用冒泡法将这 5 数按照由小到大的顺序（升序）进行排序。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[5],t;
    printf("请输入五个整数到数组里：\n");
    for(int i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=0;i<5;i++)
    {
        for(int j=i+1;j<5;j++)
        {
            if(a[i]>a[j])
            {
                t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }

    }
    printf("冒泡排序后的结果：\n");
    for(int i=0;i<5;i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

运行结果：

9.5 二维数组编程练习(1

题目：

程序定义了一个 3 行 3 列的二维数组，从键盘输入各元素初值，编程将数组左下三 角（包括对角线）中的值全部置 0。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[3][3];
    printf("请输入各初值到数组里：\n");
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    printf("数组初始值为：\n");
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            printf("%d \t",a[i][j]);
        }
        printf("\n");
    }
    printf("将数组左下三角(包括对角线)赋值0：\n");
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            if(a[i]>=a[j])
            {
                a[i][j]=0;
            }
        }
    }
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            printf("%d \t",a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

运行结果：

9.6 二维数组编程练习(2

题目：

将一个 2 行 3 列的二维数组的各元素按列依次存放到一个一维数组中。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[2][3]={{1,2,3},{4,5,6}},b[6],k;
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++,k++)
        {
            b[k]=a[i][j];
        }

    }
    printf("存放到一维数组后的结果：\n");
    for(int i=0;i<6;i++)
    {
        printf("%d\t",b[i]);
    }
    return 0;
}

运行结果：

9.7 指针基础编程练习

题目：

从键盘输入两个整数到变量 a、b 中，编程将这两个数中的较大值放在 a 中，较小 值放在 b 中。（要求：所有操作使用指针完成）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b,*pa,*pb,*pt;

    printf("请输入两个整数a和b:\n");
    scanf("%d,%d",&a,&b);
    pa = &a;
    pb = &b;
    printf("a = %d , b = %d\n",a,b);
    if(a<b)
    {
        pt=pa;
        pa=pb;
        pb=pt;
    }
    printf("转换后:\na = %d , b = %d\n",*pa,*pb);
    return 0;
}

运行结果：

9.8 一维数组编程练习(5

题目：

定义一个大小为 10 的整型一维数组，初始化所有数组元素，查找数组中的最大值和最小值。

提示：

（1） 本题变量定义可参考如下 int a[10]={ 3,6,1,7,8,4,9,5,2,10}, i, max, min;

（2） 首先用一个for循环打印10个数组元素的初值。

（3） 再用一个 for 循环嵌套 if 语句查找最大值、最小值。

（4） 查找最大值、最小值的方法相同：首先默认数组中的第一个数最大或最 小，将这个默认值放到 max 或 min 中，然后用 max 或 min 与后续元素 作比较。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={3,6,1,7,8,4,9,5,2,10},i,max,min;
    printf("数组中的初值是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }

    max=a[0],min=a[0];
    for(i=0;i<10;i++)
    {
        if(min>a[i])
        {
            min=a[i];
        }
        else if(max<a[i])
        {
            max=a[i];
        }
    }
    printf("\n数组中的最大值 = %d，最小值 = %d",max,min);
    return 0;
}

运行结果：

9.9 一维数组编程练习(6

题目：

定义一个大小为 10 的整型一维数组，初始化所 有数组元素，编程查找数组中的所有奇数，并统计奇数的个数。

提示：

（1） 本题变量定义可参考如下 int a[10]={2,4,5,6,9,11,13,16,17,19}, i, sum=0;

（2） 首先用一个for循环打印10个数组元素的初值。

（3） 再用一个for循环嵌套if语句查找并打印数组中的奇数。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={2,4,5,6,9,11,13,16,17,19},i,sum=0;
    printf("数组中的初值是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }
    printf("数组中的奇数是:\n");
    for(i=0;i<10;i++)
    {
        if(a[i]%2!=0)
        {
         printf("%d ",a[i]);
         sum++;
        }
    }
    printf("\n奇数个数是:%d",sum);
    return 0;
}

运行结果：

9.10 一维数组编程练习(7

题目：

定义一个大小为 10 的整型一维数组， 初始化其中的 9 个元素，这 9 个元素已经按照降序排列。从键盘再输入1个整数， 将该整数插入到已有的元素中，需保证这 10 个数仍然按照降序排序。

提示：

（1）本题变量定义可参考如下 int a[10]={ 20, 18, 15, 12, 10, 9, 7, 5, 2}, i, j, t; （2）本题使用冒泡法排序，先将键盘输入的1个整数放到数组元素a[9]中，然后 使用排序算法对这10个数进行降序排序。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={ 20, 18, 15, 12, 10, 9, 7, 5, 2}, i, j, t;
    printf("数组中的前面9个元素是:\n");
    for(i=0;i<9;i++)
    {
        printf("%d ",a[i]);
    }

    printf("\n请输入一个整数:");
    scanf("%d",&a[9]);
    for(i=0;i<10;i++)
    {
        for(j=0;j<10;j++)
        {
            if(a[i]>a[j])
            {
                t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
    }
    printf("降序排序后的10个数组元素是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

运行结果：

9.11 一维数组编程练习(8

题目：

定义一个大小为 10 的整型一维数组，初始化所有数组元素，编程对中间的 8 个元素进行降序排序，即第一个和最后一个元素不参与排序。

提示：

（1）本题变量定义可参考如下 int a[10]={ 3,6,1,7,8,4,9,5,10,2}, i, j, k, t;

（2）使用选择法排序，百度一下。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={ 3,6,1,7,8,4,9,5,10,2},i,j,k,t;
    printf("数组中的初始值是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }

    for(i=1;i<10-2;i++)
    {
        k=i;
        for(j=i+1;j<10-1;j++)
        {
            if(a[k]<a[j])
            {
                k=j;
            }
            t=a[k];
            a[k]=a[i];
            a[i]=t;
        }
        j=a[1];
        k=a[10];

    }
    printf("\n降序排序后的数组元素是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

运行结果：

9.12 一维数组编程练习(9

题目：

定义一个大小为10的整形数组，使用初始化 方法为数组元素赋初值，编程计算这10个元素 的平均值，并查找比平均值大的数组元素。

提示：

（1）本题使用 2 组 for 循环，第一组 for 循环 打印数组元素的初值，并计算总和。第二组 for 循环求比平均值大的数。

（2）本题的变量定义可参考如下所示 int a[10]={3,6,1,7,8,4,9,5,10,2}, i, sum=0; double aver;

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={3,6,1,7,8,4,9,5,10,2}, i, sum=0;
    double aver;

    printf("数组中的初始值是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",a[i]);
        sum=sum+a[i];
    }
    aver = sum/10;
    printf("\n平均值是 = %lf",aver);

    printf("\n数组中比平均值大的数是:\n");
    for(i=0;i<10;i++)
    {
        if(a[i]>aver)
        {
           printf("%d ",a[i]);
        }
    }
    return 0;
}

运行结果：

10. 指针基础

10.1 指针与一维数组编程练习(1

题目：

使用指针操作一维数组，从键盘输入 10 个整数存到一维数组中，并对这 10 个数求和。（指针变量始终指向数组的首地址，使用指针法完成）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10],i,sum=0;
    int *p;
    printf("请输入10个数:\n");
    for(i=0;i<10;i++)
    {
        scanf("%d",a+i);
    }
    for(p=a;p<a+10;p++)
    {
        sum=sum+*p;
    }

    printf("\n10个数的总和:%d\n",sum);
    return 0;
}

运行结果：

10.2 指针与一维数组编程练习(2

题目：

使用指针操作一维数组，从键盘输入 10 个整数存到一维数组中，并求出 10 个数中 的最大值。（指针变量始终指向数组的首地址，使用下标法完成）

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 10
int main()
{
    int a[N],i,max=0;
    int *p;
    printf("请输入10个数:\n");
    for(i=0;i<N;i++)
    {
        scanf("%d",a+i);
    }
    for(p=a;p<a+N;p++)
    {
        if(*p>max)
        {
            max=*p;

        }
    }

    printf("10个数中最大值为:%d\n",max);
    return 0;
}

运行结果：

10.3 指针与一维数组编程练习(3

题目：

使用指针操作一维数组，从键盘输入 10 个整数存到一维数组中，并求出 10 个数中的最小值。（使用指针变量自增，不断指向下一个数组元素的存储空间完成。）

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 10
int main()
{
    int a[N],i,min=0;
    int *p;
    printf("请输入10个数:\n");
    for(i=0;i<N;i++)
    {
        scanf("%d",a+i);
    }
    for(p=a;p<a+N;p++)
    {
        if(*p<min)
        {
            min=*p;
        }
    }

    printf("10个数中最小值为:%d\n",min);
    return 0;
}

运行结果：

10.4 指针与二维数组编程练习(1

题目：

程序定义了一个 3 行 3 列的二维数组，从键盘输入各元素初值，编程求解数组中所有元素的和。（借助二维数组名本身访问数组元素，可以使用“下标法”和“指针 法”两种方法。）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[3][3],i,sum=0;
    int *p;
    printf("请输入二维数组初值:\n");
    p=&a[0][0];
    for(i=0;i<9;i++)
    {
        scanf("%d",p);
        sum = sum+*p;
        p++;
    }
    printf("数组中所有元素的和:%d\n",sum);
    return 0;
}

运行结果：

10.5 指针与二维数组编程练习(2

题目：

程序定义了一个 3 行 3 列的二维数组，从键盘输入各元素初值，编程求解数组中最大元素的值和所在的位置。（借助一个一级指针访问二维数组元素）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[3][3],i,j,row=0,colum=0,max=0;
    int (*p)[3]=a;
    printf("请输入二维数组初值:\n");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            scanf("%d",&*(*(p+i)+j));
        }
    }
    for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		{
			if(max==*(*(p+i)+j))
			{
				row=row;
				colum=colum;
			}else if(max<*(*(p+i)+j))
			{
				max=*(*(p+i)+j);
				row=i;
				colum=j;
			}
		}
	}
    printf("二维数组最大值:%d\n",max);
    printf("\n二维数组最大值所在位置:row=%d col=%d\n",row,colum);
    return 0;
}

运行结果：

10.6 指针与二维数组编程练习(3

题目：

定义一个 4 行 5 列的二维数组，使用二维数组分行 初始化的方法为数组元素赋初值，编程求该二维数组周 边元素之和。

提示：

（1）本题变量定义可参考如下

int a[4][5]={{1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15}, {16,17,18,19,20}};

int i, j, sum = 0;

（2）思考周边元素的行下标和列下标有何特点。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[4][5]={{1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15}, {16,17,18,19,20}};
    int i, j, sum = 0;
    printf("该4行5列的二维数组是:\n");
    for(i=0;i<4;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("%d\t",a[i][j]);
        }
        printf("\n");
    }
    for(i=0;i<4;i++)
    {
        for(j=0;j<5;j++)
        {
            if(i==0||i==4-1||j==0||j==5-1)
            {
                sum=sum+a[i][j];
            }
        }
    }
    printf("该二维数组周边元素之和 = %d:\n",sum);
    return 0;
}

运行结果：

10.7 指针与二维数组编程练习(4

题目：

定义一个 4 行 5 列的二维数组，使用二维数组分行 初始化的方法为数组元素赋初值，编程求二维数组中每 行的最大值，并将找到的所有最大值放到一个一维数组中。

提示：

（1） 本题变量定义可参考如下

int a[4][5]={{1,5,3,7,6},{12,15,18,14,17},{25,24,21,2 7,29},{37,32,36,31,35}};

int b[4], i, j, k=0, max;

数组 b 用来存放每行的最大值。变量 i、j 作为二维数组的下标，k 作为一 维数组的下标。max 变量可根据情况选用。

（2） 对于每行元素求最大值，首先默认该行的第一个元素最大，并将此默认 值放到 max 变量中，然后用该行的后续元素与 max 变量进行比较。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[4][5]={{1,5,3,7,6},{12,15,18,14,17},{25,24,21,27,29},{37,32,36,31,35}};
    int b[4], i, j;
    printf("二维数组元素的初值是:\n");
    for(i=0;i<4;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("%d\t",a[i][j]);
        }
        printf("\n");
    }

    for(i=0;i<4;i++)
    {
        b[i]=a[j][0];
        for(j=0;j<5;j++)
        {
            if(b[i]<a[i][j])
            {
                b[i]=a[i][j];
            }
        }
    }

    printf("每行的最大值分别是:\n");
    for (int i=0;i<4;i++)
		printf("%d\t", b[i]);
    return 0;
}

运行结果：

10.8 二维数组编程练习(3

题目：

定义一个 4 行 5 列的二维数组，将该二维数组按列转 换为一维数组。

提示：

（1）该题的变量可定义为

int a[4][5] = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20}};

int b[20], i, j, k=0;

其中 i、j 变量作为二维数组的下标，k 变量作为一维数组的下标。

（2）二维数组按列转换为一维数组，则外循环控制二维数组的列，内循环控制 二维数组的行

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[4][5] ={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20}};
    int b[20], i, j, k=0;
    printf("二维数组元素的初值是:\n");

    for(i=0;i<4;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("%d\t",a[i][j]);
        }
        printf("\n");
    }

    for(i=0;i<5;i++)
    {
        for(j=0;j<4;j++)
        {
            b[k]=a[j][i];
            k++;
        }
    }



    printf("按列转换后的一维数组是:\n");
    for(i=0;i<20;i++)
    {
        printf("%d ",b[i]);
    }
    return 0;
}

运行结果：

10.9 二维数组编程练习(4

题目：

二维数组也可以看作是矩阵，定义一个 3 行 3 列的二维数组， 并使用分行初始化方法为二维数组赋初值，编程实现矩阵的“转 置”（即行列互换）。

提示：

该题变量可定义为 int a[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}}, i, j, t;

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}}, i, j, t;
    printf("原始的二维数组是:\n");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("%d\t",a[i][j]);
        }
        printf("\n");
    }

    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            if(i<j)
            {
                t=a[i][j];
                a[i][j]=a[j][i];
                a[j][i]=t;
            }
        }
    }

    printf("转置后的二维数组是:\n");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("%d\t",a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

运行结果：

11. 指针提高篇

11.1 指针的动态存储分配编程练习(1

题目：

使用 malloc 申请 n 个整形数据的存储空间，从键盘输入 n 个整数存到该存储空间， 并对这 n 个数求和。（n 的值需要通过键盘输入确定）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,n,sum=0;
    int *p;
    printf("从键盘输入 n 个整数存到该存储空间:\n");
    scanf("%d",&n);
    p=(int*)malloc(sizeof(int)*n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&p[i]);
    }
    for(i=0;i<n;i++)
    {
        sum=sum+p[i];
    }
    printf("sum=%d",sum);
    return 0;
}

运行结果：

11.2 指针的动态存储分配编程练习(2

题目：

使用 calloc 申请 n 个整形数据的存储空间，从键盘输入 n 个整数存到该存储空间， 并求出这 n 个数中的最大值。（n 的值需要通过键盘输入确定）

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,n,max=0;
    int *p;
    printf("从键盘输入 n 个整数存到该存储空间:\n");
    scanf("%d",&n);
    p=(int*)calloc(n,sizeof(int));
    for(i=0;i<n;i++)
    {
        scanf("%d",&p[i]);
    }
    for(i=0;i<n;i++)
    {
        if(max<p[i])
        {
            max=p[i];
        }
    }
    printf("max=%d",max);
    return 0;
}

运行结果：

11.3 函数编程练习(1

题目：

编写程序求组合函数的值，输入 m 为 10，n 为 5.

源代码：

#include <stdio.h>
#include <stdlib.h>
int fun(int x);
int fun(int x)
{
    int i;
    int s = 1;
    for(i=1;i<=x;i++)
    {
        s =s*i;
    }
    return s;
}

int main()
{
    int m,n,t;
    printf("请输入m和n:\n");
    scanf("%d %d",&m,&n);
    t=fun(m) / ( fun(m-n) * fun(n) );
    printf("C(m,n)=%d\n",t);
    return 0;
}

运行结果：

11.4 函数编程练习(2

题目：

定义一个 fun 函数打印以下图形。

源代码：

#include <stdio.h>
#include <stdlib.h>
void fun()
{
    printf("*\n");
    printf("**\n");
    printf("***\n");
    printf("****\n");
}
int main()
{
    fun();
    return 0;
}

运行结果：

11.5 函数编程练习(3

题目：

给定两个整数，定义一个 fun 函数，其功能是选出这两个数中的较大值。（函数要求无参数，无返回值类型）

源代码：

#include <stdio.h>
#include <stdlib.h>
//无参 无返回值
void fun()
{
    int m,n,max;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    printf("max=%d",max);
}
int main()
{
    fun();
    return 0;
}

运行结果：

11.6 函数编程练习(4

题目：

给定两个整数，定义一个 fun 函数，其功能是选出这两个数中的较大值。（函数要求有参数，无返回值类型）

源代码：

#include <stdio.h>
#include <stdlib.h>
//有参 无返回值
void fun(int m,int n)
{
    int max;

    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    printf("max=%d",max);
}
int main()
{
    int m,n;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    fun(m,n);
    return 0;
}

运行结果：

11.7 函数编程练习(5

题目：

给定两个整数，定义一个 fun 函数，其功能是选出这两个数中的较大值。（函数要求无参数，有返回值类型）

源代码：

#include <stdio.h>
#include <stdlib.h>
//无参 有返回值
int fun()
{
    int m,n,max;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    return max;
}
int main()
{
    int max;
    max=fun();
    printf("max=%d",max);
    return 0;
}

运行结果：

11.8 函数编程练习(6

题目：

给定两个整数，定义一个 fun 函数，其功能是选出这两个数中的较大值。（函数要 求有参数，有返回值类型）

源代码：

#include <stdio.h>
#include <stdlib.h>
//有参 有返回值
int fun(int m,int n)
{
    int max;

    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    return max;
}
int main()
{
    int m,n,max;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    max=fun(m,n);
    printf("max=%d",max);
    return 0;
}

运行结果：

11.9 指针与普通变量编程练习(1

题目：

利用指针编程，其功能是求电阻的并联值和串联值。程序运行效果如图所示：

输入电阻值；计算并联串联值；打印结果都必须使用指针完成。

提示：

（1）该题的变量可定义为 int r1, r2, *p1, *p2; double rp, rs, *pp, *ps;

其中指针 p1、p2 用来指向并操作变量 r1、r2；

指针 pp、ps 用来指向并 操作变量 rp、rs。

（2）在利用指针编程之前，应将指针指向对应的变量

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int r1,r2,*p1,*p2;
    double rp,rs,*pp,*ps;
    printf("请输入2个电阻值:\n");
    scanf("%d,%d",&r1,&r2);
    p1=&r1;
    p2=&r2;

    rp=(double)(*p1 * *p2)/(double)(*p1 + *p2);
    rs=*p1 + *p2;

    pp=&rp;
    ps=&rs;

    printf("并联电阻值 = %lf\n",pp);
    printf("串联电阻值 = %lf\n",ps);

    return 0;
}

运行结果：

11.10 指针与普通变量编程练习(2

题目：

利用指针编程，其功能是利用“除号”和“求余号” 将输入的两个两位的正整数组合成一个新的四位的正整数。

输入整数值；计算；打印结果都必须使用指针完成。

提示：

该题的变量可定义为 int a, b, c, *pa, *pb, *pc;

其中指针pa、pb、pc分别用来指向并操作变量a、b、c。

变量a、b用来 存放输入的两个两位正整数，变量c用来存放组合后的四位的正整数。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a, b, c, *pa, *pb, *pc;

    printf("请输入两个两位的正整数:");
    scanf("%d %d",&a,&b);
    pa=&a;
    pb=&b;
    c=*pa/10*1000 + *pb/10*100 + *pa%10*10 + *pb%10;
    pc=&c;
    printf("组合成的四位的正整数是:%d",*pc);
    return 0;
}

运行结果：

11.11 指针与一维数组编程练习(1

题目：

定义一个大小为10的整型一维数组并初始化数组元素， 再定义一个指针变量让其指向该数组，利用指针编程查找 数组中的所有奇数。

使用“下标法”编程，即使用“p[i]”的形式引用数组元素。

提示：

（1） 该题变量可定义为 int a[10]={2,4,5,6,9,11,13,16,17,19}, *p, i;

（2）在使用指针编程之前，应先将指针 p 指向数组。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[10]={2,4,5,6,9,11,13,16,17,19}, *p, i;
    p=&a[i];
    p=a;

    printf("二维数组的初值是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d\t",p[i]);
    }
    printf("数组中的奇数是:\n");
    for(p=a,i=0;i<=9;i++)
    {
        for(i=0;i<=9;i++)
        {
            if(p[i]%2!=0)
            {
                printf("%d\t",p[i]);
            }
        }
    }

    return 0;
}

运行结果：

11.12 指针与一维数组编程练习(2

题目：

定义一个大小为 8 的整型一维数组并初始化所有数组元素， 利用指针编程对所有数组元素进行降序排序。

使用“地址法”编程，即使用“*(p + i)”的形式引用数组元素。

提示：

（1）本题变量定义可参考如下 int a[8]={4, 7, 2, 8, 1, 5, 3, 6}, *p, i, j, t; 其中 i、j 是循环变量，t 是交换相邻两数时使用的中间变量。

（2）本题使用冒泡法排序，参考教材。

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 8
int main()
{
    int a[8]={4, 7, 2, 8, 1, 5, 3, 6}, *p, i, j, t;
    p=&a[i];
    p=a;
    printf("二维数组的初值是:\n");
    for(i=0;i<N;i++)
    {
        printf("%d\t",p[i]);
    }


    for(i=0;i<N;i++)
    {
        for(j=0;j<N-1-i;j++)
        {
            if(*(p+j)<*(p+j+1))
            {
                t=p[j];
                p[j]=p[j+1];
                p[j+1]=t;
            }
        }
    }

    printf("\n降序排序后的结果是:\n");
    for(i=0;i<N;i++)
    {
        printf("%d\t",p[i]);
    }
    return 0;
}

运行结果：

11.13 指针与一维数组编程练习(3

题目：

定义一个大小为 10 的整型一维数组并初始化数组元素， 再定义一个指针变量让其指向该数组，利用指针求数组 10 个元素的平均值，并打印比平均值大的数。

提示：

本题变量定义可参考如下：

int a[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, *p, i, sum=0; double aver;

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 10
int main()
{
    int a[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, *p, i, sum=0;
    double aver;
    p=&a[i];
    p=a;
    printf("二维数组的初值是:\n");
    for(i=0;i<N;i++)
    {
        printf("%d\t",p[i]);
        sum=sum+p[i];
    }
    printf("\n");
    aver = 1.0*sum / N;
    printf("这10个元素的平均值是:%lf",aver);
    printf("\n");
    printf("\n比平均值大的数是:");
    for(i=0;i<N;i++)
    {
        if(p[i]>aver)
        {
            printf("%d\t",p[i]);
        }
    }
    return 0;
}

运行结果：

12. 函数

12.1 函数调用编程练习(1

题目：

在主函数中输入两个整数值，定义一个 fun 函数，其功能是选出这两个数中的较大值。（通过函数语句调用）

源代码：

#include <stdio.h>
#include <stdlib.h>
//在主函数中输入两个整数值，定义一个 fun 函数，
//其功能是选出这两个数中的较大值。
//（通过函数语句调用）
int fun(int m,int n)
{
    int max;

    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    printf("max=%d",max);
}

int main()
{
    int m,n;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    fun(m,n);
    return 0;
}

运行结果：

12.2 函数调用编程练习(2

题目：

在主函数中输入两个整数值，定义一个 fun 函数，其功能是选出这两个数中的较大值。（通过表达式调用）

源代码：

#include <stdio.h>
#include <stdlib.h>
//在主函数中输入两个整数值，定义一个 fun 函数，
//其功能是选出这两个数中的较大值。
//（通过表达式调用）
int fun(int m,int n)
{
    int max;

    if(m>n)
    {
        max=m;
    }
    else
    {
        max=n;
    }
    return max;
}
int main()
{
    int m,n,max;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    max=fun(m,n);
    printf("max=%d",max);
    return 0;
}

运行结果：

12.3 函数调用编程练习(3

题目：

在主函数中输入两个整数值，定义一个 fun 函数，其功能是选出这两个数中的较大值。（通过函数实参调用）

源代码：

#include <stdio.h>
#include <stdlib.h>
//在主函数中输入两个整数值，定义一个 fun 函数，
//其功能是选出这两个数中的较大值。
//（通过函数实参调用）
int fun(int m,int n)
{

    if(m>n)
    {
        return m;
    }
    else
    {
        return n;
    }
}
int main()
{
    int m,n;
    printf("请输入整数m和n:\n");
    scanf("%d %d",&m,&n);
    printf("max=%d",fun(m,n));
    return 0;
}

运行结果：

12.4 函数调用编程练习(4

题目：

测试代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void swap(int x, int y)
{
    int t=0;
    t = x;
    x = y;
    y = t;
    printf("x=%d, y=%d\n",x,y);
}

int main()
{
    int x = 10,y = 20;
    swap(x,y);

}

运行结果：

12.5 函数调用编程练习(5

题目：

测试代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void swap(int *p, int *q)
{
    int t;
    t = *p; *p = *q; *q = t;
}
int main( )
{
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x=%d, y=%d\n", x, y);
}

运行结果：

12.6 函数调用编程练习(6

题目：

测试代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void swap(int *p, int *q)
{
    int t;
    t = *p; *p = *q; *q = t;
}
int main( )
{
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x=%d, y=%d\n", x, y);
}

运行结果：

12.7 函数调用编程练习(7

题目：

输入一元二次方程的三个系数 a、b、c，求方程的实根。定义三个函数 fun1()、fun2()、 fun3() 分别处理方程有无实根、有两个相同实根、有两个不同实根的情况。

要求： 数据的输入、打印实根值都在 main 函数中完成。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//输入一元二次方程的三个系数 a、b、c，求方程的实根。定义三个函数 fun1()、fun2()、
//fun3() 分别处理方程有无实根、有两个相同实根、有两个不同实根的情况。
//要求：数据的输入、打印实根值都在 main 函数中完成。

void fun1();
void fun2(float,float,float);
void fun3(float,float);

void fun1()
{
       printf("No Root\n");

}

void fun2(float a,float b,float delta)
{
    float x1,x2;
    x1 = (-b-sqrt(delta)) / (2*a);
    x2 = (-b+sqrt(delta)) / (2*a);
    printf ("该方程有两解，x1 = %f,x2 = %f\n",x1,x2);

}

void fun3(float a,float b)
{
    float x1,x2;
    x1 = (-b) / (2*a);
    x2 = x1;
    printf ("该方程有唯一解，x1 = x2 = %f\n",x1 = x2);

}
int main()
{
    float a,b,c,delta;
    scanf("%f %f %f",&a,&b,&c);
    delta = b*b - 4*a*c ;

    if(delta > 0)
    {
        fun2(a,b,delta);
    }
    else if(delta == 0)
    {
        fun3(a,b);
    }
    else
    {
        fun1();
    }

    return 0;
}

运行结果：

12.8 指针与普通变量编程练习(1

题目：

利用指针编程，其功能是求电阻的并联值和串联值。程序运行效果如图所示：

输入电阻值；计算并联串联值；打印结果都必须使用指针完成。

提示：

（1）该题的变量可定义为 int r1, r2, *p1, *p2; double rp, rs, *pp, *ps;

其中指针 p1、p2 用来指向并操作变量 r1、r2；指针 pp、ps 用来指向并 操作变量 rp、rs。

（2）在利用指针编程之前，应将指针指向对应的变量。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int r1,r2,*p1,*p2;
    double rp,rs,*pp,*ps;
    printf("请输入2个电阻值:\n");
    scanf("%d,%d",&r1,&r2);
    p1=&r1;
    p2=&r2;

    rp=(double)(*p1 * *p2)/(double)(*p1 + *p2);
    rs=*p1 + *p2;

    pp=&rp;
    ps=&rs;

    printf("并联电阻值 = %lf\n",*pp);
    printf("串联电阻值 = %lf\n",*ps);

    return 0;
}

运行结果：

12.9 指针与普通变量编程练习(2

题目：

利用指针编程，其功能是利用“除号”和“求余号” 将输入的两个两位的正整数组合成一个新的四位的正整数。

输入整数值；计算；打印结果都必须使用指针完成。

提示：

该题的变量可定义为 int a, b, c, *pa, *pb, *pc;

其中指针pa、pb、pc分别用来指向并操作变量a、b、c。

变量a、b用来 存放输入的两个两位正整数，变量c用来存放组合后的四位的正整数。

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a, b, c, *pa, *pb, *pc;

    printf("请输入两个两位的正整数:");
    scanf("%d %d",&a,&b);
    pa=&a;
    pb=&b;
    c=*pa/10*1000 + *pb/10*100 + *pa%10*10 + *pb%10;
    pc=&c;
    printf("组合成的四位的正整数是:%d",*pc);
    return 0;
}

运行结果：

12.10 函数定义、函数调用编程练习(1

题目：

从键盘输入2个2位的正整数，定义一个子函数fun( )，其功能是按照以下格 式将输入的2个整数组装成一个4位的正整数。

例如：输入12和34，组装成的四 位数是1324。

（1）数据输入和结果打印都必须在main( )函数中完成。

（2）fun( )函数的功能是将2个2位的整数组装成1个4位的整数。

提示：

（1）使用“除号”和“求余号”分离整数的十位数、个位数。

（2）fun( )函数的函数首部可参考如下 int fun(int x, int y) //该函数有 2 个形参， 有返回值

源代码：

#include <stdio.h>
#include <stdlib.h>

#include <stdio.h>
#include <stdlib.h>

int fun(int x,int y)
{
    int z;
    z=x/10*1000 + y/10*100 + x%10*10 + y%10;
    return z;
}
int main()
{
    int x, y;

    printf("请输入两个两位的正整数:");
    scanf("%d %d",&x,&y);
    printf("组合成的四位的正整数是:%d",fun(x,y));
    return 0;
}

运行结果：

12.11 函数定义、函数调用编程练习(2

题目：

输入三角形的三条边长，定义一个子函数 fun( )求三角形的面积。

（1）数据输入和结果打印都必须在main( )函数中完成。

（2）fun( )函数的功能是求三角形的面积。

提示：

（1）计算三角形面积的公式是：

$s = \sqrt{x*(x - a)*(x - b)*(x - c)}其中 x = \frac{1}{2}*(a + b + c)$

计算 x 的开方值的库函数是 sqrt(x)，使用时需包含头文件 math.h

（2）fun( )函数的函数首部可参考如下 double fun(int a, int b, int c) //该函数有 3 个形参，返回值类型为 double

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//输入三角形的三条边长，定义一个子函数 fun( )求三角形的面积。

double fun(int a,int b,int c)
{
    double x,s;
    x = 0.5 * (a + b + c);
    s = sqrt(x*(x-a)*(x-b)*(x-c));
    return s;
}

int main()
{
    int a,b,c;
    printf("请输入三角形的三边:");
    scanf("%d %d %d",&a,&b,&c);
    printf("三角形面积 = %lf",fun(a,b,c));
    return 0;
}

运行结果：

12.12 函数定义、函数调用编程练习(3

题目：

定义一个子函数 fun( )打印菱形。

菱形的行数在main( )函数中输入，根据输入的行数决定菱形打印几行。

提示：

（1）fun( )函数的函数首部可参考如下 void fun(int x) //该函数有 1 个形参， 无返回值

（2）在 fun( )函数内部，首先根据形参 x 的值计算出正三角和倒三角的行数， 然后再执行循环的嵌套结构分别打印正三角和倒三角。

源代码：

#include <stdio.h>
#include <stdlib.h>

//定义一个子函数 fun( )打印菱形
void fun(int x)
{
    int i,j;
    for(i=1;i<=x;i++)
    {
        if(i<(x+1)/2+1)
        {  // 上
            for(j=1; j<=x; j++){
                if( (x+1)/2-(i-1)<=j && j<=(x+1)/2+(i-1) ){
                    printf("*");
                }else{
                    printf(" ");
                }
            }
        }
        else
        {  // 下
            for(j=1; j<=x; j++){
                if( (x+1)/2-(x-i)<=j && j<=(x+1)/2+(x-i) ){
                    printf("*");
                }else{
                    printf(" ");
                }
            }
        }
        printf("\n");
    }
}
int main()
{
    int x;
    printf("请输入菱形的行数(注意：行数为奇数):");
    scanf("%d",&x);
    if(x%2==0){  // 判断是否是奇数
        printf("必须输入奇数！\n");
    }
    fun(x);
    return 0;
}

运行结果：

12.13 函数定义、函数调用编程练习(4

题目：

定义一个子函数 fun( )，其功能是求 1 累加到 100 的和。

结果在子函数打印。

提示：

（1）fun( )函数写在前，main( )函数写在后。

（2）fun( )函数定义为无参、无返回值形式。

源代码：

#include <stdio.h>
#include <stdlib.h>
//定义一个子函数 fun( )，其功能是求 1 累加到 100 的和
void fun()
{
    int i,sum=0;
    for(i=0;i<101
    ;i++)
    {
        sum=sum+i;

    }
    printf("1+2+3+...+100 = %d\n",sum);
}
int main()
{
    fun();
    return 0;
}

运行结果：

12.14 函数定义、函数调用编程练习(5

题目：

定义一个子函数 fun( ) ，求表达式 的值。主函数定义如下所示，请完成 fun( )函数。

int main() 

{ 

int n; 

double sum; 

printf("请输入 n 值: "); 

scanf("%d", &n); sum = fun(n); //子函数调用语句 

printf("\n sum = %lf \n", sum); 

reutn 0; 

}

提示：

该题是一个 N 项式求和的问题，每一项的分母是前一项分母再乘以“i”

源代码：

#include <stdio.h>
#include <stdlib.h>

double fun(int n)
{
    int i;
    double a = 1,b,sum=1;
    for(i=1;i<=n;i++)
    {
        a=1.0*a * i;
        b=1.0*1/a;
        sum=sum+b;

    }
    return sum;
}

int main()
{
    int n;
    double sum;
    printf("请输入 n 值: ");
    scanf("%d", &n);
    sum = fun(n); //子函数调用语句
    printf("\n sum = %lf \n", sum);
    return 0;
}

运行结果：

12.15 函数定义、函数调用编程练习(6

题目：

定义一个子函数 fun( )求算术表达式的解。

运算符（+, -, *, /, %）和两个整数在主函数输入，结果也在主函数打印。

提示：

（1）主函数内先判断运算符的有效性，如果运算符有效，就调用 fun( ) 函数。如果运算符非法，就打印错误提示信息，不调用 fun( )函数。

（2）fun( )函数的函数首部可以参考如下

double fun(char fu, int a, int b)

其中形参 fu 代表运算符，形参 a、b 代表参与运算的两个数，函数返回类型为 double，表示函数的运行结果是实数。

源代码：

#include <stdio.h>
#include <stdlib.h>

double fun(char fu, int a, int b)
{
    double sum;
    if(fu=='+')
    {
        sum = a + b;
    }else if(fu=='-')
    {
        sum = a - b;
    }else if(fu=='*')
    {
        sum = a * b;
    }else if(fu=='/')
    {
        sum = a / b;
    }else
    {
        sum = a % b;
    }

    return sum;
}

int main()
{
    char fu;
    int a,b;
    printf("请输入一个运算符和两个整数:\n");
    scanf("%c,%d,%d",&fu,&a,&b);

    if(fu=='+'||fu=='-'||fu=='*'||fu=='/'||fu=='%')
    {
        printf("%d %c %d = %.2lf",a,fu,b,fun(fu,a,b));
    }
    else
    {
        printf("错误:运算符非法");
    }
    return 0;
}

运行结果：

13. 函数

13.1 参数的传值与传地址编程练习(1

题目：

测试以下代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void swap(int *c0, int *c1)
{
    int t;
    t=*c0; *c0=*c1; *c1=t;
}
int main()
{
    int b[2]={3, 5};
    swap(&b[0],&b[1]);
    printf("%d,%d\n", b[0],b[1]);
    return 0;
}

运行结果：

13.2 参数的传值与传地址编程练习(2

题目：

测试以下代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void reverse(int a[], int n)
{
    int i, t;
    for(i=0; i<n/2; i++)
    {
        t=a[i];
        a[i]=a[n-1-i];
        a[n-1-i]=t;
    }
}
int main()
{
    int b[10]={1,2,3,4,5,6,7,8,9,10};
    int i, s=0;
    reverse(b, 8);
    for(i=6; i<10; i++) s+=b[i];
    printf("%d\n", s);
    // print -> 22
    return 0;
}

运行结果：

13.3 参数的传值与传地址编程练习(3

题目：

测试以下代码

源代码：

#include <stdio.h>
#include <stdlib.h>

void sum(int *a)
{
    a[0] = a[1];
}

int main()
{
    int aa[10] = {1,2,3,4,5,6,7,8,9,10},i;
    for(i=2; i>=0; i--)
    {
        sum(&aa[i]);
    }
    printf("%d\n",aa[0]);
    return 0;
}

运行结果：

13.4 参数的传值与传地址编程练习(4

题目：

使用函数的嵌套调用，编写程序求以下 N 项式的和。

（1）数据输入和结果打印在主函数中完成。

(2）定义 fun1( )函数完成求和功能；

(3）定义 fun2( )函数求某数的 k 次方。

源代码：

#include <stdio.h>
#include <stdlib.h>
int fun1(int,int);
int fun2(int,int);

//使用函数的嵌套调用 编写程序求以下N项式的和
int fun1(int n,int k)
{
    int i,s=0;
    //完成求和功能
    for(i=1;i<=n;i++)
    {
        s += fun2(i,k);
    }
    return s;

}

int fun2(int n,int k)
{
    //求某数的 k 次方
    int i,s=1;
    for(i=0;i<k;i++)
    {
        s = s * n;
        return s;
    }

}
int main()
{
    int n,k;
    printf("请输入n和k:\n");
    scanf("%d,%d",&n,&k);
    printf("%d\n",fun1(n,k));
    return 0;
}

运行结果：

题目：

在主函数中输入一元二次方程 ax 2+bx+c=0 的三个系数 a、b、c，求方程的 实根。定义三个子函数 fun1( )、fun2( )、fun3( ) 分别处理方程有无实根、有 两个相同实根、有两个不同实根的情况。

（1）a、b、c 值需在主函数中输入；

（2）方程的根需在 main 函数中打印。

提示：

求方程实根的计算公式是

$x_1,_2 = \frac{-b\pm \sqrt{b^2-4ac}}{2a}$

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//输入一元二次方程的三个系数 a、b、c，求方程的实根。定义三个函数 fun1()、fun2()、
//fun3() 分别处理方程有无实根、有两个相同实根、有两个不同实根的情况。
//要求：数据的输入、打印实根值都在 main 函数中完成。

void fun1();
void fun2(float,float,float);
void fun3(float,float);

void fun1()
{
       printf("No Root\n");

}

void fun2(float a,float b,float delta)
{
    float x1,x2;
    x1 = (-b-sqrt(delta)) / (2*a);
    x2 = (-b+sqrt(delta)) / (2*a);
    printf ("该方程有两解，x1 = %f,x2 = %f\n",x1,x2);

}

void fun3(float a,float b)
{
    float x1,x2;
    x1 = (-b) / (2*a);
    x2 = x1;
    printf ("该方程有唯一解，x1 = x2 = %f\n",x1 = x2);

}
int main()
{
    float a,b,c,delta;
    scanf("%f %f %f",&a,&b,&c);
    delta = b*b - 4*a*c ;

    if(delta > 0)
    {
        fun2(a,b,delta);
    }
    else if(delta == 0)
    {
        fun3(a,b);
    }
    else
    {
        fun1();
    }

    return 0;
}

运行结果：

13.6 参数的传值与传地址编程练习(6

题目：

在主函数中定义一个大小为 10 的整型数组，并对数组元 素进行初始化，定义一个 fun( )函数，其功能是求数组中 10 个数的总和、最大值、最小值。

（1）总和、最大值、最小值都在主函数打印。

（2）总和由 return 语句返回；最大值、最小值由参数返回。

提示：

（1）主函数中的变量定义可参考如下

int a[10]={3,8,1,5,2,9,6,10,7,4}, sum, max, min, i;

（2）fun( )函数有参数、有返回值。函数首部可参考如下

int fun(int *p, int *pmax, int *pmin)

其中指针 p 指向数组 a，指针 pmax 和 pmin 分别指向变量 max 和 min。

源代码：

#include <stdio.h>
#include <stdlib.h>
//在主函数中定义一个大小为10的整型数组 并对数组元
//素进行初始化 定义一个 fun()函数 其功能是求数组中S
//10个数的总和 最大值 最小值


int fun(int *p, int *pmax, int *pmin)
{
    int i,sum = 0;
    *pmax = p[0];
    *pmin = p[0];
    for(i=0;i<10;i++)
    {
        if(*pmax < p[i])
        {
            *pmax = p[i];
        }
        if(*pmin > p[i])
        {
            *pmin = p[i];
        }
        sum = sum + p[i];
    }
    return sum;
}
int main()
{
    int a[10]={3,8,1,5,2,9,6,10,7,4},sum,max,min,i;

    printf("原始数组是:\n");
    for(i=0;i<10;i++)
    {
        printf("%d\t",a[i]);
    }
    printf("\n");
    sum = fun(a,&max,&min);
    printf("sum=%d, max=%d, min=%d",sum,max,min);
    return 0;
}

运行结果：

13.7 参数的传值与传地址编程练习(7

题目：

定义一个 fun( )函数，其功能是：查找 1 到 50 之间能被 7 或 11 整除的所有 整数，将找到的这些数放到主函数中的数组 a 中；并统计找到的数的个数，通 过形参返回统计的个数值。

主函数已给出，请不要修改主函数。

#include <stdio.h>
void main( )
{
	int a[50], n, i;
    fun ( a, &n ); //函数调用
    printf("1 到 50 之间能被 7 或 11
    整除的数是:\n");
    for (i = 0; i < n; i++ )
    printf("%d ", a[i] );
    printf("\n\n") ;
}

提示：

（1）fun( )函数有 2 个参数，第一个实参是数组 名 a；第二个实参是变量 n 的地址。

fun( )函数首部可参考如下：void fun(int *p, int *n)

（2）fun( )函数中的变量定义可参考如下：

int i, j=0; 其中变量 i 控制循环范围介于 1 至 50 之间，变量 j 作为数组 的下标。 4、定义一个 f

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
//定义一个 fun()函数，其功能是：查找1到50之间能被7或11整除的所有
//整数，将找到的这些数放到主函数中的数组a中；并统计找到的数的个数
//通过形参返回统计的个数值

void fun(int *p, int *n)
{
    int i,j=0;
    for(i=1;i<50;i++)
    {
        if(i%7==0||i%11==0)
        {
            p[j]=i;
            j++;
        }
        *n=j;
    }
}

void main()
{
    int a[50], n, i;
    fun ( a, &n ); //函数调用
    printf("1 到 50 之间能被 7 或 11整除的数是:\n");
    for (i = 0; i < n; i++ )
        printf("%d ", a[i] );
    printf("\n\n") ;
}

运行结果：

13.8 参数的传值与传地址编程练习(8

题目：

定义一个 fun( )函数，其功能是：将数组 a 中的 10 个分数值按照由高到低排 序，并计算平均分，通过形参指针 n 返回平均分。

主函数已给出，请不要修改主函数。

#include <stdio.h>
void main( )
{
	int a[10]={70,60,80,75,90,88,95,75,85,69}, i;
	double aver;
	printf("10 个分数值是: ");
	for(i=0; i<10; i++)
{
	printf("%d ", a[i] );
}
	fun ( a, &aver ); //函数调用
	printf("\n\n 分数降序排序: ");
	for(i=0; i<10; i++)
{
	printf("%d ", a[i] );
}
	printf("\n\n 平均分：%lf\n", aver);
}

提示：

（1）fun( )函数有 2 个参数，第一个实参是 数组名 a；第二个参数是变量 aver 的地址。 fun( )函数首部可参考如下：

void fun(int *p, double *aver)

（2）fun( )函数内需完成两个功能：其一是使用选择法对数组元素进行降序排 序；其二是计算平均分。

源代码：

#include <stdio.h>
#include <stdlib.h>

//定义一个 fun( )函数，其功能是：
//将数组a中的10个分数值按照由高到低排序
//并计算平均分，通过形参指针n返回平均分。


void fun(int *p, double *aver)
{
    int i,j,t,sum=0;
    for(i=0;i<10;i++)
    {
        for(j=0;j<9-i;j++)
        {
            if(p[j]<p[j+1])
            {
                t=p[j+1];
                p[j+1]=p[j];
                p[j]=t;
            }
        }
    }
    for(i=0;i<10;i++)
    {
        sum += p[i];
    }
    *aver = sum / 10;
}

void main()
{
    int a[10]={70,60,80,75,90,88,95,75,85,69}, i;
    double aver;
    printf("10 个分数值是: ");
    for(i=0; i<10; i++)
    {
        printf("%d ", a[i] );
    }

    fun(a,&aver); //函数调用

    printf("\n\n 分数降序排序: ");
    for(i=0; i<10; i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n\n 平均分：%lf\n",aver);
}

运行结果：

13.9 提升编程(1

题目：

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

1.程序分析:

在 10 万以内判断，先将该数加上 100 后再开方，再将该数加上 268 后再开方，如果开方后的结果满足如下条件，即是结果。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//题目:一个整数，它加上100后是一个完全平方数，再加上 168又是一个完全平方数，请问该数是多少?
//1.程序分析:在10万以内判断，先将该数加上 100后P开方，再将该数加上268后再开方，如果开方后的结果法足如下条件，即是结果。
int main()
{
    int i;
    for(i=0;i<1000000;i++)
    {
        if( (int)sqrt(i+100)*(int)sqrt(i+100)== i+100)
        {
            if((int)sqrt(i+100+268)*(int)sqrt(i+100+268)==i+100+268)
            {
                printf("%d ",i);
            }
        }

    }

    return 0;
}

运行结果：

13.10 提升编程(2

题目：

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

1.程序分析:

以 3 月 5 日为例，应该先把前两个月的加起来，然后再加上 5 天即本年的第几天，特殊情况，闰年且输入月份大于 3 时需考虑多加一天

源代码：

#include <stdio.h>
#include <stdlib.h>
//输入某年某月某日，判断这一天是这一年的第几天?
//1.程序分析:以3月5日为例，应该先把前两个月的加起来，
//然后再加上5天即本年的第几天，特殊情况，
//闰年且输入月份大于3时需考虑多加一天。

int main()
{
    int year,month,day,result=0;
    printf("请输入年月日:\n");
    scanf("%d %d %d",&year,&month,&day);
    switch(month)
	{
		case 12:  result+=30;      //加上11月的30天
		case 11:  result+=31;      //加上10月的31天
		case 10:  result+=30;      //加上 9月的30天
		case  9:  result+=31;
		case  8:  result+=31;
		case  7:  result+=30;
		case  6:  result+=31;
		case  5:  result+=30;
		case  4:  result+=31;
		case  3:  result+=28;      //加上2月的28天
		case  2:  result+=31;      //加上1月的31天
		case  1:  result+=day;     //加上当月天数
	}

    if((year%4==0 && year%100!=0 || year%400==0) && month>=3)
         {
             result++;
         }

	printf("是%d的第%d天\n",year,result);
	return 0;
}

运行结果：

13.11 提升编程(3

题目：

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

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 20
//有一分数序列2/1 , 3/2 , 5/3 , 13/8 , 21/13 ......，求其前20项和
int main()
{
    float x1=1.0,x2=2.0,sum=0,t;
    int i;
    for(i=0;i<N;i++)
    {
        sum = sum + x2/x1;
        t=x2;
        x2=x2+x1;
        x1=t;
    }
    printf("sum=%lf",sum);
    return 0;
}

运行结果：

13.12 提升编程(4

题目：

一个数如果恰好等于它的因子之和，这个数就称为“完数”。

例如 6=1+2+3.编程找出 1000 以内的所有完数。

源代码：

#include <stdio.h>
#include <stdlib.h>
//找出1000以内的完数

int main()
{
    printf("1000以内的完数:\n");
	for(int i = 2;i <= 1000;i++)
	{
		int sum = 0;
		for(int j = 1;j <= i/2;j++)
		if(i%j == 0)
        {
            sum += j;
        }
		if(sum == i)
        {
            printf("%d\n",sum);
        }
	}
    return 0;
}

运行结果：

14. 字符串

14.1 字符串编程练习(1

题目：

从键盘输入一个字符串，统计字符的个数。（不能使用 strlen 函数）

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘输入一个字符串 统计字符的个数（不能使用strlen函数）
int main()
{
    char s[50];
    int i = 0;
    printf("键盘输入一个字符串:\n");
    gets(s);
    while(s[i] !='\0')
    {
        i++;
    }
    printf("字符串的个数是:%d",i);
    return 0;
}

运行结果：

14.2 字符串编程练习(2

题目：

从键盘输入一个字符串，将字符串中所有的小写字母全部转换为大写字母。

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘输入一个字符串 将字符串中所有的小写字母全部转换为大写字母。
int main()
{
    char s[50];
    int i = 0;
    printf("键盘输入一个字符串:\n");
    gets(s);
    while(s[i] !='\0')
    {
        if(s[i]>=97 && s[i]<=122)
        {
            s[i]=s[i]-32;
        }
        i++;
    }
    printf("字符串小写字母转大写字母:\n");
    puts(s);
    return 0;
}

运行结果：

14.3 字符串编程练习(3

题目：

测试以下代码

源代码：

#include <stdio.h>
#include <string.h>
void main( )
{
    int len;
    //遇'\0'结束计算长度
    char s[20] = {"hello\0abc\0abc\0"};
    len = strlen(s);
    printf("字符串长度: %d\n", len);
}

运行结果：

14.4 字符串编程练习(4

题目：

测试以下代码

源代码：

#include <stdio.h>
#include <string.h>
void main( )
{
    char s[20]="Hello";
    int a, b, c, d;
    a = strlen(s);
    b = sizeof(s);
    c = strlen("Hello");
    d = sizeof("Hello");
    printf("a=%d,b=%d,c=%d,d=%d.\n", a,b,c,d);
    //a=5,b=20,c=5,d=6.
}

运行结果：

14.5 字符串与数组编程练习(1

题目：

从键盘输入一个字符串，将字符串中的小写字 母全部转换为大写字母，其它字符保持不变。并统 计该字符串的长度。

字符串的输入/输出使用 scanf( )、printf( ) 函数。

提示：

本题的变量可定义为 char a[50]; int i=0;

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘输入一个字符串 将字符串中的小写字
//母全部转换为大写字母 其它字符保持不变
//并统计该字符串的长度
int main()
{
    char a[50];
    int i = 0;
    printf("请输入一个字符串:\n");
    scanf("%s",a);
    while(a[i] !='\0')
    {
        if(a[i]>=97 && a[i]<=122)
        {
            a[i]=a[i]-32;
        }
        i++;
    }

    printf("\n转换后的字符串是:\n");
    printf("%s\n",a);
    printf("\n字符串长度是:%d",i);
    return 0;
}

运行结果：

14.6 字符串与数组编程练习(2

题目：

从键盘上输入一个由大写字母、小写字母、数字字符、其 它字符构成的字符串，统计字符串中的大写字母个数、小写字 母个数、数字字符个数、其它字符个数。

字符串的输入/输出使用 gets( )、puts( )函数。

提示：

本题的变量可定义为

char a[50];

int i=0, da=0, xiao=0, shu=0, qi=0;

其中数组 a 用来存放字符串；变量 i 作循环变量，同时作为数组元素的下标； 变量 da、xiao、shu、qi 分别用来统计大写字母、小写字母、数字字符、其它字 符的个数。

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘上输入一个由大写字母、小写字母、数字字符、其
//它字符构成的字符串，统计字符串中的大写字母个数、小写字
//母个数、数字字符个数、其它字符个数。
int main()
{
    char a[50];
    int i=0, da=0, xiao=0, shu=0, qi=0;
    printf("请输入一个字符串:\n");
    gets(a);
    while(a[i] !='\0')
    {
        if(a[i]>=65 && a[i]<=90)
        {
            da++;
        }
        else if(a[i]>=97 && a[i]<=122)
        {
            xiao++;
        }
        else if(a[i]>=48 && a[i]<=57)
        {
            shu++;
        }
        else
        {
            qi++;
        }
        i++;
    }
    //kalj++ADG**78668##
    printf("\n大写字母的个数是:%d\n",da);
    printf("\n小写字母的个数是:%d\n",xiao);
    printf("\n数字字符的个数是:%d\n",shu);
    printf("\n其他字符的个数是:%d\n",qi);
    return 0;
}

运行结果：

14.7 字符串与数组编程练习(3

题目：

从键盘输入两个字符串，分别存到字符数组 a 和字 符数组 b 中，编程将第二个字符串连接到第一个字符 串末尾，形成一个新字符串。

提示：

（1）本题的变量可定义为

char a[50], b[20]; int i=0, j=0, len=0;

（2）该连接过程实际上是将第二个字符串中的字符依次复制到第一个字符串的 后面。首先应统计出第一个字符串的长度，因为第二个字符串的首字母应复制 到第一个字符串中 ‘\0’ 所在的位置。

（3）注意新字符串末尾的结束标志 '\0' 必须手动添加。

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘输入两个字符串 分别存到字符数组 a 和字
//符数组 b 中 编程将第二个字符串连接到第一个字符
//串末尾 形成一个新字符串
int main()
{
    char a[50], b[20];
    int i=0, j=0;
    printf("请输入第1个字符串:");
    gets(a);
    printf("\n请输入第2个字符串:");
    gets(b);
    while(a[i] !='\0')
    {
        i++;
    }
    while(b[j] !='\0')
    {
        a[i++]=b[j++];
    }
    a[i]='\0';
    printf("\n连接后的字符串是:");
    puts(a);
    return 0;
}

运行结果：

14.8 字符串与数组编程练习(4

题目：

从键盘输入一个字符串，删除字符串中所有下标为奇数的 字符，将下标为偶数的字符复制到另外一个字符数组 b 中， 并打印保留后的字符串。

提示：

（1）字符串输入、输出的库函数是 gets( )、puts( )。

（2）本题的变量可定义为 char a[20], b[20]; int i=0, j=0;

其中，数组 a、b 分别用来存放初始字符串和处理后的字符串；i、j 分别作 为两个数组的下标。

注意：字符串中的下标是 i 变量，字符是 a[i]。

源代码：

#include <stdio.h>
#include <stdlib.h>
//从键盘输入一个字符串，删除字符串中所有下标为奇数的
//字符，将下标为偶数的字符复制到另外一个字符数组 b 中，
//并打印保留后的字符串。
int main()
{
    char a[20], b[20];
    int i=0,j=0;
    printf("请输入第1个字符串:");
    gets(a);
    while(a[i] != '\0')
    {
        if(i % 2 ==0)
        {
            b[j]=a[i];
            j++;
        }
        i++;

    }
    printf("保留后的字符串是:\n");
    puts(b);
    return 0;
}

运行结果：

14.9 字符串与数组编程练习(5

题目：

从键盘输入一个由小写字母构成的字符串，将字符 串中的所有小写字母按照升序排序。

提示：

（1）本题的变量可定义为

char a[10], t; int i, j, len;

其中，数组 a 用来存放字符串；t 是冒泡排序代码 中交换前后两个字符时使用的中间变量；i、j 是循环变量；len 保存字符串 的长度。

（2）在进行冒泡排序之前，应先计算出数组长度，这样才能知道有多少个字母 需要排序。计算字符串的长度可以调用库函数 strlen( )，头文件是 string.h。

举例：char a[10]="abcxyz"; int len; len = strlen(a); //该语句的功能是计算数组 a 中字符串的长度并赋值给 len

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//从键盘输入一个由小写字母构成的字符串，将字符
//串中的所有小写字母按照升序排序。
int main()
{
    char a[10],t;
    int i,j,len;
    printf("请输入1个由小写字母构成的字符串:\n");
    gets(a);
    len = strlen(a);
    for(i=0;i<len;i++)
    {
        for(j=0;j<len-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }

    printf("字母按升序排序后的字符串是:\n");
    puts(a);
    return 0;
}

运行结果：

14.10 字符串与指针编程练习(1

题目：

规 定 字 符 串 中 只 包 含 字 母 和 * 号 ， 例 如 字 符 串 中 的 内 容 为 ：

ABCDEFG*，定义一个子函数 fun( )，它的功能是：统计前面和后 面星号的个数。

主函数已给出，请不要修改主函数。

#include <stdio.h>
void main( )
{
    char a[80] = "*******A*BC*DEF*G*****";
    int qian = 0, hou = 0;
    printf("原始字符串是: \n");
    puts(a);
    fun (a, &qian, &hou); //3 个实参都是传地
    址
    printf("\n 前面*号的个数是: %d\n", qian);
    printf("\n 后面*号的个数是: %d\n", hou);
}

提示：

（1） fun( )函数首部可以参考如下

void fun(char *p, int *qian, int *hou)

（2）在 fun( )函数内可以定义 2 个 char 型的指针 p1、p2，将 p1 指向最前面一 个星号，利用 p1 统计前面星号的个数；将 p2 指向最后面的一个星号，利用 p2 统计后面星号的个数。

源代码：

#include <stdio.h>
#include <string.h>
//规 定 字 符 串 中 只 包 含 字 母 和 * 号 ，
//例 如 字 符 串 中 的 内 容 为 ：
//*******A*BC*DEF*G*****，定义一个子函数 fun( )，
//它的功能是：统计前面和后面星号的个数

void fun(char *p, int *qian, int *hou)
{
    int len,i=0,j=0;
    len = strlen(p);
    while(p[len-1]=='*')
    {
        len--;
        j++;
    }
    while(p[i]=='*')
    {
        i++;
    }

    *qian=i;
    *hou=j;

}
void main()
{
    char a[80] = "*******A*BC*DEF*G*****";
    int qian = 0, hou = 0;
    printf("原始字符串是: \n");
    puts(a);
    fun (a, &qian, &hou); //3 个实参都是传地址
    printf("\n 前面*号的个数是: %d\n", qian);
    printf("\n 后面*号的个数是: %d\n", hou);
}

运行结果：

14.11 字符串与指针编程练习(2

题目：

规定字符串中只包含字母和号，

例如字符 串中的内容为：ABCDEFG，

定 义一个子函数 fun( )，它的功能是：将字符串 中前面和后面的号全部删除，中间的号不删除，处理后的字符串是：ABCDEF*G。

主函数已给出，请不要修改主函数。

#include <stdio.h>
void main( )
{
char a[80] = "*******A*BC*DEF*G*****";
printf("原始字符串是: \n ");
puts(a);
fun ( a ); //数组名作实参，传地址
printf("\n\n 处理后的字符串是: \n ");
puts(a);
}

提示：

（1） fun( )函数首部可以参考如下

void fun(char *p)

（2） 在 fun( )函数内可以定义 2 个 char 型的 指针 p1、p2，分别将 p1、p2 指向首尾 两个字母。

（3） 本题可以使用字符串处理函数 strlen( )、 strcpy( )等，注意包含头文件 string.h。

源代码：

#include <stdio.h>
#include <string.h>
//规 定 字 符 串 中 只 包 含 字 母 和 * 号 ，
//例 如 字 符 串 中 的 内 容 为 ：
//*******A*BC*DEF*G*****，定义一个子函数 fun( )，
//它的功能是：统计前面和后面星号的个数

void fun(char *p, int *qian, int *hou)
{
    int len,i=0,j=0;
    len = strlen(p);
    while(p[len-1]=='*')
    {
        len--;
        j++;
    }
    while(p[i]=='*')
    {
        i++;
    }

    *qian=i;
    *hou=j;

}
void main()
{
    char a[80] = "*******A*BC*DEF*G*****";
    int qian = 0, hou = 0;
    printf("原始字符串是: \n");
    puts(a);
    fun (a, &qian, &hou); //3 个实参都是传地址
    printf("\n 前面*号的个数是: %d\n", qian);
    printf("\n 后面*号的个数是: %d\n", hou);
}

运行结果：

14.12 字符串与指针编程练习(3

题目：

从键盘上输入一个字符串，该字符串的字符全部由小写字母组成，统计每一 个小写字母出现的次数。

提示：

（1）该题的变量定义可参考如下

char a[50];

int b[26]={0}, len, i, j;

其中，数组 a 用来存放输入的字符串；数组 b 是 int 型的，用来存放每个 字母出现的次数。len 用来存放字符串的长度值。i 是循环变量，j 作为数 组 b 的下标。

（2） 本题需完成的主要工作是，将字母 'a'、'b'、'c'，……，'z' 出现的次数分 别放在 b[0]、b[1]、b[2]、……、b[25]中。其规律是，每个字母与数组元 素b[j]的下标有一一对应的关系，即字母 'a' 对应的下标j=0，字母 'b' 对 应的下标 j=1，……，字母 'z' 对应的下标 j=25。每出现一个字母，其对 应的 b[j]就自增 1。

源代码：

#include <stdio.h>
#include <string.h>
//从键盘上输入一个字符串，该字符串的字符全部由小写字母组成，
//统计每一个小写字母出现的次数
int main()
{
    char a[50];
    int b[26]={0}, len, i, j;
    printf("请输入一个由小写字母组成的字符串: \n ");
    gets(a);
    len = strlen(a);
    for(i=0;i<=len;i++)
    {
        if(a[i]>=97 && a[i]<=122)
        {
            b[a[i]-97]++;
        }
    }
    printf("每个小写字母出现的次数是:\n");
    for(j=0;j<26;j++)
    {
        printf("%c -- %d 次\t",97+j,b[j]);
    }
    return 0;
}

运行结果：

14.13 字符串处理函数编程练习(1

题目：

定义 3 个字符数组 a、b、c，为 3 个数组分别初始化 3 个 字符串"abc"、"defg"、"hijklmn"，将这 3 个字符串连接在 一起形成一个新字符串，并且将新字符串放在数组 a 中。

提示：

该题可使用字符串连接函数 strcat( )，并且应包含头 文件 string.h。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义 3 个字符数组 a、b、c，为 3 个数组分别初始化 3 个
//字符串"abc"、"defg"、"hijklmn"，将这 3 个字符串连接在
//一起形成一个新字符串，并且将新字符串放在数组 a 中
int main()
{
    char a[50],b[50],c[50];
    printf("初始的3个字符串是:\n");
    gets(a);
    gets(b);
    gets(c);
    strcat(a,b);
    strcat(a,c);
    printf("连接后的新字符串是:%s\n",a);
    return 0;
}

运行结果：

14.14 字符串处理函数编程练习(2

题目：

定义 3 个字符数组 a、b、c，从键盘为 3 个数组分别 输入 1 个字符串，对 3 个字符串进行 ASCII 码值的大小比 较，按照 ASCII 码值由小到大依次重新放到数组 a、b、c 中。

提示：

（1） 该题可使用字符串比较函数 strcmp( )，字符串拷贝函数 strcpy( )。

（2） 注意：该题不能使用冒泡法或者选择法对 3 个字符串进行由小到大排序， 只能使用 3 个单分支 if 语句分别进行两两比较。

（3） 本题变量定义可参考如下 char a[20], b[20], c[20], t[20];

其中数组 a、b、c 分别用来存放输入的 3 个字符串，数组 t 作为两个字 符串交换时的暂存数组。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义 3 个字符数组 a、b、c，从键盘为 3 个数组分别
//输入 1 个字符串，对 3 个字符串进行 ASCII 码值的大小比
//较，按照 ASCII 码值由小到大依次重新放到数组 a、b、c中。
int main()
{
    char a[20],b[20],c[20],t[20];
    printf("请输入3个字符串是:\n");
    gets(a);
    gets(b);
    gets(c);
    if(strcmp(a,b)>=0)
    {
        strcpy(t,a);
        strcpy(a,b);
        strcpy(b,t);
    }
    if(strcmp(a,c)>=0)
    {
        strcpy(t,a);
        strcpy(a,c);
        strcpy(c,t);
    }
    if(strcmp(b,c)>=0)
    {
        strcpy(t,b);
        strcpy(b,c);
        strcpy(c,t);
    }
    printf("按ASCII码由小到大排序后的字符串是:\n%s\n%s\n%s\n",a,b,c);
    return 0;
}

运行结果：

15. 结构体和共同体

15.1 结构体的编程练习(1

题目：

定义结构体如下：

typedef struct stu
{ 
    char name[30];
    char sex;
    int age;
    double score;
}STU;

在 main 函数中通过定义结构图变量

x STU x = {“LiPin”, ‘M’, 19, 80};

在 main 函数中输出 x 的所有成员信息。

源代码：

#include <stdio.h>
#include <stdlib.h>
//在 main 函数中输出 x 的所有成员信息
typedef struct stu
{
    char name[30];
    char sex;
    int age;
    double score;
}STU;


int main()
{
    STU x = {"NSY",'M',20,80};
    printf("name=%s sex=%c age=%d score=%lf",x.name,x.sex,x.age,x.score);
    return 0;
}

运行结果：

15.2 结构体的编程练习(2

题目：

定义结构体如下：

typedef struct stu
{ 	
    char name[30];
    char sex;
    int age;
    double score;
}STU;

在 main 函数中通过定义结构图变量 x

STU x ;

在 main 函数中通过“结构体变量名. 成员名”的形式给 x 的成员赋值，并输出 x 的所有成员信息。

源代码：

#include <stdio.h>
#include <stdlib.h>
//在 main 函数中通过 结构体变量名
//成员名的形式给 x 的成员赋值，并输出 x 的所有成员信息
typedef struct stu
{
    char name[30];
    char sex;
    int age;
    double score;
}STU;
int main()
{
    STU x;
    printf("请为成员赋值:\n");
    gets(x.name);
    scanf("%c,%d,%lf",&x.sex,&x.age,&x.score);
    printf("输出成员信息:\n");
    printf("name=%s sex=%c age=%d score=%lf",x.name,x.sex,x.age,x.score);

    return 0;
}

运行结果：

15.3 结构体的编程练习(3

题目：

定义结构体如下：

typedef struct stu
{ 
    char name[30];
    char sex;
    int age;
    double score;
}STU;

在 main 函数中通过定义结构图变量 x

STU x, *p=&x ;

在 main 函数中通过“结构体指针变量名->成员名”的形式给 x 的成员赋值，并输出 x 的 所有成员信息。

源代码：

#include <stdio.h>
#include <stdlib.h>
//在 main 函数中通过“结构体指针变量名->成员名”的形式给 x 的成员赋值，并输出 x 的所有成员信息
typedef struct stu
{
    char name[30];
    char sex;
    int age;
    double score;
}STU;
int main()
{
    STU x, *p=&x;
    printf("请为成员赋值:\n");
    gets(p->name);
    scanf("%c,%d,%lf",&p->sex,&p->age,&p->score);
    printf("输出成员信息:\n");
    printf("name=%s sex=%c age=%d score=%lf",x.name,x.sex,x.age,x.score);

    return 0;
}

运行结果：

15.4 结构体的编程练习(4

题目：

定义结构体如下：

typedef struct stu
{ 
    char name[30];
    char sex;
    int age;
    double score;
}STU;

在 main 函数中通过定义结构图变量 x

STU x, *p=&x ;

在 main 函数中通过“（*结构体指针变量名）.成员名”的形式给 x 的成员赋值，并输出 x 的所有成员信息。

源代码：

#include <stdio.h>
#include <stdlib.h>

//在 main 函数中通过“（*结构体指针变量名）.成员名”的形式给 x 的成员赋值，并输出 x的所有成员信息
typedef struct stu
{
    char name[30];
    char sex;
    int age;
    double score;
}STU;
int main()
{
    STU x, *p=&x;
    printf("请为成员赋值:\n");
    gets((*p).name);
    scanf("%c,%d,%lf",&(*p).sex,&(*p).age,&(*p).score);
    printf("输出成员信息:\n");
    printf("name=%s sex=%c age=%d score=%lf",x.name,x.sex,x.age,x.score);

    return 0;
}

运行结果：

5.5 结构体的编程练习(5

题目：

定义一个大小为 4 的结构体数组，存放 4 名学生的信息，查找这 4 名学生中的最高分，并打印该同学的所有信息。

源代码：

#include <stdio.h>
#include <stdlib.h>
//定义一个大小为 4 的结构体数组
//存放 4 名学生的信息
//查找这 4 名学生中的最高分
//并打印该同学的所有信息
typedef struct stu
{
    char name[30];
    char sex;
    int age;
    double score;
}STU;
int main()
{
    STU x[4] = {{"LiPin",'M',18,80},
             {"LinYi",'M',19,85},
             {"SunDan",'W',18,90},
             {"WuLi",'W',18,70}};
    int i,index=0,scoremax=0;
    for(i=0;i<4;i++)
    {
        if(x[i].score>scoremax)
        {
            scoremax=x[i].score;
            index=i;
        }
    }
    printf("最高分同学的所有信息:\n");
    printf("name=%s sex=%c age=%d score=%lf",x[index].name,x[index].sex,x[index].age,x[index].score);

    return 0;
}

运行结果：

15.6 字符串数组编程练习(1

题目：

定义 1 个二维的字符数组 a，它可以存放 3 个字符串，从键盘输入 3 个字符串存放到数组 a 中，编程将这 3 个字符串连接成一个字符串。

提示：

（1） 字符串的连接使用库函数 strcat( )，注 意需包含头文件 string.h。

（2） 本题变量定义可参考如下：

char a[3] [20];

char b[60]="\0"; //为数组 b 初始化一个空串 int i; 其中，二维数组 a 用来存放键盘输入的 3 个字符串；一维数组 b 用 来存放连接后的新字符串； 思考：以上变量定义时将数组 b 初始化成一个空串，请问，如果没有对数 组 b 进行初始化，运行结果会如何？

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义 1 个二维的字符数组 a，它可以存放 3 个字符串，从键盘输入 3
//个字符串存放到数组 a 中，编程将这 3 个字符串连接成一个字符串

int main()
{
    char a[3][20];
    char b[60]="\0"; //为数组 b 初始化一个空串
    int i;

    printf("请输入3个字符串:\n");
    gets(a[0]);
    gets(a[1]);
    gets(a[2]);
    for(i=0;i<3;i++)
    {
        strcat(b,a[i]);
    }
    printf("将以上3个字符串连接成的新字符串是:\n");
    puts(b);
    return 0;
}

运行结果：

15.6 字符串数组编程练习(2

题目：

定义 1 个二维的字符数组 a，并为其初始化 5 个姓名字符串，编程对 5 个姓名字符串按 ASCII 码值的大小进行升序排序。

提示：

（1） 对字符串进行 ASCII 码值的比较使用库函 数 strcmp( )，交换字符串应使用库函数 strcpy( )，注意需包含头文件 string.h。

（2） 该题使用冒泡法对 3 个字符串进行排序。

（3） 本题变量定义可参考如下：

int i, j;

char a[5][20] = {"ZhangDa", "WangLin", "LiQian", "LiuYing", "HuYuan"};

char t[20];

其中，i、j 是排序时的循环变量；二维数组 a 用来存放 5 个字符串； 一维数组 t 作为交换相邻两个字符串时的暂存单元。

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义 1 个二维的字符数组 a，并为其初始化 5
//个姓名字符串，编程对 5 个姓名字符串按 ASCII
//码值的大小进行升序排序
int main()
{
    int i, j;
    char a[5][20] = {"ZhangDa", "WangLin", "LiQian", "LiuYing", "HuYuan"};
    char t[20];
    printf("5个姓名的字符串是:\n");
    for(i=0;i<5;i++){
        printf("%s\n",a[i]);
    }

    printf("对5个姓名字符串进行升序排序的结果是:\n");
    for(i=0;i<5;i++)
    {
        for(j=0;j<5-i-1;j++)
        {
            if(strcmp(a[j],a[j+1])>=0)
            {
                strcpy(t,a[j]);
                strcpy(a[j],a[j+1]);
                strcpy(a[j+1],t);

            }
        }
    }

    for(i=0;i<5;i++){
        printf("%s\n",a[i]);
    }

    return 0;
}

运行结果：

16. 链表和文件

16.1 链表的编程练习(1

题目：

建立一个动态链表，链表中有 10 个数据结点，向每个结点的数据域中填入一个整数值， 并输出该链表。

源代码：

#include <stdio.h>
#include <stdlib.h>
//建立一个动态链表，
//链表中有 10 个数据结点，
//向每个结点的数据域中填入一个整数值，
//并输出该链表
typedef struct node
{
    int data;
    struct node *next;
}NODE;

int main()
{
    NODE *h,*p1,*p2;
    int i;
    h = (NODE *)malloc(sizeof(NODE));
    p1 = h;
    for(i=0;i<10;i++)
    {
        p2 = (NODE *)malloc(sizeof(NODE));
        p2 ->data = 2*i+1;
        p1->next = p2;
        p1 = p2;
    }
    p1->next = NULL;
    p1 = h->next;
    while(p1 !=NULL)
    {
        printf("%d -> ",p1->data);
        p1 = p1->next;
    }
    printf("NULL\n");
    return 0;
}

运行结果：

16.2 链表的编程练习(2

题目：

建立一个具有 10 个结点的链表，假定链表中的各结点已按升序排序，并且各结点中的数值不重复。从键盘输入一个整数，查找链表中是否有该数，如果有，就将链表中 存放该数的结点删除。

源代码：

#include <stdio.h>
#include <stdlib.h>
//建立一个具有 10 个结点的链表，
//假定链表中的各结点已按升序排序，
//并且各结点中的数值不重复。
//从键盘输入一个整数，查找链表中是否有该数，
//如果有，就将链表中存放该数的结点删除
typedef struct node
{
    int data;
    struct node *next;
}NODE;

int main()
{
    NODE *h,*p1,*p2;
    int i,x,a[10]={1,2,3,4,5,6,7,8,9,10};
    h = (NODE *)malloc(sizeof(NODE));
    p1 = h;
    for(i=0;i<10;i++)
    {
        p2 = (NODE *)malloc(sizeof(NODE));
        p2 ->data = a[i];
        p1->next = p2;
        p1 = p2;
    }
    p1->next = NULL;

    p1 = h->next;
    printf("原始链表:\n");
    while(p1 !=NULL)
    {
        printf("%d -> ",p1->data);
        p1 = p1->next;
    }
    printf("NULL\n");

    printf("请输入一个整数:");
    scanf("%d",&x);
    p1 = h;
    while(p1 != NULL)
    {
        p2 = p1->next;
        if(p2->data == x)
        {
            break;
        }
        else
        {
            p1 = p1->next;
        }
    }

    p1->next = p2->next;
    free(p2);
    printf("删除节点后的链表:\n");
    p1 = h->next;
    while(p1 !=NULL)
    {
        printf("%d -> ",p1->data);
        p1 = p1->next;
    }
    printf("NULL\n");

    return 0;
}

运行结果：

16.3 链表的编程练习(3

题目：

建立一个具有 10 个结点的链表，假定链表中的各结点已按升序排序，并且各结点中的 数值不重复。从键盘输入一个整数，将该数插入到链表中，使该链表各结点仍然保 持升序排序。

源代码：

#include <stdio.h>
#include <stdlib.h>
//建立一个具有 10 个结点的链表，
//假定链表中的各结点已按升序排序，
//并且各结点中的数值不重复。
//从键盘输入一个整数，查找链表中是否有该数，
//使该链表各结点仍然保持升序排序
typedef struct node{
    int data;
    struct node *next;
}NODE;

int main()
{
    NODE *h,*p1,*p2,*p3;
    int i,x,a[10]={1,3,5,7,9,11,13,15,17,19};
    h = (NODE *)malloc(sizeof(NODE));
    p1 = h;
    for(i=0;i<10;i++)
    {
        p2 = (NODE *)malloc(sizeof(NODE));
        p2 ->data = a[i];
        p1->next = p2;
        p1 = p2;
    }
    p1->next = NULL;

    p1 = h->next;
    printf("原始链表:\n");
    while(p1 !=NULL)
    {
        printf("%d -> ",p1->data);
        p1 = p1->next;
    }
    printf("NULL\n");

    printf("请输入一个整数:");
    scanf("%d",&x);
    p3 = (NODE *)malloc(sizeof(NODE));
    p3->data = x;
    p1 = h;
    while(p1 != NULL)
    {
        p2 = p1->next;
        if(p2->data > x)
        {
            break;
        }
        else
        {
            p1 = p1->next;
        }
    }

    p1->next = p3;
    p3->next = p2;
    printf("插入节点后的链表:\n");
    p1 = h->next;
    while(p1 !=NULL)
    {
        printf("%d -> ",p1->data);
        p1 = p1->next;
    }
    printf("NULL\n");

    return 0;
}

运行结果：

16.4 文件的编程练习(1

题目：

在 D 盘根目录下存放了一个 file.txt 文件，如下图所示，编程读出文件的内容。

源代码：

#include <stdio.h>
#include <stdlib.h>
//在 D 盘根目录下存放了一个 file.txt 文件，如下图所示，编程读出文件的内容
int main()
{
    char ch;
    FILE *fp;
    fp = fopen("d:\\file.txt","r");
    if(fp == NULL)
    {
        printf("无法打开文件\n");
        exit(0);
    }
    ch = fgetc(fp);
    while(ch !=EOF)
    {
        putchar(ch);
        ch = fgetc(fp);
    }
    fclose(fp);
    putchar('\n');
    return 0;
}

运行结果：

16.5 文件的编程练习(2

题目：

测试代码

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *fp;
    int i = 20,j = 30,k,n;
    fp = fopen("d1.dat","w");
    fprintf(fp,"%d\n",i);
    fprintf(fp,"%d\n",j);
    fclose(fp);
    fp = fopen("d1.dat","r");
    fscanf(fp,"%d%d",&k,&n);
    printf("%d %d\n",k,n);
    fclose(fp);
    return 0;
}

运行结果：

16.6 文件的编程练习(3

题目：

测试代码

源代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *fp; int i, k=0, n=0;
    fp=fopen("d1.dat","w");
    for(i=1;i<4;i++)
    fprintf(fp,"%d", i);
    fclose(fp);
    fp=fopen("d1.dat","r");
    fscanf(fp,"%d%d",&k,&n);
    printf("%d %d\n",k,n);
    fclose(fp);
    return 0;
}

运行结果：

16.7 结构体基础编程练习(1

题目：

定义一个日期结构体类型，从键盘输入年-月-日，计算该日是本年的第几天。

提示：

（1）结构体定义参考如下

typedef struct {

int year; /年/

int month; /月/

int day; /日/

}DATE; /结构体类型名/

（2）主函数中变量定义参考如下

DATE x; /结构体变量，用来保存输入的年-月-日/

int i, day, sum = 0; /i 是循环变量，day 保存各月的天数，sum 保 存天数总和/

（3）该题编程思路为：

例如输入 2008 年 3 月 4 日，则首先统计 2008 年中 1、 2 月天数总和，再加上 3 月份的 4 天，便得到该日是该年的第几天。同时 需要考虑闰年的问题，闰年是指“能被 400 整除的年份，或者是能被 4 整 除但同时不能被 100 整除的年份”。

源代码：

#include <stdio.h>
#include <stdlib.h>
//定义一个日期结构体类型，
//从键盘输入年-月-日，
//计算该日是本年的第几天
typedef struct
{
    int year; /*年*/
    int month; /*月*/
    int day; /*日*/
}DATE; /*结构体类型名*/

int main()
{
    DATE x;
    int i,day[12] = {31,28,31,30,31,30,31,31,30,31,30,31},sum = 0;
    printf("请输入年-月-日:\n");
    scanf("%d-%d-%d",&x.year,&x.month,&x.day);
    sum = x.day;
    for(i = 0;i != x.month - 1;i++)
    {

        sum += day[i];
    }
    if((x.year % 4 == 0 && x.year % 100 !=0) || x.year % 400 == 0)
    {
        sum++;
    }
    printf("%d-%d-%d是该年的第%d天",x.year,x.month,x.day,sum);
    return 0;
}

运行结果：

16.8 结构体数组编程练习(1

题目：

定义一个学生结构体类型（包括学号、姓名、两门课 的成绩），然后定义一个能保存 3 名学生数据的结构体 数组，并为数组初始化 3 个学生的信息。

编程求出每个学 生两门课的平均成绩，查找平均分最高的学生，打印该生 的信息（学号、姓名、两门课成绩）。程序运行效果如右 图所示：

提示：

（1） 结构体定义参考如下

typedef struct
{
    char num[10]; /*学号*/
    char name[20]; /*姓名*/
    int score[2]; /*两门课的成绩*/
    float aver; /*平均成绩*/
}STU; /*结构体类型名*/

（2） 主函数里的变量定义参考如下

/*定义结构体数组，并初始化 3 个学生的信息*/
STU stu[3]={{"200901", "zhang", {60, 65}}, {"200902", "Wang", {70, 75}}, {"200903", "Zhao", {80, 85}}};
int i, max; /*max 保存平均分最高的学生编号*/

（3）该程序可以由 3 个循环体构成，其中第一个循环的功能是打印 3 个学生的 信息；第二个循环的功能是计算并打印每个学生的平均分；第三个循环的 功能是查找最高的平均分。

源代码：

#include <stdio.h>
#include <stdlib.h>
//定义一个学生结构体类型（包括学号、姓名、两门课
//的成绩），然后定义一个能保存 3 名学生数据的结构体
//数组，并为数组初始化 3 个学生的信息。编程求出每个学
//生两门课的平均成绩，查找平均分最高的学生，打印该生
//的信息（学号、姓名、两门课成绩）
typedef struct
{
    char num[10]; /*学号*/
    char name[20]; /*姓名*/
    int score[2]; /*两门课的成绩*/
    float aver; /*平均成绩*/
}STU; /*结构体类型名*/

int main()
{
    /*定义结构体数组，并初始化 3 个学生的信息*/
    STU stu[3]={{"200901", "zhang", {60, 65}},
                {"200902", "Wang", {70, 75}},
                {"200903", "Zhao", {80, 85}}};
    int i, max=0,maxaver=0; /*max 保存平均分最高的学生编号*/
    printf("3个学生的信息是:\n");
    printf("学号\t姓名\t成绩\n");
    for(i=0;i<3;i++)
    {
        printf("%s\t%s\t%d %d\n",stu[i].num,stu[i].name,stu[i].score[0],stu[i].score[1]);
    }

    printf("\n3个学生的平均成绩是:\n");
    for(i=0;i<3;i++)
    {
        stu[i].aver = (stu[i].score[0] + stu[i].score[1]) / 2;
        printf("第i个学生的平均分:%f\n",stu[i].aver);
    }

    printf("\n平均分最高的学生是:\n");
    for(i=0;i<3;i++)
    {
        if(stu[i].aver > maxaver)
        {
            maxaver = stu[i].aver;
            max = i;
        }
    }
    printf("%s\t%s\t%d %d\n",stu[max].num,stu[max].name,stu[max].score[0],stu[max].score[1]);
    return 0;
}

运行结果：

16.9 结构体数组编程练习(2

题目：

定义一个学生结构体类型（包括学号、姓名、一门课的 成绩），再定义一个能保存 4 名学生数据的结构体数组， 并为数组初始化 4 个学生的信息。编程对这 4 个学生按课 程成绩进行降序排序。

提示：

（1）注意本题按分数降序排序并不仅仅对分数进行交换， 而是将整个学生的信息进行交换。 （2）结构体定义参考如下

typedef struct
{
char num[10]; /*学号*/
char name[20]; /*姓名*/
int score; /*一门课的成绩*/
}STU; /*结构体类型名*/

（3）主函数里的变量定义参考如下

STU stu[4]={{"200901", "Zhang", 70},{"200902", "Wang", 80}, {"200903", "Zhao", 65}, {"200904", "Zhou", 95}};
int i, j;
STU t;

其中数组 stu 用来存放学生信息；变量 i、j 是循环变量；变量 t 是中间变量，冒泡排序时使用

源代码：

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
//定义一个学生结构体类型（包括学号、姓名、一门课的
//成绩），再定义一个能保存 4 名学生数据的结构体数组，
//并为数组初始化 4 个学生的信息。编程对这 4 个学生按课
//程成绩进行降序排序。
typedef struct
{
    char num[10]; /*学号*/
    char name[20]; /*姓名*/
    int score; /*一门课的成绩*/
}STU; /*结构体类型名*/


int main()
{
    STU stu[4]={{"200901", "Zhang", 70},{"200902", "Wang", 80}, {"200903", "Zhao", 65}, {"200904", "Zhou", 95}};
    int i,j;
    STU t;
    printf("4个学生的信息是:\n");
    printf("学号\t姓名\t成绩\n");
    for(i=0;i<4;i++)
    {
        printf("%s\t%s\t%d\n",stu[i].num,stu[i].name,stu[i].score);
    }
    for(i=0;i<3;i++)
    {
        for(j=0;j<3-i;j++)
        {
            if(stu[j].score<stu[j+1].score)
            {
                strcpy(t.num,stu[j].num);
	strcpy(stu[j].num,stu[j+1].num);
	strcpy(stu[j+1].num,t.num);

                strcpy(t.name,stu[j].name);
	strcpy(stu[j].name,stu[j+1].name);
	strcpy(stu[j+1].name,t.name);

                t.score=stu[j].score;
                stu[j].score=stu[j+1].score;
                stu[j+1].score=t.score;


            }
        }
    }

    printf("按成绩降序排序后的结果是:\n");
    printf("学号\t姓名\t成绩\n");
    for(i=0;i<4;i++)
    {
        printf("%s\t%s\t%d\n",stu[i].num,stu[i].name,stu[i].score);
    }
    return 0;
}

运行结果：

看到这里的都是人才!!!