当前位置：文档库 › 结构体习题

结构体习题

二级C语言教程章节测试 14.结构体与共用体及用户定义类型
https://www.wendangku.net/doc/3e2344514.html,　作者：mingjin整理　来源：希赛网　2007年1月30日　发表评论　进入社区
一、选择题：
（1）有以下程序段
typedef struct NODE
{ int num; struct NODE *next;
} OLD;
以下叙述中正确的是
A）以上的说明形式非法 B）NODE是一个结构体类型
C）OLD是一个结构体类型 D）OLD是一个结构体变量

（2）有以下程序
# include
struct STU
{ int num;
float TotalScore; };
void f（struct STU p）
{ struct STU s[2]={{20044,550},{20045,537}};
p.num = s[1].num; p.TotalScore = s[1].TotalScore;
}
main（）
{ struct STU s[2]={{20041,703},{20042,580}};
f（s[0]）;
printf（"%d %3.0f\n", s[0].num, s[0].TotalScore）;
}
程序运行后的输出结果是
A）20045 537 B）20044 550 C）20042 580 D）20041 703

（3）有以下程序
# include
struct STU
{ char name[10];
int num; };
void f（char *name, int num）
{ struct STU s[2]={{"SunDan",20044},{"Penghua",20045}};
num = s[0].num;
strcpy（name, s[0].name）;
}
main（）
{ struct STU s[2]={{"YangSan",20041},{"LiSiGuo",20042}},*p;
p=&s[1]; f（p->name, p->num）;
printf（"%s %d\n", p->name, p->num）;
}
程序运行后的输出结果是
A）SunDan 20042 B）SunDan 20044
C）LiSiGuo 20042 D）YangSan 20041

（4）有以下程序
struct STU
{ char name[10]; int num; float TotalScore; };
void f（struct STU *p）
{ struct STU s[2]={{"SunDan",20044,550},{"Penghua",20045,537}}, *q=s;
++p ; ++q; *p=*q;
}
main（）
{ struct STU s[3]={{"YangSan",20041,703},{"LiSiGuo",20042,580}};
f（s）;
printf（"%s %d %3.0f\n", s[1].name, s[1].num, s[1].TotalScore）;
}
程序运行后的输出结果是
A）SunDan 20044 550 B）Penghua 20045 537
C）LiSiGuo 20042 580 D）SunDan 20041 703

（5）若有以下说明和定义
union dt
{
int a; char b; double c;
}data;
以下叙述中错误的是
A）data的每个成员起始地址都相同
B）变量data所占内存字节数与成员c所占字节数相等
C）程序段：data.a=5;printf（"%f\n",data.c）;输出结果为5.000000
D）data可以作为函数的实参

（6）设有如下说明
typedef struct ST
{
long a;
int b;
char c[2];
} NEW;
则下面叙述中正确的是
A）以上的说明形式非法
B）ST是一个结构体类型
C）NEW是一个结构体类型
D）NEW是一个结构体变量

（7）有以下结构体说明和变量定义，如图所示，指针pqr分别指向此链表中三个连续结点。
struct node
{
int data;
struct node *next;
} *p,*q,*r;
现要将q所指结点从链表中删除，同时保持链表的连续,以下不能完成指定操作的语句是
A）p->next=q->next;
B）p->next=p->next->next;
C）p->next=r;
D）p=q->next;

（8）以下对结构体类型变量td的定义中，错误的是
A）typedef struct aa
{
int n;
float m;
}AA;
AA td;
B）struct aa
{
int n;
float m;
} td;
struct aa td;
C）struct
{
int n;
float m;
}aa;
struct aa td;
D）struct
{
int n;
float m;
}td;

（9）有以下说明和定义语句
struct student
{ int age; char num[8];};
struct student stu[3]={{20,"200401"},{21,"200402"},{10\9,"200403"}};
struct student *p=stu;
以下选项中引用结构体变量成员的表达式错误的是
A）（p++）->num B） p->num C）（*p）.num D） stu[3].age
10～12.以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转储到链表的各个结点中，请从与下划线处号码对应的一组选若中选择出正确的选项。
#include
stuct node
{ char data; struct node *next;};
（10） CreatList（char *s）
{ struct node *h,*p,*q）;
h=（struct node *） malloc（sizeof（struct node））;
p=q=h;
while（*s!='\0'）
{ p=（struct node *） malloc（sizeof（struct node））;
p->data= （11） ;
q->next=p;
q= （12） ;
s++;
}
p->next='\0';
return h;
}
main（）
{ char str[]="link list";
struct node *head;
head=CreatList（str）;
...
}

（10） A） char * B） struct node C） struct node* D） char
（11） A） *s B） s C） *s++ D）（*s）++

（12） A） p->next B） p C） s D） s->next

（13）设有以下语句
typedef struct S
{ int g; char h;} T;
则下面叙述中正确的是
A）可用S定义结构体变量 B）可以用T定义结构体变量
C）S是struct类型的变量 D）T是struct S类型的变量

（14）有以下程序
struc STU
{ char name[10];
int num;
};
void f1（struct STU C）
{ struct STU b={“LiSiGuo”,2042};
c=b;
}
void f2（struct STU *C）
{ struct STU b={“SunDan”,2044};
*c=b;
}
main（）
{ struct STU a={“YangSan”,2041},b={“WangYin”,2043};
f1（A） ;f2（&B） ;

printf（“%d %d\n”,a.num,b.num）;
}
执行后的输出结果是
A）2041 2044 B）2041 2043 C）2042 2044 D）2042 2043

（15）有以下程序
struct STU
{ char name[10];
int num;
int Score;
};
main（）
{ struct STU s[5]={{“YangSan”,20041,703},{“LiSiGuo”,20042,580},
{“wangYin”,20043,680},{“SunDan”,20044,550},
{“Penghua”,20045,537}},*p[5],*t;
int i,j;
for（i=0;i<5;i++） p[i]=&s[i];
for（i=0;i<4;i++）
for（j=i+1;j<5;j++）
if（p[i]->Score>p[j]->Score）
{ t=p[i];p[i]=p[j];p[j]=t;}
printf（“5d %d\n”,s[1].Score,p[1]->Score）;
}
执行后输出结果是
A） 550 550 B） 680 680 C） 580 550 D） 580 680

（16）有以下程序
#include
struct NODE{
int num;
struct NODE *next;
};
main（）
{ struct NODE *p,*q,*r;
int sum=0;
p=（struct NODE *）malloc（sizeof（struct NODE））;
q=（struct NODE *）malloc（sizeof（struct NODE））;
r=（struct NODE *）malloc（sizeof（struct NODE））;
p->num=1;q->num=2;r->num=3;
p->next=q;q->next=r;r->next=NULL;
sum+=q->next->num;sum+=p->num;
printf（“%d\n”,sum）;
}
执行后的输出结果是
A） 3 B） 4 C） 5 D） 6

（17）以下选项中不能正确把c1定义成结构体变量的是
A） typedef struct B） struct color cl
{ int red; { int red;
int green; int green;
int blue; int blue;
} COLOR; };
COLOR cl;
C） struct color D） struct
{ int red; { int red;
int green; int green;
int blue; int blue;
} c l; } c l ;

（18）有以下程序
struct s
{ int x,y;} data[2]={10,100,20,200};
main （）
{ struct s *p=data;
printf（"%d\n",++（p->x））;
}
程序运行后的输出结果是
A） 10 B） 11 C） 20 D）21

（19）有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。
struct node
{ int data
struct node *next ;
} *p, *q, *r;

现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是
A） r->next=q; q->next=r->next; p->next=r;
B） q->next=r->next; p->next=r; r->next=q;
C） p->next=r; q->next=r->next; r->next=q;
D） q->next=r->next; r->next=q; p->next=r;

（20）设有如下说明
typedef struct
{ in

t n; char c; double x;}STD;
则以下选项中，能正确定义结构体数组并赋初值的语句是
A） STD tt[2]={{1,'A',62},{2, 'B',75}};
B） STD tt[2]={1,"A",62},2, "B",75};
C） struct tt[2]={{1,'A'},{2, 'B'}};
D）structtt[2]={{1,"A",62.5},{2, "B",75.0}};

（21）有以下程序
main（）
{ union { unsigned int n;
unsigned char c;
}u1;
ul.c=｀A｀;
printf（"%c\n",u1.n）;
}
执行后输出结果是
A）产生语法错 B）随机值 C） A D） 65

（22）若要说明一个类型名STP，使得定义语句STP s等价于char *s，以下选项中正确的是
A） typedef STP char *s; B） typedef *char STP;
C） typedef stp *char; D） typedef char* STP;

（23）设有如下定义
struct ss
{ char name[10];
int age;
char sex;
}std[3],*p=std;
下面各输入语句中错误的是
A） scanf（"%d",&（*p）.age）; B） scanf（"%s",&https://www.wendangku.net/doc/3e2344514.html,）;
C） scanf（"%c",&std[0].sex） D） scanf（"%c",&（p->sex））;

（24）有以下程序
struct STU
{ char num[10]; float score[3]; };
main（）
{ struct stu s[3]={{“20021”,90,95,85},
{“20022”,95,80,75},
{“20023”,100,95,90}},*p=s;
int i; float sum=0;
for（i=0;i<3,i++）
sum=sum+p->score[i];
printf（“%6.2f\n”,sum）;
}
程序运行后的输出结果是
A） 260.00 B） 270.00 C） 280.00 D） 285.00

（25）设有如下定义：
struck sk
{ int a;
float b;
}data;
int *p;
若要使P指向data中的a域，正确的赋值语句是
A） p=&a; B） p=data.a; C） p=&data.a; D） *p=data.a;

（26）有以下程序
#include
struct NODE
{ int num; struct NODE *next; };
main（）
{ struct NODE *p,*Q,*R;
p=（struct NODE*）malloc（sizeof（struct NODE））;
q=（struct NODE*）malloc（sizeof（struct NODE））;
r=（struct NODE*）malloc（sizeof（struct NODE））;
p->num=10; q->num=20; r->num=30;
p->next=q;q->next=r;
printf（“%d\n”,p->num+q->next->num）;
}
程序运行后的输出结果是
A） 10 B） 20 C） 30 D） 40

（27）若有以下说明和定义
typedef int *INTEGER;
INTEGER p,*q;
以下叙述正确的是
A） P是int型变量 B） p是基类型为int的指针变量
C） q是基类型为int的指针变量 D）程序中可用INTEGER代替int类型名

（28）若有下面的说明和定义：
struct test
{ int ml; char m2; float m3;
union uu {char ul[5]; int u2[2];} ua;
} myaa;
则sizeof（struct test ）的值是
A） 12 B） 16 C） 14 D） 9

（29）若以下定义:
struct link
{ int data;
struck link *next;
}a,b,c,*p,*q;

且变量a和b之间已有如下图所示的链表结构:
a b
data next data next

↑p
c
data next

↑q
指针p指向变量a,q指向变量c。则能够把c插入到a和b 之间并形成新的链表的语句组是:
A） a.next=c; c.next=b; B） p.next=q; q.next=p.next;
C） p->next=&c; q->next=p->next; D）（*p）.next=q; （*q）.next=&b;

（30）设有以下说明语句
typedef struct
{ int n;
char ch[8];
}PER;
则下面叙述中正确的是
A） PER 是结构体变量名 B） PER是结构体类型名
C） typedef struct 是结构体类型 D） struct 是结构体类型名

（31）以下各选项企图说明一种新的类型名，其中正确的是
A） typedef v1 int; B） typedef v2=int;
C） typedefv1 int v3; D） typedef v4: int;

（32）以下程序的输出结果是
struct HAR
{ int x, y; struct HAR *p;} h[2];
main（）
{ h[0],x=1;h[0];y=2;
h[1],x=3;h[1];y=4;
h[0],p=&h[1],p=h;
printf（“%d %d \n”,（h[0],p）->x,（h[1],p）->y）;
}
A） 12 B） 23 C） 14 D） 32

（33）以下程序的输出结果是
union myun
{ struct
{ int x, y, z; } u;
int k;
} a;
main（）
{ a.u.x=4; a.u.y=5; a.u.z=6;
a.k=0;
printf（%d\n”,a.u.x）;
}
A） 4 B） 5 C） 6 D） 0

（34）设有以下说明语句
struct ex
{ int x ; float y; char z ;} example;
则下面的叙述中不正确的是
A） struct结构体类型的关键字 B） example是结构体类型名
C） x,y,z都是结构体成员名 D） struct ex是结构体类型

（35）以下程序的输出是
A） 10 B） 11 C） 51 D） 60
struct st
{ int x; int *y;} *p;
int dt[4]={ 10,20,30,40 };
struct st aa[4]={ 50,&dt[0],60,&dt[0],60,&dt[0],60,&dt[0],};
main（）
{ p=aa;
printf（“%d\n”,++（p->x））;
}

（36）假定建立了以下链表结构，指针p、q分别指向如图所示的结点，则以下可以将q所指结点从链表中删除并释放该结点的语句组是
A） free（q）; p->next=q->next;
B）（*p）.next=（*q）.next; free（q）;
C） q=（*q）.next; （*p）.next=q; free（q）;
D） q=q->next; p->next=q; p=p->next; free（p）

（37）有如下定义
struct person{char name[9]; int age;};
strict person class[10]={“Johu”, 17,
“Paul”, 19
“Mary”, 18,
“Adam 16,};
根据上述定义，能输出字母M的语句是
A） prinft（“%c\n”,class[3].mane）;
B） pfintf（“%c\n”,class[3].name[1]）;
C） prinft（“%c\n”,class[2].name[1]）;
D） prin

tf（“%^c\n”,class[2].name[0]）;

（38）以下对结构体类型变量的定义中，不正确的是
A） typedef struct aa B） #define AA struct aa
{ int n; AA {int n;
float m; float m;
}AA; }td1;
AA td1;
C） struct D） struct
{ int n; { int n;
float m; float m;
}aa; }td1;
stuct aa td1;

（39）若已建立如下图所示的单向链表结构，

在该链表结构中，指针p、s分别指向图中所示结点，则不能将s所指的结点插入到链表末尾仍构成单向链表的语句组是
A） p =p->next; s->next=p; p->next=s;
B） p =p->next; s->next=p->next; p->next=s;
C） s->next=NULL; p=p->next; p->next=s;
D） p=（*p）.next; （*s）.next=（*p）.next; （*p）.next=s;

（40）下列程序的输出结果是
A） 5 B） 6 C） 7 D） 8
struct abc
{ int a, b, c; };
main（）
{ struct abc s[2]={{1,2,3},{4,5,6}}; int t;
t=s[0],a+s[1],b;
printf（"%d \n",t）;
}

（41）有以下结构体说明和变量的定义,且如下图所示指针p指向变量a,指针q指向变量b。则不能把结点b连接到结点a之后的语句是
A） a.next=q; B） p.next=&b;
C） p->next=&b; D）（*p）.next=q;
struct node
{ char data;
struct node *next;
{ a,b,*p=&a,*q=&b;
data next data next

（42）变量a所占内存字节数是
A） 4 B） 5 C） 6 D） 8
union U
{ char st[4];
int i;
long l;
};
struct A
{ int c;
union U u;
}a;

（43）以下选项中，能定义s为合法的结构体变量的是
A） typedef struct abc B） struct
{ double a； { double a；
char b[10]； char b[10]；
} s； } s；
C） struct ABC D） typedef ABC
{ double a； { double a；
char b[10]； char b[10]；
} }
ABC s； ABC s；

（44）以下程序的输出结果是
A） 2 B） 1 C）0 D）不确定
main（）
{ union { char i[2];
int k;
}r;
r.i[0]=2;

r.i[1]=0;
printf{“%d\n”,r.k};
}

（45）设有以下定义或语句，则输出的结果是（指针变量占两个字节）
A） 20 B） 16 C） 14 D）12
struct date
{ long *cat;
struct date *next;
double dog;
}too;
printf（“%d\n”,sizeof（too））;

（46）有以下程序
#include
struct stu
{ int num;
char name[10];
int age;
};
void fun（struct stu *p）
{ printf（"%s\n",（*p）.name）; }
main（）
{
struct stu students[3]={ {9801,"Zhang",20},
{9802,"Wang",19},
{9803,"Zhao",18} };
fun（students+2）;
}
输出结果是
A） Zhang B）Zhao C） Wang D） 18

（47）设有以下说明和定义:
typedef union
{ long i; int k[5]; char c; }DATE;
struct date
{ int cat; DATE cow; double dog; } too;
DATE max;
则下列语句的执行结果是
printf （"%d",sizeof （struct date ） +sizeof（max））;
A） 26 B） 30 C） 18 D） 8

（48）设有如下定义:
struct sk
{int a;float b;}data,*p;
若有p=&data;，则对data中的a域的正确引用是
A）（*p）.data.a B）（*p）.a C）p->data.a D）p.data.a

（49）若程序中有下面的说明和定义
struct abc
{int x;char y;}
struct abc s1,s2;
则会发生的情况是
A）编译进错 B）程序将顺利编译`连接`执行
C）能顺利通过编译`连接`但不能执行 D）能顺利通过编译`但连接出错

（50）若有下面的说明和定义，则sizeof（struct aa）的值是
struct aa
{ int r1;double r2; float r3;
union uu{char u1[5]; long u2[2]; } ua;
} mya;
A）30 B）29 C）24 D）22

（51）字符'0'的ASCII码的十进制数为48,且数组的第0个元素在低位,则以下程序的输出结果是
#include
main（）
{ union { int i[2]; long k; char c[4]; }r,*s=&r;
s->i[0]=0x39;
s->i[1]=0x38;
printf（"%c\n",s->c[0]） }
A） 39 B） 9 C） 38 D） 8

（52）设有以下定义:
typedef union { long i;int k[5];char c;}DATE;
struct date { int cat;DATE cow;double dog;}too;
DATE max;
则下列语句的执行结果是
printf（"%d",sizeof（struct date）+sizeof（max））;
A） 25 B） 30 C） 18 D） 8

（53）根据下面的定义，能打印出字母M的语句是
A） printf（"%c\n",class[3].name）;
D） printf（"%c\n

",class[2].name[0]）;
B） printf（"%c\n",class[3].name[1]）;
C） printf（"%c\n",class[2].name[1]）;
struct person { char name[9]; int age;};
struct person class[10]={"John",17,
"Paul",19,
"Mary",18,
"Adam",16};

（54）下面程序的输出是
A） 0 B） 1 C） 3 D） 6
main（）
{ struct cmplx { int x; int y; } cnum[2]={1,3,
2,7};
printf（"%d\n",cnum[0].y /cnum[0].x * cnum[1].x）;}

（55）已知字符0的ASCII码为十六进制的30，下面程序的输出是
A） 6 B） 9 C） 0 D） 3
main（）
{ union { unsigned char c;
unsigned int i[4];
} z;
z.i[0]=0x39;
z.i[1]=0x36;
printf（"%c\n",z.c）;}

（56）下面程序的输出是
A） 32 B） 16 C） 8 D） 24
typedef union { long x[2];
int y[4];
char z[8];
} MYTYPE;
MYTYPE them;
main（）
{ printf（"%d\n", sizeof（them））;}

（57）若已建立下面的链表结构，指针p、s分别指向图中所示的结点，则不能将s所指的结点插入到链表末尾的语句组是
A） s->next=NULL; p=p->next; p->next=s;
B） p=p->next; s->next=p->next; p->next=s;
C） p=p->next; s->next=p; p->next=s;
D） p=（*p）.next; （*s）.next=（*p）.next; （*p）.next=s;

（58）下面程序的输出结果为
struct st
{ int x;
int *y;
} *p;
int dt[4]={10,20,30,40};
struct st aa[4]={ 50,&dt[0],60,&dt[1],
70,&dt[2],80,&dt[3] };
main（）
{ p=aa;
printf（"%d\n", ++p->x ）;
printf（"%d\n", （++p）->x）;
printf（"%d\n", ++（ *p->y））;
}
A） 10 B） 50 C） 51 D） 60
20 60 60 70
20 21 21 31

（59）有以下程序：
#include
union pw
{ int i; char ch[2]; } a;
main（）
{ a.ch[0]=13; a.ch[1]=0; printf（"%d\n",a.i）; }
程序的输出结果是（注意： ch[0]在低字节，ch[1]在高字节。）
A） 13 B） 14 C） 208 D） 209

（60）设有以下语句：
struct st {int n; struct st *next;};
static struct st a[3]={5,&a[1],7,&a[2],9,'\0'},*p;
p=&a[0];
则表达式　【60】的值是6。
A）p + + ->n B） p->n + + C）（*p）.n + + D） + + p->n

二、填空题:

（1）以下程序运行后的输出结果是【1】。
struct NODE
{ int num; struct NODE *next;
} ;
main（）
{ struct NODE s[3]={{1, '\0'},{2, '\0'},{3, '\0'}}, *p, *q, *r;
int sum=0;
s[0].next=s+1; s[1].next=s+2; s[2].next=s;
p=s; q=p->next; r=q->next;

sum+=q->next->num; sum+=r->next->next->num;
printf（"%d\n", sum）;
}

（2）以下程序运行后的输出结果是【2】。
struct NODE
{ int k;
struct NODE *link;
};
main（）
{
struct NODE m[5],*p=m,*q=m+4;
int i=0;
while（p!=q）
{ p->k=++i; p++;
q->k=i++; q--;
}
q->k=i;
for（i=0;i<5;i++）
printf（"%d",m[i].k）;
printf（"\n"）;
}

（3）以下程序的运行结果是【3】
# include
typedef struct student{
char name[10];
long sno;
float score;
}STU;
main（）
{ STU
a={“zhangsan”,2001,95},b={“Shangxian”,2002,90},c={“Anhua”,2003,95},d,*p=&d;
d=a;
if（strcmp（https://www.wendangku.net/doc/3e2344514.html,,https://www.wendangku.net/doc/3e2344514.html,）>0） d=b;
if（strcmp（https://www.wendangku.net/doc/3e2344514.html,,https://www.wendangku.net/doc/3e2344514.html,）>0） d=c;
printf（“%ld%s\n”,d.sno,p->name）;
}

（4）已有定义如下：
struct node
{ int data;
struct node *next;|
} *p;
以下语句调用malloc函数，使指针p指向一个具有struct node类型的动态存储空间。
请填空。
p=（struct node *） malloc（【4】）;

（5）设有以下定义
struct ss
{ int info;struct ss *link;}x,y,z;
且已建立如下图所示链表结构：请写出删除点y的赋值语句【5】。

（6）下面程序的运行结果是： [6] 。
typedef union student
{ char name[10];
long sno;
char sex;
float score[4];
}STU;
main（）
{ STU a[5];
printf（“%d\n”,sizeof（a））;
}

（7）以下定义的结构体类型拟包含两个成员,其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针.请将定义补充完整。
struct node
{int info;
【7】 link;
}

（8）以下程序段用于构成一个简单的单向链表，请填空。
struct STRU
{ int x, y ;
float rate;
【8】 p;
} a, b;
a.x=0; a.y=0; a.rate=0; a.p=&b;
b.x=0; b.y=0; b.rate=0; b.p=NULL;

（9）若有如下结构体说明：
struct STRU
{ int a, b ; char c; double d:
struct STRU p1,p2;
};
请填空，以完成对t数组的定义，t数组的每个元素为该结构体类型
【9】 t[20];

（10）以下程序用来输出结构体变量ex所占存储单元的字节数，请填空。
struct st
{ char name[20]; double score; };
main（）
{ struct st ex;
printf（“ex size: %d\n”,sizeof（【10】））;
}

（11）设有以下结构类型说明和变量定义，则变量a在内存所占字节数是 [11]

。
Struct stud
{ char num[6];
int s[4];
double ave;
} a,*p;

（12）有以下定义和语句，则sizeof（a）的值是【12】 ,而sizeof（a.share）的值是【13】
struct date{ int day;
int month;
int year;
union{int share1
float share2;
}share;
}a;

（13）若以下定义和语句,则sizeof（a）的值是【14】 ,而sizeof（b）的值是【15】
struct { int day; char mouth; int year;} a, *b;
b=&a;

（14）变量root有如图所示有存储结构,其中sp是指向字符串的指针域,next 是指向该结构的指针域,data用以存放整型数. 请填空 , 完成此结构的类型说明和变量root的定义
sp next data
┌─┬─┬─┐
root│ │ │ │
└─┴─┴─┘
struct list
{ char *sp;
【16】 ;
【17】 ;
}root;

（15）有以下说明定义和语句，可用a.day引用结构体成员day, 请写出引用结构体成员a.day的其它两种形式【18】、【19】。
struct{int day;char mouth;int year;}a,*b; b=&a;

（16）现有如图所示的存储结构，每个结点含两个域，data是指向字符串的指针域，next是指向结点的指针域。请填空完成此结构的类型定义和说明。
struct link
{【20】 ; 【21】;} *head;

（17）以下函数creat用来建立一个带头结点的单向链表，新产生的结点总是插在链表的末尾。单向链表的头指针作为函数值返回.请填空:
#include
struct list { char data; struct list * next; };
struct list * creat（）
{ struct list * h,* p,* q;
char ch;
h=【22】 malloc（sizeof（struct list））;
p=q=h;
ch=getchar（）;
while（ch!='?'）
{ p=【23】 malloc（sizeof（struct list））;
p->data=ch;
p->next=p;
q=p;
ch=getchar（）;
}
p->next='\0';
【24】

（18）下面min3函数的功能是：计算单向循环链表first中每3个相邻结点数据域中值的和，返回其中最小的值。请填空。
struct node {int data; struct node * link;};
int min3（struct node * first）
{ struct node *p=first;
int m,m3=p->data+p->link->data+p->link->link->data;
for（p=p->link; p! =first; p= 【25】）
int m,m3=p->data+p->link->data+p->link->link->data;
{ m=p->data+p->link->data+p->link->link->data;
if（【26】） m3=m;}
return（m3）;}

（19）若有以下说明和定义语句，则变量w在内存中所占的字节数是【27】。
union aa
{ float x, y;
char c[6];
};
struct st { union aa v; float w[5]; double ave; } w;

（20）为了建立如图所示的存储结构（即每个结点含两个域，data是数据域，next是向结点的指针域），请填空。
data next

struct link { char data; 【28】 } node;

（21）以下程序建立了一个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入数据为-1时，表示输入结束（链表头结点的data 域不放数据，表空的条件是ph->next = = NULL）.
#include
struct list { int data;struct list *next;};
【29】 creatlist（）
{ struct list *p,*q,*ph; int a;
ph=（struct list *） malloc（sizeof（struct list））;
p=q=ph; printf（"Input an integer number,enter –1 to end:\n"）;
scanf（"%d",&a）:
while（a!=-1）
{ p=（struct list *）malloc（sizeof（struct list））;
p->data=a; q->next=p; 【30】 =p; scanf（"%d",&a）; }
p->next='\0'; return（ph）; }
main（）
{ struct list *head; head=creatlist（）;}
答案：
一、选择题：
1） C 2） D 3） A 4） B 5） C 6） C 7） D 8） C 9） D 10） C
11） A 12） B 13） B 14） A 15） C 16） B 17） B 18） B 19） A 20） B
21） A 22） D 23） B 24） B 25） C 26） D 27） B 28） A 29） D 30） B
31） C 32） D 33） D 34） B 35） C 36） B 37） D 38） C 39） A 40） B
41） B 42） C 43） B 44） A 45） D 46） B 47） B 48） B 49） A 50） D
51） B 52） B 53） D 54） D 55） B 56） C 57） C 58） C 59） A 60） D
二、填空题：
（1） 5
（2） 13431
（3） 2002Shangxian
（4） sizeof（struct node ）
（5） x,link=&z或x.link=y.ink
（6） 80
（7） struct node *
（8） Struct STRU*
（9） Struct STRU
（10） struct st 或ex
（11） 22
（12） 10
（13） 4
（14） 5
（15） 2
（16） struct list *next
（17） int data
（18）（*b）.day
（19） b->day
（20） char *data
（21） struct link *next
（22）（struct list *）
（23）（struct list *）
（24） return（h）; 或 return h;
（25） p->link
（26） mm或m<=m3或m3>=m
（27） 34
（28） struct link *next
（29） struct list *
（30） q