一、选择题：
（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.以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转储到链表的各个结点中，请从与下划线处号码对应的一组选若中选择出正确的选项。
#include <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) 有以下程序
#include <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",&std.name);
　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 <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) 有以下程序
    #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<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              
　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所指的结点插入到链表末尾的语句组是
  http://s4/middle/8abf4784gacd38cd01283&690


　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<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(a.name,b.name)>0)   d=b;
               if(strcmp(c.name,d.name)>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;
且已建立如下图所示链表结构：
  http://s1/middle/8abf4784gacd392c5f080&690

请写出删除点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是指向结点的指针域。请填空完成此结构的类型定义和说明。

http://s4/middle/8abf4784gacd3963e6073&690

struct link
{【20】 ; 【21】;} *head;

(17) 以下函数creat用来建立一个带头结点的单向链表，新产生的结点总是插在链表的末尾。单向链表的头指针作为函数值返回.请填空:
#include<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个相邻结点数据域中值的和，返回其中最小的值。请填空。

http://s3/middle/8abf4784gacd39c73ef02&690

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<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