若要在图3-19窗口(窗体名为frm001)中新增一个命令按钮，单击该命令按钮后，图像框所显示的图像就会成为此窗口的背景图像。请写出该命令按钮单击事件过程内的程序代码。

阅读以下应用说明、图和Java代码，根据要求回答问题1至问题5。

 【说明】

 Stack类是java. ntil包中专门用来实现栈的工具类。以下Java程序是一个不使用库函数而实现字符串反转的程序。例如，输入：123456，则输出：654321：输入：asdfeg，则输出：gefdsa。

【Java程序】

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

import java.util.*;

public class UseStack extends Applet implements ActionListener

{ Stack MyStack;

 Label prompt=new Label("输入要反转字符:");

 Button pushBtn=new Button("压栈");

 Button popBtn=new Button("弹栈");    //反转

 TextField input=new TextField(5);

 int[] DrawStack =new int[10];      //记录堆栈中数据

 int[] PoppedOut=new int[20];       //记录被弹出的数据

 int StackCnt=0;             //记录模拟堆栈的数组中的数据个数

 String msg=" ";

 public void init()

 { MyStack=new Stack();

   add(prompt);

   add(input);

   add(pushBtn);

   add(popBtn);

   pushBtn.addActionListener(this);

    (1) 

 }

 public void paint(Graphics g)

 { for (int i=10; i＜StackCnt; i++)    //模拟显示堆栈内部的数据排列情况

   { g.drawRect(50,200-i*20,80,20);

     g.drawString(Integer.toString(DrawStack[i]),80,215-i*20);

   }

   for (int i=0;(2) )         //显示被弹出的数据

     g.drawString(Integer.toString(PoppedOut[i]),200+i*20,100);

     g.drawString("堆栈",70,236);

     g.drawString("栈底",135,225);

     g.drawString("栈顶",160,225-StackCnt*20);

     g.drawString(msg,200,140);

 }

 public void actionPerformed( (3) )

 { if (e.getAct ionCommand () == "压栈")  //压栈操作

   { if(StackCnt＜10)

     { MyStack.push(new Integer( (4) ));

       DrawStack[StackCnt++]=Integer.parseInt(input.getText() );

       input.setText (" ");

     }

     else

       msg="输入数据过多，请先弹栈!"

     }

   else if (e.getActionCommand () == "弹栈") //弹栈操作

   { if( (5) )

     { StackCnt--;

       PoppedOut[PopCnt++]=[(Integer)(MyStack.pop())).intValue();

     }

     else

       msg="堆栈已空，不能再弹栈!";

   }

   repaint();

 }

}

阅读以下应用说明、图和C++程序，将C++程序中(1)～(6)空缺处的语句填写完整。

  【说明】

 以下【C++程序】用于实现两个多项式的乘积运算。多项式的每一项由类Item描述，而多项式由类List描述。类List的成员函数主要有：

 createList()：创建按指数降序链接的多项式链表，以表示多项式：

 reverseList()：将多项式链表的表元链接顺序颠倒：

 multiplyList(ListL1，ListL2)计算多项式L1和多项式L2的乘积多项式。

【C++程序】

#include ＜iostream.h＞

class List;

class Item {

  friend class List;

  private:

    double quot ;

    int exp ;

    Item *next;

  Public:

    Item(double_quot,int_exp)

    { (1) ;}

};

class List{

 private:

   Item *list;

 Public:

   List(){

     list=NULL:

   }

 void reverseList();

 void multiplyList(List L1,List L2);

 void createList();

};

void List::createList()

{ Item *p,*U,*pre;

 int exp;

 double quot;

 list = NULL;

 while (1) {

   cout ＜＜ "输入多项式中的一项(系数、指数) :" ＜＜ endl;

   cin ＞＞ quot ＞＞ exp:

   if ( exp＜0 )

     break ;         //指数小于零，结束输入

   if ( quot=0 )

     continue;

   p = list;

   while ( (2) ) {    //查找插入点

     pre = p;

     p = p-＞next;

   }

   if ( p != NULL && exp = p-＞exp ) {

     p-＞quot += quot;

     continue ;

   }

   u =(3);

   if (p == list)

     list = u;

   else

     pre-＞next = u;

   u -＞next = p;

 }

}

void List::reverseList()

{ Item *p, *u;

 if ( list==NULL )

   return;

 p = list -＞next;

 list -＞ next = NULL;

 while ( p != NULL) {

   u = p -＞ next;

   p -＞next = list;

   list = p;

   p = u;

 }

}

void List::multiplyList ( List L1, List L2 )

{ Item *pL1,*pL2,*u;

 int k, maxExp;

 double quot;

 maxExp =(4):

 L2.reverseList();

 list=NULL;

 for ( k = maxExp;k ＞= 0;k-- ){

   pL1 = L1.list;

   while ( pL1 != NULL && pL1 -＞ exp ＞ k )

     pL1 = pL1 -＞next;

   pL2 = L2.1ist;

   while (pL2 NULL &&(5))

     pL2 = pL2 -＞ next;

   quot = 0.0;

   while (pL1 != NULL && pL2 != NULL){

     if(pL1-＞exp+pL2-＞exp==k) {

        (6) 

       pL1 = pL1 -＞ next;

       pL2 = pL2 -＞ next;

     } else if ( pL1 -＞ exp + pL2 -＞ exp ＞ k )

         pL1 = pL1 -＞ next;

       else

         pL2 = pL2 -＞ next;

   }

   if ( quot !=0.0 ) {

     u = new item( quot, k );

     u -＞ next = list;

     list = u;

   }

 }

 reverseList ();

 L2. reverseList ():

}

void main()

{ List L1,L2,L;

假设某应用程序开发工程(默认的工程名为“工程1”)已先后创建了名为Form01和Form02的两个窗体。为使窗体Form02成为运行该工程时的启动窗体，在开发过程应进行的操作过程如下。

 在工程对话框中，用鼠标右键单击“工程1(工程1)”，在选择[(8)]命令，系统弹出如图3-20所示的对话框。切换至图3-20的“通用”选项，在“(9)”下拉列表框中，选择“ (10)”。

filFile.Pattern属性用于指定文件列表框中所显示的文件类型。若要同时显示*.jpg和*.gif两种文件类型，filFile.Pattern的属性值应如何设置?

若要在图3-19窗口(窗体名为frm001)中新增一个命令按钮，单击该命令按钮后，图像框所显示的图像就会成为此窗口的背景图像。请写出该命令按钮单击事件过程内的程序代码。

阅读以下应用说明及Visual Basic程序代码，根据要求回答问题1至问题4。

 [说明]

 某文件管理系统的图片浏览器如图3-19所示。运行程序时，用户只要通过驱动器列表框、目录列表框和文件列表框，选择文本文件所在的驱动器、文件夹及相应的文件名后，在图像框中将显示出相应的文件图像。

 在开发过程中，假设驱动器列表框名为drvFile，目录列表框名为 dirFile，文件列表框名为filFile，选择文件类型组合框名为cboFile，图像框名为IMG nClick=over(this) title=放大Show。

 图3-19 图片浏览器

 [Visual Basic程序]

 Private Sub Form_Load ()

   IMG nClick=over(this) title=放大Show.Stretch=True

   cboFile.Addltem "位图文件(*.bmp)"

   cboFile.Addltem "图标文件(*.ico)"

   cboFile.Addltem "图元文件(*.wmf)"

   cboFile.Addltem "JPEG文件(*.jpg)"

   cboFile.Addltem "GIF文件(*.gif)"

   cboFile.ListIndex = 0

    (1) 

 End Sub

 Private Sub drvFile_Change ()

    (2) 

 End Sub

 Private Sub dirFile_Change ()

    (3) 

 End Sub

 Private Sub cboFile_Click ()

    (4) 

     Case 0

       filFile. Pattern= "*.bmp"

     Case 1

       filFile. Pattern= "*.ico"

     Case 2

       filFile. Pattern= "*.wmf"

     Case 3

       filFile. Pattern= "*.jpg.

     Case 4

       filFile. Pattern= "*.gif"

   End Select

 End Sub

 Private Sub filFile_Click()

   If (5) Then

     IMG nClick=over(this) title=放大Show. Picture= LoadPieture(filFile. Path+ filFile.FileName)

   Else

     IMG nClick=over(this) title=放大Show. Picture= LoadPicture( (6) + "\" + (7) )

   End If

 End Sub

请根据[说明]和图3-19的显示结果，从以下备选答案中为程序(1)～(7)空缺处选择正确的答案。

 [备选答案]

 A. filFile.path        B. dirFile.Path=drvFile.Drive

 C．Right(filFile.Path，1) = "\"  D．filFile.Pattern ="*.bmp"

 E．filFile.Path = dirFile.Path  F．filFile.FileName

 G．Select Case cboFile.ListIndex

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

[说明]

 Kruskal算法是一种构造图的最小生成树的方法。设G为一无向连通图，令T是由G的顶点构成的于图，Kmskal算法的基本思想是为T添加适当的边使之成为最小生成树：初始时，T中的点互相不连通；考察G的边集E中的每条边，若它的两个顶点在T中不连通，则将此边添加到T中，同时合并其两顶点所在的连通分量，如此下去，当添加了n-1条边时，T的连通分量个数为1，T便是G的一棵最小生成树。

 下面的函数void Kruskal(EdgeType edges[],int n)利用Kruskal算法，构造了有n个顶点的图 edges的最小生成树。其中数组father[]用于记录T中顶点的连通性质：其初值为father[i]=-1 (i=0,1,…,n-1)，表示各个顶点在不同的连通分量上；若有father[i]=j，j＞-1，则顶点i，j连通；函数int Find(int father[],int v)用于返回顶点v所在树形连通分支的根结点。

[函数]

#define MAXEDGE 1000

typedef struct

{ int v1;

 int v2;

}EdgeType;

void Kruskal(EdgeType edges[],int n)

{ int father[MAXEDGE];

 int i,j,vf1,vt2;

 for(i=0;i＜n;i+ +) father[i]=-1;

 i=0;

 j=0;

 while(i＜MAXEDGE && j＜(1))

 { vf1=Find(father,edges[i].v1);

   vf2=Find(father,edges[i].v2);

   if((2))

   {(3)=vf1;

     (4);

     printf("%3d%3d\n",edges[i].v1,edges[i].v2);

   }

    (5);

 }

}

int Find(int father[],int v)

{ int t;

 t=v;

 while(father[t]＞=0) t=father[t];

 return(t);

}

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

 邻接表是图的一种顺序存储与链式存储结合的存储方法。其思想是：对于图G中的每个顶点 vi，将所有邻接于vi的顶点vj连成一个单链表，这个单链表就称为顶点vi的邻接表，其中表头称作顶点表结点VertexNode，其余结点称作边表结点EdgeNode。将所有的顶点表结点放到数组中，就构成了图的邻接表AdjList。邻接表表示的形式描述如下： #define MaxVerNum 100    /*最大顶点数为100*/

typedef struct node{     /*边表结点*/

  int adjvex;       /*邻接点域*/

  struct node *next;   /*指向下一个边表结点的指针域*/ }EdgeNode;

typedef struct vnode{    /*顶点表结点*/

 int vertex;       /*顶点域*/

 EdgeNode *firstedge;   /*边表头指针*/

}VertexNode;

typedef VertexNode AdjList[MaxVerNum];  /*AdjList是邻接表类型*/

typedef struct{

  AdjList adjlist;     /*邻接表*/

  int n;          /*顶点数*/

}ALGraph;           /*ALGraph是以邻接表方式存储的图类型*/

 深度优先搜索遍历类似于树的先根遍历，是树的先根遍历的推广。

 下面的函数利用递归算法，对以邻接表形式存储的图进行深度优先搜索：设初始状态是图中所有顶点未曾被访问，算法从某顶点v出发，访问此顶点，然后依次从v的邻接点出发进行搜索，直至所有与v相连的顶点都被访问；若图中尚有顶点未被访问，则选取这样的一个点作起始点，重复上述过程，直至对图的搜索完成。程序中的整型数组visited[]的作用是标记顶点i是否已被访问。

[函数]

void DFSTraverseAL(ALGraph *G)/*深度优先搜索以邻接表存储的图G*/

{ int i;

 for(i=0;i＜(1);i++) visited[i]=0;

 for(i=0;i＜(1);i++)if((2)) DFSAL(G,i);

}

void DFSAL(ALGraph *G,int i)  /*从Vi出发对邻接表存储的图G进行搜索*/

{ EdgeNode *p;

  (3);

 p=(4);

 while(p!=NULL)       /*依次搜索Vi的邻接点Vj*/

 { if(! visited[(5)]) DFSAL(G,(5));

   p=p-＞next;       /*找Vi的下一个邻接点*/

 }

}

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

[函数2.1说明]

 下面程序的功能是：将由键盘输入的某个十进制数转换成对应的R进制数并输出。这里R是 2到16的整数，由键盘输入。例如，输入n=128，base=13后的输出为9B。

[函数2.1]

#include ＜stdio.h＞

main()

{ char b[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

 int c[64],n,i=0,base;

 printf("Enter a number:");scaaf("%d",&n);

 printf("Enter new base:");scanf("%d",&base);

 do{c[i]=(1);

   i++;

   n=n/base;

 }while((2));

 printf("Transmit new base:");

   for(- -i;i＞=0;- -i)printf("%c",(3));

}

[函数2.2说明]

 所谓回文字符中是指正序和逆序拼写相同的字符串，例如astrtsa，adgdtdgda等。下面函数int fun(char *str)的功能是判断字符串str是否是回文，当字符串是回文时，函数返回1，否则返回0。

[函数2.2]

int fun(char *str)

{ int i,j,l;

 for(i=0;str[i]! ='\0';i++);

 l=i/2;

 for(j=0,i- -;j＜=1;(4))

 if((5)) return 0;

 return 1;

}

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

[说明]

 下面的流程图用于统计一个英文句子中单词的个数N。假设该英文句子中只含字母、空格和句点“.”，其中句点表示结尾，空格之间连续的字母串称为单词。

[流程图]