教材课后题答案-第7章

习题7

一 单选题

1.设有如下定义，则表达式sizeof(y)的值是【 】。

struct data {long *ln; char c;

struct data *last,*next; }y; A.7 B.9 C.13 D.17 【答案】C

【解析】指针变量在内存中占用4个字节，所以sizeof(y)的值是4+1+4+4=13 2.设有以下程序段，则表达式的值不为100的是【 】。

struct st

{int a;int *b;}; void main()

{int m1[]={10,100},m2[]={100,200}; struct st *p,x[]={99,m1,100,m2}; p=x; ... }

A.*(++p->b)

B.(++p)->a

C.++p->a

D.(++p)->b 【答案】D

【解析】根据题意，p 指向x 数组，x[0]的b 成员指向m1数组，x[1]的b 成员指向m2数组，如图7-1所示。选项A 中p->b 指向m1[0]，通过“++”运算p->b 指向m1[1]，所以选项A 的表达式的值为100。选项B 中++p 使p 指向x[1]，x[1]的a 成员的值是100。选项C 中p 指向x[0]，x[0]的a 成员做“++”运算，结果为100。选项D 中++p 使p 指向x[1]，x[1]的b 成员的值是指针，所以选择选项D 。

m1m2p

图7-1

3.设有以下定义，且如图7-2所示，指针head 和p 指向链表的第一个结点，指针q 指向新的结点，则不能把新结点插入在第一个结点之前的语句是【 】。

head

p

q

图7-2

struct node

{int a;

struct node *next;

}*head,*p,*q;

A.head=q,q->next=p;

B.head=q,q->next=head;

C.q->next=head,head=q;

D.head=q,head->next=p;

【答案】B

4.设有如下结构体说明和变量定义，且如图7-3所示，指针p指向变量one，指针q指向变量two，则不能将结点two接到结点one之后的语句是【】。

p

图7- 3

struct node

{int n;

struct node *next;

}one,two,*p=&one,*q=&two;

A.p.next=&two;

B.(*p).next=q;

C.one.next=q;

D.p->next=&two;

【答案】A

【解析】p是指向结构体的指针，因此选项D是规范的引用方式。

5.设有以下定义，且如图7-4所示建立了链表，指针p、q分别指向相邻的两个结点，下列语句中【】不能将p所指向的结点删除。

head......

图7- 4

struct node

{int a;

struct node *link;

}*head,*p,*q;

A.q->link=p->link;

B.p=p->link,q->link=p;

C.(*p).link=(*q).link;

D.p=(*p).link,(*q).link=p;

【答案】C

6.以下选项中，能正确地将x定义为结构体变量的是【】。

A.struct

B.typedef struct st

{int i; {int i;

float j; float j;

}x; }x;

C.struct st

D.typedef st

{int i; {int i;

float j; float j;

} }

st x; st x;

【答案】A

【解析】选项C语法错误。

7.若有如下定义，则sizeof(struct no)的值是【】。

struct no

{int n1;

float n2;

union nu

{char u1[6];

double u2;

}n3;

};

A.12

B.14

C.16

D.10

【答案】C

【解析】4+4+max{6,8}=16。

8.设有如下定义，则下列叙述中正确的是【】。

typedef struct

{int s1;

float s2;

char s3[80];

}STU;

A.STU是结构体变量名

B.typedef struct是结构体类型名

C.STU是结构体类型名

D.struct是结构体类型名

【答案】C

9.设有如下定义，则引用共用体中h成员的正确形式为【】。

union un

{int h;char c[10];};

struct st

{int a[2];

union un h;

}s={{1,2},3},*p=&s;

A.p.un.h

B.(*p).h.h

C.p->st.un.h

D.s.un.h

【答案】B

10.以下各选项欲为float定义一个新的类型名，其中正确的是【】。

A.typedef float w1;

B.typedef w2 float;

C.typedef float=w3;

D.typedef w4=float;

【答案】A

二填空题

1.设有以下定义，则变量s在内存中占字节。

struct st

{char num[5];

int age;

float score;}s;

【答案】13

【解析】1×5+4+4=13。

2.以下程序用以输出结构体变量bt所占内存单元的字节数，请填上适当内容。

struct ps

{double i;

char arr[20];

};

void main()

{struct ps bt;

printf("bt size : %d\n", );

}

【答案】sizeof(struct ps)

3.若定义了struct{int d,m,n;}a,*b=&a;，可用a.d引用结构体成员，请写出引用结构体成员a.d 的其他两种形式【1】，【2】。

【答案】【1】(*b).d 【2】b->d

4.设有以下结构体类型的定义，请将结构体数组xy的定义补充完整。

struct ST

{char num[10];

int m;

struct ST *last,*next;

};

xy[10];

【答案】struct ST

5.以下是定义链表中结点的数据类型，请将定义补充完整。

struct node

{char name[20];

int score;

next;};

【答案】struct node*

6.设有以下定义，且建立了链表，如图7-5所示，指针p指向链表尾结点，指针q指向新结点，用语句可实现将新结点连接到链表尾部。

struct node

{int a;

struct node *link;

}*head,*p,*q;

【答案】(*p).link=q; （或p->link=q;）

head...

图7- 5

7.下列程序是将从键盘输入的一组字符作为结点的内容建立一个单向链表。要求输出链表内容时与输入时的顺序相反。填空将程序补充完整。

#include "stdio.h"

#include "stdlib.h"

struct node

{char d;

struct node *link;

};

void main()

{struct node *head,*p;

char c;

head=NULL;

while((c=getchar())!='\n')

{p=(struct node *)malloc(sizeof(struct node));

p->d=c;

p->link= 【1】;

head= 【2】;

}

p=head;

while(p->link!=NULL)

{printf("%c->",p->d);

p= 【3】;

}

printf("%c\n",p->d);

}

【答案】【1】head 【2】p 【3】p->link

【解析】第一个空应该填入新结点插入链表后它的下一个结点的地址。由于题目要求输出链表内容时与输入时的顺序相反，而且单向链表只能从头到尾输出，所以每次新结点必须作为第一个结点插入到链表，并使从前的第一个结点作为它的后续结点，这样做的结果恰好使生成的链表的顺序与输入顺序相反，因此第一个空填head。第二个空的内容应实现头指针指向新结点，所以填p。第三个空是在输出结点内容的循环中，输出一个结点后，指针需要后移，所以应填p->link。

8.下列函数的功能是在单向链表中查找最大值所在结点的地址。填空将函数补充完整。

struct node

{int data;

struct node *next;

};

struct node *found(struct node *head)

{struct node *p,*q;

int max;

p=head;max=p->data;q=p;

while(p->next!=NULL)

{ 【1】;

if(p->data>max){max=p->data; 【2】;}

}

return q;

}

【答案】【1】p=p->next 【2】q=p

【解析】在循环查找之前p和q都指向了第一个结点，并将第一个结点的数据假设为最大值。在循环查找的过程中，p指针需要顺着链表不断后移，所以第一个空应填p=p->next。q指针的作用是指向当前的最大值，这一点也可以从return q;看出，所以第二个空应填q=p。

9.设有以下定义和语句，请在printf语句中填上能够正确输出的变量及相应的格式说明。

union

{int n;

double x;

}num;

num.n=10;

num.x=10.5;

printf(" 【1】", 【2】);

【答案】【1】%lf 【2】num.x

10.下面欲为结构体类型struct st定义一个新的类型名STUDENT，请将定义补充完整。

struct st

{char num[10],name[20],sex;

float score;

};

typedef STUDENT;

【答案】struct st

三阅读程序，写出结果

1. #include "stdio.h"

struct st

{int a,b;

struct st *next;} x[3];

void main()

{int i;

struct st *p;

for(i=0;i<3;i++)

{x[i].a=i+1,x[i].b=i+2;x[i].next=&x[i+1];}

x[2].next=x;

for(p=x,i=0;i<3;i++)

{printf("%d",p->a);p=p->next;

printf("%d",p->b);p=p->next;

}

}

【答案】133224

【解析】x数组是一个结构体数组，通过第一个for循环以及其后的一个语句建立了一个环状链表。x[0]的next成员指向x[1]，x[1]的next成员指向x[2]，x[2]的next成员又指向了x[0]。所以在随后的循环输出中，通过p不断改变指向得到结果133224

2. #include "stdio.h"

struct stu

{int n;

char name[20];

int age;

};

void pri(struct stu *p)

{printf("%s\n",p->name);}

void main()

{struct stu s[4]={{200201,"zhao",19},{200202,"Qian",18},

{200203,"sum",19},{200204,"Li",18}};

pri(s+3);

}

【答案】Li

【解析】调用pri函数时，实参应该是结构体类型指针，s数组是一个结构体数组，s+3是s[3]的地址，所以通过函数调用语句pri(s+3);得到结果Li。

3. #include "stdio.h"

#include "stdlib.h"

struct node

{char ni;

struct node *next;

};

void main()

{struct node *head,*p;

int n=48;

head=NULL;

do

{p=(struct node *)malloc(sizeof(struct node));

p->ni=n%8+48;

p->next=head;

head=p;

n=n/8;

}

while(n!=0);

p=head;

while(p!=NULL)

{printf("%c",p->ni);

p=p->next;

}

}

【答案】60

【解析】在此程序中head为链表的头指针，p指向新结点。在do-while循环中通过p->next=head;和head=p;语句，总是将新结点链接在链表的第一个结点的位置。这样在while 循环中输出链表各结点内容时，就形成了一种与新结点产生顺序相反的结果。至于结点数据域的内容（n%8+48）是整数n除以8的余数的ASCII值，然后n再整除8，通过循环重复计算，直到n为0结束。程序的结果是逆序输出这些余数，这个算法实现了十进制数转换为八进制数。

4. #include "stdio.h"

#include "stdlib.h"

void fun(int **p,int x[2][3])

{**p=x[1][1];}

void main()

{int y[2][3]={1,2,3,4,5,6},*t;

t=(int *)malloc(4);fun(&t,y);printf("%d\n",*t);

}

【答案】5

【解析】其中y[0][0]=1，y[0][1]=2，y[0][2]=3，y[1][0]=4，y[1][1]=5，y[1][2]=6，

5. #include "stdio.h"

union un

{int x;

struct

{int a,b,c;}y;

}z;

void main()

{z.x=5;

z.y.a=1;z.y.b=2;z.y.c=3;

printf("%d\n",z.x);

}

【答案】1

四编程题

1.定义一个结构体数组，存放10个学生的信息，每位学生的信息是一个结构体类型数据，其成员分别为：学号、姓名、五门成绩及总分。要求编写3个函数，它们的功能分别为：①输入函数，用于从键盘读入学号、姓名和五门成绩；②计算总分函数，用于计算每位学生的总分；③输出函数，显示每位学生的学号、姓名和总分。这3个函数的形式参数均为结构体指针和整型变量，函数的类型均为void。

【程序】

#include "stdio.h"

#include "stdlib.h"

struct st

{char num[8],name[20];

int score[5],total;

};

void insub(struct st *p,int n) /*输入学生信息函数*/

{int i,j;

for(i=0;i

{printf("Input number:\n");

scanf("%s",p->num);

printf("Input name:\n");

scanf("%s",p->name);

printf("Input 5 scores:\n");

for(j=0;j<5;j++)

scanf("%d",&p->score[j]);

}

}

void sumsub(struct st *p,int n) /*计算总分函数*/

{int i,j;

for(i=0;i

{p->total=0;

for(j=0;j<5;j++)

p->total+=p->score[j];

}

}

void outsub(struct st *p,int n) /*输出学生总分函数*/

{int i;

printf("number name total\n");

for(i=0;i

printf("%-8s %-20s %4d\n",p->num,p->name,p->total); }

void main()

{struct st x[10];

insub(x,3); /*调试程序时将10改为3*/ sumsub(x,3);

outsub(x,3);

}

【运行情况】

Input number:

0311010↙

Input name:

zhuming↙

Input 5 scores:

78 84 90 73 82↙

Input number:

0311011↙

Input name:

yanweifeng↙

Input 5 scores:

85 88 79 76 92↙

Input number:

0311012↙

Input name:

mifangzhou↙

Input 5 scores:

80 77 89 87 80↙

number name total

0311010 zhuming 407

0311011 yanweifeng 420

0311012 mifangzhou 413

2.编写一个creat函数，其功能是用键盘输入的字符序列建立一个具有头结点的单向链表，新结点总是追加在链表的尾部，字符序列以’#’为结束标志，函数的返回值是链表的头指针。

【思路】首先定义链表结点的数据类型，数据域部分应是一个字符型成员。然后定义三个指针，h作为链表的头指针，p指针用于创建新结点，q指针用于指向链表的尾结点。由于头结点的数据域部分不需要存放数据，所以用p指针创建新结点后，可以直接让h和q指针指向它，使其成为头结点和尾结点。将变量C用于存放键盘输入的字符，如果输入的不是“#”，则将其存入新结点的数据域，然后继续输入字符；否则完成链表的创建。

【程序】

#include "stdio.h"

#include "stdlib.h"

struct node

{char data;

struct node *next;

};

struct node *create()

{struct node *h,*p,*q;

char c;

p=(struct node *)malloc(sizeof(struct node));

h=q=p; /*将新结点作为头结点和尾结点*/

c=getchar();

while(c!='#')

{p=(struct node *)malloc(sizeof(struct node));

p->data=c; /*将字符存入新结点的数据域*/

q->next=p; /*新结点链接到链表的尾部*/

q=p; /*q指针指向新的尾结点*/

c=getchar();

}

p->next=NULL; /*存入链表结束标志*/

return h;

}

3.用一个链表表示一个一元n次多项式，每个结点的数据部分包括指数和系数。例如，多项式2x5-3x4+6x-7，可用下面的链表表示：

图7- 6

编写一个程序，要求包括两个函数，①建立一元n次多项式链表函数；②输出一元n 次多项式链表函数（将多项式中指数形式以X^n形式输出），并从主函数调用这两个函数完成一元n次多项式链表的建立和输出。

【思路】首先在定义链表中结点的数据结构时，其数据域部分应定义为三个成员，分别用于存放指数、系数和下一个结点的地址。其次在编制建立链表函数时，根据一元n次多项式特点，将X0项作为结束标志，所以此项系数为0是也要输入。最后在编制输出链表函数时，应考虑的几点问题，第一，系数的符号输出；第二，系数为0时不输出此项，系数为1时省略系数；第三，指数为0时仅输出系数，指数为1时省略指数。

【程序】

#include "stdio.h"

#include "stdlib.h"

struct node

{int exp,co;

struct node *next;

};

struct node *creat() /*建立链表函数*/

{static struct node *h;

struct node *p,*q;

h=NULL;

do

{p=(struct node *)malloc(sizeof(struct node));

printf("Input the exponent:\n");

scanf("%d",&p->exp);

printf("Input the coefficient:\n");

scanf("%d",&p->co);

p->next=NULL;

if(h==NULL)

h=p;

else

q->next=p;

q=p;

}while(p->exp!=0); /*当最新输入的一项的指数为0时结束输入*/ return h;

}

void print(struct node *head) /*输出链表函数*/

{struct node *p;

p=head;

if(p->co!=1)printf("%d",p->co); /*如果系数不是1，则打印系数*/

if(p->exp==1) /*如果指数是1，则不打印指数*/ printf("X");

printf("X^%d",p->exp);

p=p->next;

while(p!=NULL)

{if(p->co!=0) /*如果系数不为0，则打印此项*/ {if(p->co>=0) /*打印各项的系数符号*/

printf("+");

else

printf("-");

if(p->exp!=0) /*判断各项指数是否为0*/

{if(abs(p->co)!=1)

printf("%d",abs(p->co)); /*系数绝对值不为1时打印*/

if(p->exp==1) /*指数为1时省略*/

printf("X");

else

printf("X^%d",p->exp);

}

else /*指数为0，仅打印系数*/

printf("%d",abs(p->co));

}

p=p->next;

}

}

void main()

{struct node *head;

head=creat();

print(head);

}

【运行情况】

Input the exponent:

5↙

Input the coefficient:

2↙

Input the exponent:

4↙

Input the coefficient:

-3↙

Input the exponent:

1↙

Input the coefficient:

6↙

Input the exponent:

0↙

Input the coefficient:

2X^5-3X^4+6X-7

4.编写一个程序，运用插入结点方法，将键盘输入的n个整数插入到链表中，建立一个从小到大的有序链表。

【思路】运用插入法建立有序链表时，每插入一个结点都需要三个步骤：第一，开辟新结点；第二，查找插入位置；第三，将新结点链接到链表。第二、第三步是关键，可编制一个插入链表结点函数。设head为头指针，指向链表的第一个结点。p0为指向新结点的指针。p和q为工作指针，利用p指针查找插入位置，q指针为p指针的前导指针。新结点插入到链表时共有四种情况：

①空表时插入（当head==NULL）；

②在表头插入（当p0->d<=head->d）；

③在表中间插入（p0->d<=p->d）；

④在表尾追加（p0->d>p->d&&p->next==NULL）。

算法如图7-7所示。

图7-7

【程序】

#include "stdio.h"

#include "stdlib.h"

#define LEN sizeof(struct litem)

struct litem

{int d;

struct litem *next;

};

struct litem *insert(struct litem *head,struct litem *p0)/*插入结点函数*/

{struct litem *p,*q;

if(head==NULL)

head=p0;

else

{p=head;

while(p0->d>p->d&&p->next!=NULL) /*寻求插入点*/

{q=p;p=p->next;}

if(p0->d<=p->d)

{if(p==head) /*插在第一个结点位置*/

head=p0;

else /*插在链表中间位置*/

q->next=p0;

p0->next=p;

}

else /*插在表尾位置*/ p->next=p0;

}

return(head);

}

main()

{struct litem *head=NULL,*tem,*p;

int n,i;

printf("Input n:");

scanf("%d",&n);

printf("Input %d numbers:\n",n);

for(i=1;i<=n;i++)

{tem=(struct litem *)malloc(LEN);

scanf("%d",&tem->d);

tem->next=NULL;

head=insert(head,tem);

}

p=head;

while(p->next!=NULL)

{printf("%d->",p->d);

p=p->next;

}

printf("%d\n",p->d);

}

【运行情况】

Input n:5↙

Input 5 numbers:

3 5 2 8 1↙

1->2->3->5->8

5.在TC环境下编写一个程序，实现从键盘输入一个unsigned long型整数，然后将其前两个字节和后两个字节分别作为两个unsighned int型整数在显示器输出（提示：使用共用体类型数据实现）。

【程序】

#include "stdio.h"

main()

{union

{unsigned long a;

unsigned int b[2];}x;

scanf("%lu",&x.a);

printf("%u %u\n",x.b[0],x.b[1]); }

【运行结果】（TC下运行结果）65566↙

30 1

【运行结果】（VC下运行结果）65566↙

65566 3435973836