一、选择题：
    （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）;
      ...
    }

    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
    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） 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、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（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;
    且已建立如下图所示链表结构：请写出删除点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