结构体与共用体及用户定义类型

结构体与共用体及用户定义类型
一、选择题：
（1）有以下程序段
typedef struct NODE
{ int num; struct NODE *next;
} OLD;
以下叙述中正确的是
A）以上的说明形式非法
B）NODE是一个结构体类型
C）OLD是一个结构体类型
D）OLD是一个结构体变量
（2）有以下程序
# include <string.h>
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 <string.h>
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.以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转储到链表的各个结点中，请从与下划线处号码对应的一组选若中选择出正确的选项。

＃i nclude <stdlib.h>
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) 有以下程序
＃i nclude <stdlib.h>
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
{ int 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",&);
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) 有以下程序
＃i nclude <stdlib.h>
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
┌──┬──┐┌──┬──┐
│ 5│┼──→ │ 9│ \0 │
└──┴──┘└──┴──┘
↑p
c
data next
┌──┬──┐
│ 7││
└──┴──┘
↑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) printf(“%^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
data next
在该链表结构中，指针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) 有以下程序
＃i nclude
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个元素在低位,则以下程序的输出结果是
＃i nclude<stdio.h>
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
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] };
{ 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) 有以下程序：
＃i nclude<stdio.h>
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 <string.h>
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(,)>0) d=b;
if(strcmp(,)>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;
且已建立如下图所示链表结构：
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用来建立一个带头结点的单向链表，新产生的结点总是插在链表的末尾。

单向链表的头指针作为函数值返回.请填空:
＃i nclude<stdio.h>
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).
＃i nclude<stdio.h>
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();}
答案：
一、选择题：
01) C 02) D 03) A 04) B 05) C
06) C 07) D 08) C 09) 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。