概述
本文主要提供《C语言程序设计》(浙大版) 第九、十章的课后习题解析，以方便同学们完成题目后作为参考对照。后续将更新第十一、十二章节的课后习题解析，如想了解更多，请持续关注该专栏。
专栏直达链接：《C语言程序设计》(浙大版)_孟俊宇-MJY的博客-CSDN博客
http://t.csdnimg.cn/ZtcgY
一.第九章（结构）
选择题
[9-1]
以下定义结构变量的语句中，错误的是（ ）。
A. struct student { int num; char name[ 20];} s;
B. struct { int num; char name[ 20] ;} s;
C. struct student { int num; char name[ 20] ;} ; student s;
D. struct student { int num; char name [ 20] ; } ; struct student s;
答：C
解析：
结构变量名可以在定义结构后单独定义。也可以跟在结构后直接定义，直接写结构变量名即可。
[9-2]
如果结构变量 s 中的生日是 “1984 年11月11日”，下列对其生日的正确赋值是（ ）。
struct student{
int no; char name[20]; char sex;
struct {
int year; int month; int day;
}birth;
}s;A. year= 1984; month=11; day=11;
B. birth. year= 1984; birth. month=11; birth. day=11;
C. s. year= 1984; s. month=11; s. day=11;
D. s. birth. year= 1984; s. birth. month= 11; s. birth. day=11;
答：D
解析：
s 对应的结构为 student，birth 是它的一个成员，year，month，day 是birth的成员。所以要通过 s. birth. year= 1984; s. birth. month= 11; s. birth. day=11; 表示。
[9-3]
以下程序段的输出结果为（ ）。
struct
{
int x, y;
} s[2] = {{1, 3}, {2, 7}};
printf("%d\n", s[0].y / s[1].x);
A.0
B.1
C.2
D.3
答：B
解析：
这里打印的结果是 s[0].y / s[1].x，就是 3 / 2 的结果，是 1 。
[9-4]
设有如下定义，则对data中的a成员的正确引用是（ ）。
struct sk{
int a; double b;
}data, *p=&data;A. (*p).data.a
B. (*p).a
C. p->data. a
D. p.data.a
答：B
解析：
这里 *p 指向 data，想引用对应的 a，直接 (*p).a 即可。所以这里选 B。
[9-5]
对于以下结构定义，++p->str中的++加在（ ）。
struct{
int len; char *str;
}*P;A.指针 str 上
B.指针 p 上
C. str 指向的内容上
D.语法错误
答：A
解析：->的等级大于++的等级，所以先p->str，然后+1。相当于++(p->str)。
[9-6]
若有下列定义，则以下不合法的表达式是（ ）。
struct student
{
int num;
int age;
} stu[3] = {{101, 20}, {102, 19}, {103, 20}}, *p = stu;A. (p++)->num
B. p++
C. (*p). num
D. p= &stu.age
答：D
解析：
p 是 struct student 类型的指针，stu.age 是 int 型变量，p 指向 stu.age 会产生类型不匹配的问题
填空题
[9-1]
写出下面程序段的运行结果（ ）。
struct example
{
struct
{
int x;
int y;
} in;
int a;
int b;
} e;
e.a = 1;
e.b = 2;
e.in.x = e.a * e.b;
e.in.y = e.a + e.b;
printf("%d,%d\n", e.in.x, e.in.y);答：2,3
解析：
e.a = 1, e.b = 2,
e.in.x = e.a * e.b = 1 * 2 = 2
e.in.y = e.a + e.b = 1 + 2 = 3
最终打印 2 和 3。
[9-2]
时间计算。读入时间数值，将其加 1 秒后输出，时间格式为 "hh: mm: ss"，即 "小时: 分钟: 秒"，当小时等于 24 小时，置为 0 。请填空。
#include <stdio.h>
struct
{
int hour, minute, second;
} time;
int main()
{
scanf("%d:%d:%d", _______________);
time.second++;
if ( _______________ == 60)
{
_______________;
time.second = 0;
if (time.minute == 60)
{
time.hour++;
time.minute = 0;
if ( _______________ == 24)
{
time.hour = 0;
}
}
}
printf("%d:%d:%d\n", time.hour, time.minute, time.second);
return 0;
}答：
&time.hour, &time.minute, &time.second
time.second
time.minute++
time.hour
解析：
第一空，&time.hour, &time.minute, &time.second，读入时间的时，分，秒。然后根据题意，给秒加 1。
第二空，time.second == 60，判断秒是否是 60。
第三空，time.minute++，如果是，那么分钟累加 1，秒置为 0。然后判断分钟是否是 60，如果是，时就累加 1，然后分钟置为 0 。
第四空，time.hour == 24，如果时为 24，要将时置为 0 ，表示第二天了。
[9-3]
"." 称为（ ）运算符，"->" 称为（ ）运算符。
答：成员 指向
解析：
. 叫做结构成员操作符。用于访问结构成员。
-> 叫做指向运算符。用于访问指针指向的结构成员。
[9-4]
写出下面程序段的运行结果（ ）。
struct example
{
int a;
double b;
char *c;
} x = {23, 98.5, "wang"}, *px = &x;
printf("%d,%s,%.1f,%s\n", x.a, x.c, (*px).b, px->c);答：23,wang,98.5,wang
解析：
打印语句中，先打印 x.a ，就是 23，然后打印 x.c ，就是 wang，然后 (*px).b，这里 px 指向 x，打印的就是 98.5，px->c，打印 wang。
[9-5]
写出下面程序段的运行结果（ ）。
struct table
{
int x, y;
} a[4] = {{10, 20}, {30, 40}, {50, 60}, {70, 80}};
struct table *p = a;
printf("%d,", p++->x);
printf("%d,", ++p->y);
printf("%d\n", (a + 3)->x);答：10,41,70
解析：
第一行打印：p++->x，最初 p 指向数组 a 的第一个元素，打印它的 x，值为 10。然后 p指向下一个元素。
第二行打印：此时 p 指向第二个元素{30,40}，++p->y，这里表示取 p->y，40，然后 ++ ，打印 41。
第三行打印：(a + 3)->x，a+3 表示里面下标为 3 的元素，就是 {70,80}，取 x 打印出 70。
[9-6]
写出下面程序段的运行结果（ ）。
struct
{
int a;
int *b;
} s[4], *p;
int i, n = 1;
for (i = 0; i < 4; i++)
{
s[i].a = n;
s[i].b = &s[i].a;
n = n + 2;
}
p = &s[0];
printf("%d\n", ++*p->b);
p++;
printf("%d,%d\n", (++p)->a, (p++)->a);答：
2
5,5
解析：
for 循环中主要是为了给数组 s 中的 4 个元素赋值。
s[0] 中 a 和 b 分别是 1。
s[1] 中 a 和 b 分别是 3。
s[2] 中 a 和 b 分别是 5。
s[3] 中 a 和 b 分别是 7。
第一行打印语句，++*p->b ，这里取 *p 指向数组中的第一个元素，取 b 的值，就是 1。然后有个前置的 ++ ，所以打印的是 2。
第二行打印语句，(++p)->a，在这之前，上面有一行单独的 p++，那么 p 会指向数组中第二个元素，这里 (++p) 后，那么 p 就指向了数组第三个元素，打印 它的 a，就是 5。再打印 (p++)->a，这里 (p++)，还是先运算再累加 1，所以还是打印第三个元素的 a，然后 p 指向第四个元素。
程序设计题
[9-1]
时间换算：用结构类型表示时间内容（时间以时、分、秒表示），输入一个时间数值，再输入一个秒数 n（n<60），以 h: m: s 的格式输出该时间再过 n 秒后的时间值（超过 24 点就从 0 点开始计时）。试编写相应程序。
答案代码：
#include <stdio.h>
struct time
{
int hour;
int minute;
int second;
};
void add(struct time *p, int s);
int main()
{
// 习题(9.3.1)
/*
时间换算：用结构类型表示时间内容（时间以时、分、秒表示），输入一个时间数值，
再输入一个秒数 n（n<60），以 h: m: s 的格式输出该时间再过 n 秒后的时间值（超过 24 点就从 0 点开始计时）。
*/
struct time c;
int n;
printf("input time:");
scanf("%d%d%d", &c.hour, &c.minute, &c.second);
printf("input n:");
scanf("%d", &n);
add(&c, n);
printf("%d: %d: %d\n", c.hour, c.minute, c.second);
return 0;
}
void add(struct time *p, int s)
{
int ho, mi, se;
ho = p->hour;
mi = p->minute;
se = p->second;
se = se + s;
if (se < 60)
{
p->second = se;
return;
}
else
{
mi = p->minute = mi + se / 60;
se = p->second = se % 60;
if (mi < 60)
{
return;
}
else
{
mi = p->minute = mi % 60;
ho = ho + mi / 60;
mi = p->hour = mi % 60;
}
if (ho < 24)
{
return;
}
else
mi = p->hour = mi % 24;
return;
}
}运行结果：
[9-2]
计算两个复数之积：编写程序，利用结构变量求解两个复数之积。 提示：求解 (a1+a2i)x(b1+b2i)， 乘积的实部为： a1xb1-a2xb2 ，虚部为： a1xb2+a2xb1。
答案代码：
#include <stdio.h>
struct complex
{
int real, im;
};
struct complex cmult(struct complex, struct complex);
int main()
{
// 习题(9.3.2)
/*
计算两个复数之积：编写程序，利用结构变量求解两个复数之积。
提示：求解 (a1+a2i)x(b1+b2i)， 乘积的实部为： a1xb1-a2xb2 ，虚部为： a1xb2+a2xb1。
*/
struct complex a = {3, 4}, b = {5, 6}, c;
c = cmult(a, b);
printf("(%d+%di)x(%d+%di) =%d+%di\n", a.real, a.im, b.real, b.im, c.real, c.im);
return 0;
}
struct complex cmult(struct complex a, struct complex b)
{
struct complex w;
w.real = a.real * b.real - a.im * b.im;
w.im = a.real * b.im + a.im * b.real;
return w;
}运行结果：
[9-3]
平面向量加法：输入两个二维平面向量 V1=(x1, y1) 和 V2=(x2, y2) 的分量，计算并输出两个向量的和向量。试编写相应程序。
答案代码：
#include <stdio.h>
struct vector
{
double x;
double y;
};
struct vector vector_add(struct vector v1, struct vector v2);
int main()
{
// 习题(9.3.3)
/*
平面向量加法：输入两个二维平面向量 V1=(x1, y1) 和 V2=(x2, y2) 的分量，计算并输出两个向量的和向量。
*/
struct vector v1, v2, sum;
double s1, s2;
printf("input first vector:\n");
scanf("%lf%lf", &v1.x, &v1.y);
printf("input second vector:\n");
scanf("%lf%lf", &v2.x, &v2.y);
sum = vector_add(v1, v2);
printf("(%.1lf, %.1lf)\n", sum.x, sum.y);
return 0;
}
struct vector vector_add(struct vector v1, struct vector v2)
{
struct vector sum;
double s1, s2;
s1 = v1.x + v2.x;
s2 = v1.y + v2.y;
sum.x = s1;
sum.y = s2;
return sum;
}运行结果：
[9-4]
从键盘输入 10 本书的名称和定价并存入结构数组中，从中查找定价最高和最低的书的名称和定价，并输出。试编写相应程序。
答案代码：
#include <stdio.h>
#define NUMBER 10
struct book
{
char name[30];
float price;
};
int main()
{
// 习题(9.3.4)
/*
查找书籍：从键盘输入 10 本书的名称和定价并存入结构数组中，从中查找定价最高和最低的书的名称和定价，并输出。
*/
int i, max1, min1;
struct book test[NUMBER];
printf("input 10 book's name and price\n");
for (i = 0; i < NUMBER; i++)
scanf("%s%f", test[i].name, &test[i].price);
max1 = min1 = 0;
for (i = 1; i < NUMBER; i++)
{
if (test[max1].price < test[i].price)
max1 = i;
if (test[min1].price > test[i].price)
min1 = i;
}
printf("Max Price: %.2f, %s\n", test[max1].price, test[max1].name);
printf("Min Price: %.2f, %s\n", test[min1].price, test[min1].name);
return 0;
}运行结果：
[9-5]
通信录排序：建立一个通信录，通信录的结构记录包括：姓名、生日、电话号码;其中生日又包括三项：年、月、日。编写程序，定义一个嵌套的结构类型，输入 n（n<10）个联系人的信息，再按他们的年龄从大到小的顺序依次输出其信息。试编写相应程序。
答案代码：
#include <stdio.h>
struct birth
{
int year;
int month;
int date;
};
struct friends_list
{
char name[10]; /*姓名*/
struct birth birthday; /*生日*/
char phone[15]; /*电话号码*/
char address[50]; /*住址*/
};
void sort(struct friends_list s[], int n) /*按生日日期从小到大排序*/
{
int i, j;
struct friends_list temp;
for (i = 1; i < n; i++)
for (j = 0; j < n - i; j++)
// 先判断年份
if (s[j].birthday.year > s[j + 1].birthday.year)
{
temp = s[j];
s[j] = s[j + 1];
s[j + 1] = temp;
}
else if (s[j].birthday.year == s[j + 1].birthday.year)
{
if (s[j].birthday.month > s[j + 1].birthday.month)
{
temp = s[j];
s[j] = s[j + 1];
s[j + 1] = temp;
}
else if (s[j].birthday.month == s[j + 1].birthday.month)
{
if (s[j].birthday.date > s[j + 1].birthday.date)
{
temp = s[j];
s[j] = s[j + 1];
s[j + 1] = temp;
}
}
}
}
int main()
{
// 习题(9.3.5)
/*
通信录排序：建立一个通信录，通信录的结构记录包括：姓名、生日、电话号码;
其中生日又包括三项：年、月、日。编写程序，定义一个嵌套的结构类型，
输入 n（n<10）个联系人的信息，再按他们的年龄从大到小的顺序依次输出其信息。
*/
int i, n;
struct friends_list friends[10];
printf("input n:");
scanf("%d", &n);
for (i = 0; i < n; i++) /*输入 n个人的通讯信息*/
{
printf("请输入第 %d 个人的信息: 姓名 年 月 日 手机号 地址\n", i + 1);
scanf("%s%d%d%d%s%s", friends[i].name, &friends[i].birthday.year, &friends[i].birthday.month, &friends[i].birthday.date, friends[i].phone, friends[i].address);
}
printf("------------------------------------------------------------------------\n");
printf("通讯录信息:\n");
for (i = 0; i < n; i++)
/*输出*/
printf("%s\t%d\t%d\t%d\t%s\t%s\n", friends[i].name, friends[i].birthday.year, friends[i].birthday.month, friends[i].birthday.date, friends[i].phone, friends[i].address);
printf("------------------------------------------------------------------------\n");
printf("排序后信息:\n");
/*按年龄从大到小排序*/
sort(friends, n);
for (i = 0; i < n; i++)
/*输出*/
printf("%s\t%d\t%d\t%d\t%s\t%s\n", friends[i].name, friends[i].birthday.year, friends[i].birthday.month, friends[i].birthday.date, friends[i].phone, friends[i].address);
return 0;
}运行结果：
[9-6]
按等级统计学生成绩：输入 10 个学生的学号、姓名和成绩，输出学生的成绩等级和不及格人数。每个学生的记录包括学号、姓名、成绩和等级，要求定义和调用函数set_grade()，根据学生成绩设置其等级，并统计不及格人数，等级设置： 85~100 为 A ，70~84 为 B ， 60~69 为 C ， 0~59 为 D。试编写相应程序。
答案代码：
#include <stdio.h>
#define N 10
struct student
{
int num;
char name[20];
int score;
char grade;
};
int set_grade(struct student *p);
int main()
{
// 习题(9.3.6)
/*
按等级统计学生成绩：输入 10 个学生的学号、姓名和成绩，输出学生的成绩等级和不及格人数。
每个学生的记录包括学号、姓名、成绩和等级，要求定义和调用函数set_grade()，根据学生成绩设置其等级，并统计不及格人数，
等级设置： 85~100 为 A ，70~84 为 B ， 60~69 为 C ， 0~59 为 D。
*/
struct student stu[N], *ptr;
int i, count;
ptr = stu;
printf("input the student's number, name and score: \n");
for (i = 0; i < N; i++)
{
printf("No %d:", i + 1);
scanf("%d%s%d", &stu[i].num, stu[i].name, &stu[i].score);
}
count = set_grade(ptr);
printf("The count (<60): %d\n", count);
printf("The student grade:\n");
for (i = 0; i < N; i++)
printf("%d\t%s\t%c\n", stu[i].num, stu[i].name, stu[i].grade);
return 0;
}
//等级设置
int set_grade(struct student *p)
{
int i, n = 0;
for (i = 0; i < N; i++, p++)
{
if (p->score >= 85)
p->grade = 'A';
else if (p->score >= 70)
p->grade = 'B';
else if (p->score >= 60)
p->grade = 'C';
else
{
p->grade = 'D';
n++;
}
}
return n;
}运行结果：
二.第十章（函数与程序结构）
选择题
[10-1]
对于以下递归函数，调用f(4)，其返回值为（ ）。
int f(int n)
{
if (n)
return f(n - 1) + n;
else
return n;
}A.10
B.4
C.0
D.以上均不是
答：A
解析：
递归函数的调用。
第一次调用函数 f，参数为 4，执行 if 语句，返回 f(3)+4，
第二次调用函数 f，参数为 3，执行 if 语句，返回 f(2)+3，
第三次调用函数 f，参数为 2，执行 if 语句，返回 f(1)+2，
第四次调用函数 f，参数为 1，执行 if 语句，返回 f(0)+1，
第五次调用函数 f，参数为 0，执行 else 语句，返回 0。
然后再一层一层将return 的结果返回。最终得到的就是 0 +1+2+3+4 = 10。
[10-2]
执行下列程序段后，变量 i 的值为（ ）。
#define MA(x, y) (x*y)
i=5;
i=MA(i, i+1)-7;A.30
B.23
C.19
D.1
答：C
解析：
函数调用时，如果实参是表达式，要先计算表达式，再把结果值传递过去。而这里使用了宏定义。宏替换不作计算，直接替换进去。
MA(i, i+1)，按照 i * (i+1) 计算，i 带入给 x，i+1 带入给 y，那么 x * y 就是 x * x + 1 ，计算结果就是 26，再减掉 7，最终结果就是 19。
[10-3]
宏定义 "#define DIV(a, b) a/b"， 经 DIV(x+5, y-5) 引用，替换展开后是（ ）。
A. (x+5/y-5)
B. x+5/y-5
C. (x+5)/(y-5)
D. (x+5)/(y-5)
答：B
解析：
宏定义在使用的时候，宏替换不作计算，直接替换进去。 就是 x+5/y-5，选项 B 正确。
[10-4]
以下程序的输出结果是（ ）。
int x = 5, y = 7;
void swap()
{
int z;
z = x;
x = y;
y = z;
}
int main()
{
int x = 3, y = 8;
swap();
printf("%d#%d\n", x, y);
return 0;
}A.8#3
B.3#8
C.5#7
D.7#5
答：B
解析：
题目中定义了全局变量 x=5，y=7，main() 中又定义了同名的局部变量 x=3，y=8。函数 swap ()，函数里交换了x 和 y 的值，操作的是全局变量。main() 中调用完函数后打印 x 和 y 的值，这里打印的是 main () 的局部变量，还是 3 和 8。所以选项 B 正确。
[10-5]
下面说法中正确的是（ ）。
A.若全局变量仅在单个 C 文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度
B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度
C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑变量生命周期问题
D.静态全局变量使用过多，将导致动态存储区(堆栈)溢出
答：A
解析：
A选项：变量分为全局变量和局部变量。局部变量和形参的作用域是函数内部，全局变量的作用域是整个文件。但可以通过声明一个extern的全局变量拓展全局变量的作用域，也可以通过定义一个static的全局变量限制这种拓展。
B选项：如果全局变量仅仅由单个函数访问，不存在耦合度的问题
C选项：动态全局变量、静态全局变量、静态局部变量的生命周期都为程序运行期间，其中静态局部变量的生存周期虽然为整个源程序，但是其作用域仍然与局部变量相同，当退出函数是，该变量还存在，但是不能使用。
D选项：全局变量和静态变量都是存储在静态存储区，所以在递归调用是不会压栈，也不会造成堆栈溢出。
[10-6]
以下 main() 函数中所有可用的变量为（ ）。
void fun(int x)
{
static int y;
.....
}
int z;
int main()
{
int a, b;
fun(a);
.....
}A.x,y
B.x,y,z
C.a,b,x,y, z
D.a,b,z
答：D
解析：
在 main() 中可以使用的变量包括 main() 中声明的局部变量 a 和 b，以及全局变量 z
填空题
[10-1]
对于以下递归函数，调用f(3)，其返回值为（ ）。
tin f(int x)
{
return((x>0)? f(x-1)+f(x-2): 1);
}答：5
解析：
这里是递归函数调用：
f(3)
= f(2)+f(1)
= f(1)+ f(0) + f(1) = f(1)+1+f(1)
= f(0)+ f(-1) + 1 + f(0)+f(-1) = 1+1+1+1+1
= 5
[10-2]
输入 6 ，下列程序的运行结果是（ ）。
#include <stdio.h>
int f(int n, int a)
{
if (n == 0)
return a;
return f(n - 1, n * a);
}
int main(void)
{
int n;
scanf("%d", &n);
printf("%d\n", f(n, 1));
return 0;
}答：720
解析：
这里 f 函数时递归调用，当 n 为 6 时，第一次调用函数，传入参数 n 为 6，a 为 1。
f(6,1)
= f(5,6)
= f(4,30)
= f(3,120)
= f(2, 360)
= f(1,720)
= f(0, 720)
= 720
[10-3]
下列程序的输出结果为（ ）。
#include <stdio.h>
int f(int g)
{
switch (g)
{
case 0:
return 0;
case 1:
case 2:
return 2;
}
printf("g=%d\n", g);
return f(g - 1) + f(g - 2);
}
int main(void)
{
int k;
k = f(4);
printf("k=%d\n", k);
return 0;
}答：
g=4
g=3
k=6
解析：
递归函数调用：
k = f(4)
打印 g=4
= f(3)+f(2) = f(3)+2
打印 g=3
= f(2)+f(1) = 2+2+2 = 6
打印 k = 6[10-4]
C 语言的编译预处理功能主要包括和（ ）、（ ）和（ ）。
答：宏定义、文件包含、条件编译
解析：
编译预处理时 C 语言编译程序的组成部分，它用于解释处理 C 语言源程序中的各种预处理指令。
预处理功能是由很多预处理命令组成，这些命令在编译时进行通常的编译功能(包含词法和语言分析、代码生成、优化等)之前进行处理。预处理后的结果和源程序一起在进行通常的编译操作，进而得到目标代码。预处理功能主要包括：宏定义、文件包含、条件编译。
[10-5]
下列语句的运算结果为（ ）。
#define F(x) x-2
#define D(x) x*F(x)
printf("%d,%d", D(3), D(D(3)));答：7,-13
解析：
宏定义，是直接将数值带入。
D(3),
=3*F(3)
=3*3-2
=7
D(D(3))
=D(3)*F(D(3))
=3*F(3)*D(3)-2
=3*3-2*3*F(3)-2
=3*3-2*3*3-2-2
=9-18-2-2
=-13程序设计题
[10-1]
判断满足条件的三位数：编写一个函数，利用参数传入一个 3 位数 n ，找出 101～ n 间所有满足下列两个条件的数：它是完全平方数，又有两位数字相同，如 144、676 等，函数返回找出这样的数据的个数。试编写相应程序。
答案代码：
#include <stdio.h>
#include <math.h>
int fun(int n);
int main()
{
int n;
printf("input n:");
scanf("%d", &n);
printf("total= %d\n", fun(n));
return 0;
}
int fun(int n)
{
int i, d = 0;
for (i = 101; i <= n; i++)
if (((int)sqrt(i) * (int)sqrt(i)) == i)
{
if (i / 100 == (i / 10) % 10 || i / 100 == i % 10 || (i / 10) % 10 == i % 10)
{
printf("%d\n", i);
d++;
}
}
return d;
}运行结果：
[10-2]
递归求阶乘和：输入一个整数 n（ n>0 且 n≤10），求 1!+2!+3!+...+n!。 定义并调用函数 fact(n) 计算 n!，函数类型是 double。试编写相应程序。
答案代码：
#include <stdio.h>
double fact(int n);
int main()
{
// 习题(10.3.2)
int i, n;
double sum = 0;
printf("input n:");
scanf("%d", &n);
for (i = 1; i <= n; i++)
sum = sum + fact(i);
printf("%.0lf\n", sum);
return 0;
}
double fact(int n)
{
int result = 0;
if (n == 1)
result = 1;
else if (n > 1)
result = n * fact(n - 1);
return result;
}运行结果：
[10-3]
递归实现计算 x^n ：输入实数 x 和正整数 n，用递归函数计算 x^n 的值。试编写相应程序。
答案代码：
#include <stdio.h>
int rec(int x, int n);
int main()
{
// 习题(10.3.3)
int x, n;
printf("input x and n:");
scanf("%d%d", &x, &n);
printf("result : %d\n", rec(x, n));
return 0;
}
int rec(int x, int n)
{
if (n == 0)
return 1;
else
return rec(x, n - 1) * x;
}运行结果：
[10-4]
递归求式子和：输入实数 x 和正整数 n，用递归的方法对下列计算式子编写一个函数。
答案代码：
#include <stdio.h>
double f(double x, int n);
double rec(double z, int b);
int main()
{
// 习题(10.3.4)
double x;
int n;
printf("input x and n:");
scanf("%lf%d", &x, &n);
printf("%.2lf\n", f(x, n));
return 0;
}
double f(double x, int n)
{
double sum;
double b;
if (n == 0)
return 0;
int z;
if (n % 2 == 0)
z = -1;
else
z = 1;
b = z * rec(x, n);
sum = b + f(x, n - 1);
return sum;
}
double rec(double x, int n)
{
if (n == 0)
return 1;
return x * rec(x, n - 1);
}运行结果：
[10-5]
递归计算函数 ack(m, n) ：输入 m 和 n ，编写递归函数计算 Ackermenn 函数的值：
试编写相应程序。
答案代码：
#include <stdio.h>
int Ack(int m, int n);
int main()
{
// 习题(10.3.5)
int m, n;
int result;
printf("input m and n:");
scanf("%d%d", &m, &n);
result = Ack(m, n);
printf("Ackerman(%d,%d)=%d\n", m, n, result);
return 0;
}
int Ack(int m, int n)
{
if (m == 0)
return n + 1;
else if (n == 0)
return Ack(m - 1, 1);
else
return Ack(m - 1, Ack(m, n - 1));
}运行结果：
[10-6]
递归实现求 Fabonacei 数列：用递归方法编写求斐波那契数列的函数，函数类型为整型，斐波那契数列的定义如下。试编写相应程序。
其中 f(0)=0，f(1)= 1。
答案代码：
#include <stdio.h>
long fib(int n);
int main()
{
// 习题(10.3.6)
int n;
printf("input n:");
scanf("%d", &n);
printf("fib(%d)=%ld\n", n, fib(n));
return 0;
}
long fib(int n)
{
long res;
if (n == 0)
res = 0;
else if (n == 1)
res = 1;
else
res = fib(n - 2) + fib(n - 1);
return res;
}运行结果：
[10-7]
递归实现十进制转换二进制：输入一个正整 n，将其转换为二进制后输出。要求定义并调用函数 dectobin(n)，它的功能是输出 n 的二进制。试编写相应程序。
答案代码：
#include <stdio.h>
void dectobin(int n);
int main()
{
// 习题(10.3.7)
int n;
printf("input n:");
scanf("%d", &n);
dectobin(n);
printf("\n");
return 0;
}
void dectobin(int n)
{
if (n == 0)
return;
else
{
dectobin(n / 2);
printf("%d", n % 2);
}
}运行结果：
[10-8]
递归实现顺序输出整数：输入一个正整数 n，编写递归函数实现对其进行按位顺序输出。试编写相应程序。
答案代码：
#include <stdio.h>
void printdigits(int n);
int main()
{
// 习题(10.3.8)
int n;
printf("input n:");
scanf("%d", &n);
printdigits(n);
return 0;
}
void printdigits(int n)
{
if (n < 10)
printf("%d\n", n);
else
{
printdigits(n / 10);
printf("%d\n", n % 10);
}
}运行结果：
[10-9]
输入 n（n<10）个整数，统计其中素数的个数。要求程序由两个文件组成，一个文件中编写 main 函数，另一个文件中编写素数判断的函数。使用文件包含的方式实现。试编写相应程序。
答案代码：
#include <stdio.h>
#include <math.h>
#include "Prime.c"
int main()
{
// 习题(10.3.9)
/*
输入 n（n<10）个整数，统计其中素数的个数。要求程序由两个文件组成，
一个文件中编写 main 函数，另一个文件中编写素数判断的函数。使用文件包含的方式实现。
*/
int n;
int count = 0;
printf("input numbers:");
while (1)
{
scanf("%d", &n);
if (prime(n))
{
count++;
}
if (getchar() == '\n')
{
break;
}
}
printf("其中素数的个数为:%d\n", count);
return 0;
}prime.c 文件：
int prime(int n)
{
int flag = 1;// 1：是素数，0:不是素数
int count = 0;//统计n被整除的次数
if( n == 1){
flag = 0;
}else{
for(int j = 2;j <= sqrt(n); j++){
if(n % j == 0){
count++;
break;
}
}
if(count == 1){
flag = 0;//不是素数
}
}
return flag;
}运行结果：
[10-10]
三角形面积为：
其中 a、b、c 分别是三角形的 3 条边。请分别定义计算 s 和 area 的宏，再使用函数实现。比较两者在形式上和使用上的区别。(上)
答案代码：
(1) 使用宏实现
#include <stdio.h>
#include <math.h>
#define S(a, b, c) ((a) + (b) + (c)) / 2
#define AREA(s, a, b, c) sqrt((s) * ((s) - (a)) * ((s) - (b)) * ((s) - (c)))
int main()
{
// 习题(10.3.10)
double a, b, c, s;
printf("input a,b,c:");
scanf("%lf%lf%lf", &a, &b, &c);
s = S(a, b, c);
printf("area = %lf\n", AREA(s, a, b, c));
return 0;
}运行结果：
[10-10]
三角形面积为：
其中 a、b、c 分别是三角形的 3 条边。请分别定义计算 s 和 area 的宏，再使用函数实现。比较两者在形式上和使用上的区别。
(2) 使用函数实现
#include <stdio.h>
#include <math.h>
double p(double a, double b, double c);
double area(double a, double b, double c);
int main()
{
// 习题(10.3.10)
double a, b, c, s;
printf("input a,b,c:");
scanf("%lf%lf%lf", &a, &b, &c);
printf("area = %lf\n", area(a, b, c));
return 0;
}
double p(double a, double b, double c)
{
return (a + b + c) / 2;
}
double area(double a, double b, double c)
{
double s = p(a, b, c);
return sqrt(s * (s - a) * (s - b) * (s - c));
}运行结果：
[10-11]
有序表的增删改查操作。首先输入一个无重复元素的、从小到大排列的有序表，并在屏幕上显示以下菜单，用户可以反复对该有序表进行插入、删除、修改和查找操作，也可以选择结束。当用户输入编号 1~4 和相关参数时，将分别对该有序表进行插入、删除、修改和查找操作，输入其他编号，则结束操作。
[1 ] Insert
[2] Delete
[3] Modify
[4] Query
[other option] End
答案代码：
/* 有序表的增删改查操作 */
#include <stdio.h>
#define MAXN 10000 /* 定义符号常量表示数组a的长度 */
int Count = 0; /* 用全局变量Count表示数组a中待处理的元素个数 */
void select(int a[], int option, int value); /* 决定对有序数组a进行何种操作的控制函数 */
int input_array(int a[]); /* 输入有序数组a的函数 */
void print_array(int a[]); /* 输出有序数组a的函数 */
int insert(int a[], int value); /* 在有序数组a中插入一个值为value的元素的函数 */
int del(int a[], int value); /* 删除有序数组a中等于value的元素的函数 */
int modify(int a[], int value1, int value2); /* 将有序数组a中等于value1的元素，替换为value2 */
int query(int a[], int value); /* 用二分法在有序数组a中查找元素value的函数 */
int main()
{
// 习题(10.3.1)
/*
有序表的增删改查操作。首先输入一个无重复元素的、从小到大排列的有序表，并在屏幕上显示以下菜单，用户可以反复对该有序表进行插入、删除、修改和查找操作，也可以选择结束。当用户输入编号 1~4 和相关参数时，将分别对该有序表进行插入、删除、修改和查找操作，输入其他编号，则结束操作。
[1 ] Insert
[2] Delete
[3] Modify
[4] Query
[other option] End
*/
int option, value, a[MAXN];
if (input_array(a) == -1)
{ /* 调用函数输入有序数组 a */
printf("Error"); /* a不是有序数组，则输出相应的信息 */
return 0;
}
printf("[1] Insert\n"); /* 以下4行显示菜单*/
printf("[2] Delete\n");
printf("[3] Update\n");
printf("[4] Query\n");
printf("[Other option] End\n");
while (1)
{ /* 循环 */
printf("input you select:");
scanf("%d", &option); /* 接受用户输入的编号 */
if (option < 1 || option > 4)
{ /* 如果输入1、2、3、4以外的编号，结束循环 */
break;
}
printf("input value:");
scanf("%d", &value); /* 接受用户输入的参数value */
select(a, option, value); /* 调用控制函数 */
printf("\n");
}
printf("Thanks.\n"); /* 结束操作 */
return 0;
}
/* 控制函数 */
void select(int a[], int option, int value)
{
int index, value2;
switch (option)
{
case 1:
index = insert(a, value); /* 调用插入函数在有序数组 a 中插入元素value */
if (index == -1)
{ /* 插入数据已存在，则输出相应的信息 */
printf("Error");
}
else
{
print_array(a); /* 调用输出函数，输出插入后的有序数组a */
}
break;
case 2:
index = del(a, value); /* 调用删除函数在有序数组 a 中删除元素value */
if (index == -1)
{ /* 没找到value，则输出相应的信息 */
printf("Deletion failed.");
}
else
{
print_array(a); /* 调用输出函数，输出删除后的有序数组a */
}
break;
case 3:
printf("input value2:");
scanf("%d", &value2); /* 接受用户输入的参数value2 */
index = modify(a, value, value2); /* 调用修改函数在有序数组 a 中修改元素value的值为value2 */
if (index == -1)
{ /* 没找到value或者vaule2已存在，则输出相应的信息 */
printf("Update failed.");
}
else
{
print_array(a); /* 调用输出函数，输出修改后的有序数组a */
}
break;
case 4:
index = query(a, value); /* 调用查询函数在有序数组 a 中查找元素value */
if (index == -1)
{ /* 没找到value，则输出相应的信息 */
printf("Not found.");
}
else
{ /* 找到，则输出对应的下标 */
printf("%d", index);
}
break;
}
}
/* 有序表输入函数 */
int input_array(int a[])
{
printf("input n:");
scanf("%d", &Count);
for (int i = 0; i < Count; i++)
{
scanf("%d", &a[i]);
if (i > 0 && a[i] <= a[i - 1])
{ /* a不是有序数组 */
return -1;
}
}
return 0;
}
/* 有序表输出函数 */
void print_array(int a[])
{
for (int i = 0; i < Count; i++)
{ /* 输出时相邻数字间用一个空格分开，行末无空格 */
if (i == 0)
{
printf("%d", a[i]);
}
else
{
printf(" %d", a[i]);
}
}
}
int insert(int a[], int value)
{
int i, j, flag = 0;
for (i = 0; i < Count; i++)
{
if (a[i] == value)
{
flag = 1;
break;
}
else
{
if (value < a[i])
{
break;
}
}
}
if (flag == 1)
{
return -1;
}
else
{
for (j = Count - 1; j >= i; j--)
{
a[j + 1] = a[j];
}
a[i] = value;
Count++;
}
return 0;
}
int del(int a[], int value)
{
int i, j, flag = 0;
for (i = 0; i < Count; i++)
{
if (a[i] == value)
{
flag = 1;
break;
}
}
if (flag == 0)
{
return -1;
}
else
{
for (j = i; j < Count - 1; j++)
{
a[j] = a[j + 1];
}
Count--;
}
return 0;
}
int modify(int a[], int value1, int value2)
{
if (del(a, value1) == -1)
{
return -1;
}
if (insert(a, value2) == -1)
{
return -1;
}
return 0;
}
int query(int a[], int value)
{
int left = 0, right = Count - 1, mid, flag = 0;
while (left <= right)
{
mid = (left + right) / 2;
if (value == a[mid])
{
flag = 1;
return mid;
}
else if (value < a[mid])
{
right = mid - 1;
}
else
{
left = mid + 1;
}
}
if (flag == 0)
{
return -1;
}
}运行结果： 
总结
以上为本篇文章的所有内容，后续将更新各个章节课后习题解析，如想了解更多，请持续关注该专栏。如有疑问或提供意见，请指出，谢谢！！！
文章内容参考： 程序咖
标签：10,return,struct,int,double,C语言,课后,printf,习题 From： https://blog.csdn.net/2301_80771046/article/details/137232743