阅读以下说明和C函数，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 某班级有N名学生，他们可根据自己的情况选修名称和数量不尽相同的课程。设N等于6，学生信息、所选课程及成绩用链表结构存储，如图5-1所示。

 

 程序中相应的类型定义如下：

 #define N 6

 struct node{

   char cname[5]; /*课程名*/

   int grade; /*成绩*/

   struct node *next; /*指针，指示某学生选修的下一门课程及成绩*/

 };

 struct student{

   char xh[5]; /*学号*/

   char name[20]; /*姓名*/

   struct node *link; /*指针，指示出选修的课程及成绩链表*/

 }stud_info[n];

 Stud_info[]为一个全局数组。

 函数func(char kc[],int *num)的功能是统计选修了课程名为kc的学生的人数，并返回该课程的平均成绩(若无人选修该课程，则平均成绩为0)，参数num带回选修课程kc的学生人数。

 [C语言函数]

 double func(char kc[], int *num)

 {

   int i, count=0, sum=0; /*count用于记录选修课程名为kc的学生的人数*/

   double avg=0.0;

   struct node *p;

   for(i=0; i＜N; i++){

     p=(1); /*取第土个学生所修课程链表的头指针*/

     while (p){

       if((2)){

         sum=(3);

         count++;

         break;;

       } /* if*/

       p=p-＞next;

     } /*while*/

   }

    (4);

   if((5))

     avg=(double) sum /count; /*计算平均成绩*/

   return avg;

 } /*func*/

阅读下列说明、图和C++代码，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 已知对某载客车辆(Car)进行类建模，如图5-1所示，其中类Engine表示发动机引擎，类Wheel表示车轮，类Body表示车身，类Driver表示司机，类Passenger表示乘客。

 [C++代码]

 const int (1)=7; //定义最多载客数

 const int MAX WHEELS=5; //定义最多轮胎数

 class Body{

   //此处代码省略

 }; //车身类

 class Passenger{

   //此处代码省略

 }; //乘客类

 class Wheel{

   //此处代码省略

 };//车轮类

 class Driver{ //司机类

 public:

   string name；//表示第几路公交车司机

   Driver(string driverName):name((2)){}; //构造函数

 };

 class Engine{ //引擎类

 public:

   string engineNo; //引擎编号

   Engine(string engineNo){(3)-＞engineNo=engineNo;} //构造函数

 };

 class Car{ //汽车类

 protected:

   Engine * engine; Driver * driver; Body body;

   Wheel * wheels[MAX_HEELS]; Passenger * passengers[MAX_PASSENGERS];

 public:

   Car(Driver * driver){//构造函数

     this-＞driver=driver;

     engine=new Engine("TX6536型号引擎");

     int index;

     for (index=0; index＜MAX_HEELS; index++){

       wheels[index]=new Wheel();

     }

     for(index=0; index＜MAX_PASSENGERS; index++){

       passengers[index]=NULL;

     }

   }

   virtual～Car() {//析构函数

     for (int index=0; index＜MAX_WHEELS; index++)

       delete wheels[index];

     delete (4);

   }

   int getPassengerNumber(){//获取车上乘客数量

     //此处代码省略

   }

   void getOnPassenger(Passenger * aPassenger){//乘客上车

     //此处代码省略

   }

   void run(){//开车

     if(driver==NULL) { cout＜＜ "司机尚未上车!"; return; }

     //此处代码省略

   }

 )；

 void main(){

   Driver driver("第五路公交车司机");

   Car car ((5));

   Passenger passengers [MAX_PASSENGERS];

   for (int index = 0; index＜MAX PASSENGERS; index++) //乘客上车处理

     car.getOnPassenger(&passengers[index]);

   car.run();

 }

阅读以下说明和Java程序代码，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 在下面的Java程序代码中，类SalesTicket能够完成打印票据正文的功能，类 HeadDecorator与FootDecorator分别完成打印票据的抬头和脚注的功能。己知该程序运行后的输出结果如下所示，请填补该程序代码中的空缺。

 这是票据的抬头!

 这是票据正文!

 这是票据的脚注!

 ---------------------------------------

 这是票据的抬头!

 这是票据的脚注!

 [Java程序代码]

 public class SalesTicket{

   public void printTicket(){

     System.out.println("这是票据正文!");

   }

 }

 public class Decorator extends SalesTicket{

   SalesTicket ticket;

   public Decorator(SalesTicket t){

     ticket =t；

   }

   public void printTicket(){

     if(ticket!=null)

       ticket. printTicket();

   }

 }

 public class HeadDecorator extends Decorator{

   public HeadDecorator(SalesTicket t){

      (1);

   }

   public void printTicket(){

     System.out.rintln("这是票据的抬头!");

     Super.printTicket();

   }

 }

 public class FootDecorator extends Decorator{

   public FootDecorator(SalesTicket t){

      (2);

   }

   public void printTicket(){

     super.printTicket();

     System.out.println("这是票据的脚注!");

   }

 }

 public class Main{

   public static void main(String[] args){

     Decorator T=

       new HeadDecorator((3));

     T. (4);

     System.out.println("-----------------------------------------");

     T=new FootDecorator((5));

     T.printTicket();

   }

 }

阅读以下说明和C函数，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 某班级有N名学生，他们可根据自己的情况选修名称和数量不尽相同的课程。设N等于6，学生信息、所选课程及成绩用链表结构存储，如图5-1所示。

 程序中相应的类型定义如下：

 #define N 6

 struct node{

   char cname[5]; /*课程名*/

   int grade; /*成绩*/

   struct node *next; /*指针，指示某学生选修的下一门课程及成绩*/

 };

 struct student{

   char xh[5]; /*学号*/

   char name[20]; /*姓名*/

   struct node *link; /*指针，指示出选修的课程及成绩链表*/

 }stud_info[n];

 Stud_info[]为一个全局数组。

 函数func(char kc[],int *num)的功能是统计选修了课程名为kc的学生的人数，并返回该课程的平均成绩(若无人选修该课程，则平均成绩为0)，参数num带回选修课程kc的学生人数。

 [C语言函数]

 double func(char kc[], int *num)

 {

   int i, count=0, sum=0; /*count用于记录选修课程名为kc的学生的人数*/

   double avg=0.0;

   struct node *p;

   for(i=0; i＜N; i++){

     p=(1); /*取第土个学生所修课程链表的头指针*/

     while (p){

       if((2)){

         sum=(3);

         count++;

         break;;

       } /* if*/

       p=p-＞next;

     } /*while*/

   }

    (4);

   if((5))

     avg=(double) sum /count; /*计算平均成绩*/

   return avg;

 } /*func*/

阅读以下说明和C语言函数，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 假设一个剧场有N*N个座位，顾客买票时可以提出任意有效的座号请求。下面用二维数组a[N][N]模拟剧场中的座位，a[i][j]等于0表示第i排第j列(0≤i,j≤N-1)的票尚未售出。

 函数int Find(inta[][N],int R,int *row, int *col)的功能是：在部分票已售出的情况下，找出剧场中的R*R个空座位，要求这些座位的排列形成一个正方形。若找到满足要求的一个座位排列，则函数返回1，并算出该正方形左上角的行、列号；若未找到，则返回0。

 例如，一个7×7个座位的剧场如下图(a)所示，已售出部分座位的剧场如下图(b)所示，图中阴影部分表示已售出的座位，从图(b)中找出的3×3正方形空座位如图(c)中斜线区所示。

 [C语言函数]

 int Find(int a[][N],int R,int *row,int *col)

 {

   int i,j,k,c,t; int FOUND=0;

   for(i=0; !FOUND && i＜N-R+1;i++) { /*从第0排开始查找*/

      (1);

     while(j＜N-R+1 &&!FOUND) {

       for(k=0;(2)&& a[i][j+k]==0; k++); /*查找第i排连续的R个座位*/

       if(k＞=R) {  /*找到第i排连续的R个空座位*/

         for(c=0;c＜R;c++) {  /*查找其余的R*(R-1)个座位*/

          for(t=1;t＜R;t++)

            if(a[(3)][j+c]!=0)break;

          if(t＜R)break;

         }/*for*/

         if((4))FOUND=1;

       } /*if*/

        (5);

     } /*while*/

   } /*for i*/

   if(FOUND){

     *row=i-1; *col=j-1; /*计算正方形区域的左上角坐标*/

     return 1;

   }

   return 0;

 }

阅读以下说明和C函数，将应填入(n)处的字句写在对应栏内。

 [说明]

 若一个矩阵中的非零元素数目很少且分布没有规律，则称之为稀疏矩阵。对m行n列的稀疏矩阵M，进行转置运算后得到n行m列的矩阵MT，如图3-1所示

 为了压缩稀疏矩阵的存储空间，用三元组(即元素所在的行号、列号和元素值、表示稀疏矩阵中的一个非零元素，再用一维数组逐行存储稀疏矩阵中的所有非零元素也称为三元组顺序表)。例如，图3-1所示的矩阵M相应的三元组顺序表如表3-1所示。其转置矩阵MT的三元组顺序表如表3-2所示。

 函数TransposeMatrix(Matrix M)的功能是对用三元组顺序表表示的稀疏矩阵M进行转置运算。

 对M实施转置运算时，为了将M中的每个非零元素直接存入其转置矩阵MT三元组顺序表的相应位置，需先计算M中每一列非零元素的数目(即MT中每一行非零元素的数目)，并记录在向量num中；然后根据以下关系，计算出矩阵M中每列的第一个非零元素在转置矩阵MT三元组顺序表中的位置：

 cpot[0]=0

 cpot[j]=cpot[j-1]+num[j-1]) /*j为列号*/

 类型ElemType，Triple和Matrix定义如下：

 typedef int ElemType;

 typedef struct{ /*三元组类型*/

   int r,c; /*矩阵元素的行号、列号*/

   ElemType e; /*矩阵元素的值*/

 }Triple;

 typedef struct{ /*矩阵的元组三元组顺序表存储结构*/

   int rows,cols,elements; /*矩阵的行数、列数和非零元素数目*/

   Triple data[MAXSIZE];

 }Matrix;

 [C语言函数]

 int TransposeMatrix(Matrix M)

 {

   int j,q,t;

   int *num, *cpot;

   Matrix MT; /*MT是M的转置矩阵*/

   num=(int*)malloc(M.cols*sizeof(int));

   cpot=(int*)malloc(M.cols*sizeof(int));

   if(!num ||cpot)

     return ERROR;

   MT.rows=(1); /*设置转置矩阵MT行数、列数和非零元素数目*/

   MT.cols=(2);

   MT.elements=M.elements;

   if(M.elements＞0){

     for (q=0 ; q＜M. cols ; q++)

       num[q]=0;

     for (t=0; t＜M.elements;++t) /*计算矩阵M中每一列非零元素数目*/

       num [M.data[t].c]++;

     /*计算矩阵M中每列第一个非零元素在其转置矩阵三元组顺序表中的位置*/

      (3);

     for(j=1;j＜M.cols;j++)

       cpot[j]=(4);

     /*以下代码完成转置矩阵MT三元组顺序表元素的设置*/

     for(t=0;t＜M.elements;t++){

       j=(5); /*取矩阵M的一个非零元素的列号存入j*/

       /*q为该非零元素在转置矩阵MT三元组顺序表中的位置(下标)*/

       q=cpot[j];

       MT.data[q].r=M.data[t].c;

       MT.data[q].c=M.data[t].r;

       MT.data[q].e=M.data[t].e;

       ++cpot[j]; /*计算M中第j列的下一个非零元素的目的位置*/

     }/*for*/

   } /*if*/

   free(num); free(cpot);

   /*此处输出矩阵元素，代码省略*/

   return OK;

 }/*TransposeMatrix*/

阅读以下说明和C程序，将应填入(n)处的字句写在答题纸的对应栏内。

 [说明]

 下面的程序按照以下规则输出给定名词的复数形式：

 a．若名词以“y”结尾，则删除y并添加“ies”；

 b．若名词以“s”、“ch”或“sh”结尾，则添加“es”；

 c．其他所有情况，直接添加“s”。

 [C语言程序]

 # include ＜stdio.h＞

 # include ＜string.h＞

 char *plural (char *word)

 {

   int n;

   char *pstr;

   n=strlen(word); /*求给定单词的长度*/

   pstr=(char *) malloc(n+3); /*申请给定单词的复数形式存储空间*/

   if (!pstr||n＜2)

     return NULL;

   strcpy (pstr,word);/*复制给定单词*/

   if((1))

   {

     pstr[n-1] = 'i-'; pstr[n]='e'; pstr[n+1]='s';(2);

   }

   else if(pstr[n-1]=='s' ||pstr[n-1]=='h' && ((3))

   {

     pstr[n]='e'; pstr[n+1]='s'; pstr[n+2]='＼0';

   }

   else

   {pstr[n]='s'; pstr[n+1]='＼0';}

    (4)；

 }

 main ( )

 {

   int i; char *ps;

   char wc[9][10]={"chair", "dairy", "boss", "circus", "fly", "dog", "church", "clue", "dish");

   for(i=0; i＜9; i++)  {

     ps=(5)；

     printf("%s: %s＼n",wc[i],ps); /*输出单词及其复数形式*/

     free (ps);/*释放空间*/

   }

   system ("pause");

 }

阅读以下说明和流程图，填补流程图中的空缺(1)～(9)，将解答填入对应栏内。

 [说明]

 假设数组A中的各元素A(1),A(2),…,A(M)已经按从小到大排序(M≥1)；数组 B中的各元素B(1),B(2),…,B(N)也已经按从小到大排序(N≥1)。执行下面的流程图后，可以将数组A与数组B中所有的元素全都存入数组C中，且按从小到大排序(注意：序列中相同的数全部保留并不计排列顺序)。例如，设数组A中有元素：2,5,6,7,9；数组B中有元素：2,3,4,7；则数组C中将有元素：2,2,3,4,5,6,7,7,9。

 [流程图]