阅读下列算法说明和算法，将应填入(n)处的语句写在对应栏内。

1.  【说明】

 实现连通图G的深度优先遍历(从顶点v出发)的非递归过程。

 【算法】

 第一步：首先访问连通图G的指定起始顶点v；

 第二步：从V出发，访问一个与v(1)p，再从顶点P出发，访问与p(2)顶点q，然后从q出发，重复上述过程，直到找不到存在(3)的邻接顶点为止。

 第三步：回退到尚有(4)顶点，从该顶点出发，重复第二、三步，直到所有被访问过的顶点的邻接点都已被访问为止。

 因此，在这个算法中应设一个栈保存被(5)的顶点，以便回溯查找被访问过顶点的未被访问过的邻接点。

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

  【说明】

 链表和栈对象的共同特征是：在数据上执行的操作与在每个对象中实体存储的基本类型无关。例如，一个栈存储实体后，只要保证最后存储的项最先用，最先存储的项最后用，则栈的操作可以从链表的操作中派生得到。程序6-1实现了链表的操作，程序6-2实现了栈操作。

 import java.io.*;

 class Node      //定义结点

 {  private String m_content;

    private Node m_next;

    Node(String str)

    {  m_content=str;

       m_next=null;  }

    Node(String str,Node next)

    {  m_content=str;

       m_next=next; }

    String getData()    //获取结点数据域

    {  return m_content;}

    void setNext(Node next] //设置下一个结点值

    {  m_next=next;    }

    Node getNext()    //返回下一个结点

    {  return m_next; )

 }

 【程序6-1】

 class List

 {  Node Head;

    List()

    { Head=null; }

    void insert(String str)    //将数据str的结点插入在整个链表前面

    {  if(Head==null)

          Head=new Node(str);

      else

        (1) 

    }

    void append(String str)  //将数据str的结点插入在整个链表尾部

    {  Node tempnode=Head;

       it(tempnode==null)

       Heed=new Node(str);

       else

       { white(tempnode.getNext()!=null)

           (2) 

         (3) }

    }

   String get()         //移出链表第一个结点，并返回该结点的数据域

   {  Srting temp=new String();

      if(Head==null)

      {  System.out.println("Errow! from empty list!")

        System.exit(0); }

      else

      {  temp=Head.getData();

         (4)  }

      return temp;

   }

 } 

 【程序6-2】

 class Stack extends List

 {  void push(String str)       //进栈

    { (5)  }

    String pop()            //出栈

    {  return get();}

 }

阅读以下说明，以及用C++在开发过程中所编写的程序代码，将应填入(n)处的字句写在对应栏内。

  【说明】

 在下面程序横线处填上适当的字句，3个(2)空填的是一样的。使其输出结果为：

 x=5

 x=6

 y=7

 x=8

 z=9

 【程序】

 #include＜iostream.h＞

 class X1{

  int x;

   (1);

  X1(int xx=0){x=xx;}

   (2) void Output(){

  cout＜＜"x="＜＜x＜＜end;

  }

 };

  (3) Y1:public X1{

  int y;

  public:

   Y1(int xx=0,int yy=0);X1(xx){y=yy;}

   (2) void Output(){

   (4) Output();

  cout＜＜"y="＜＜y＜＜endl;

  }

 };

 class Z1:public X1{

   int z:

    (5);

   Z1(int xx=0,int zz=0):X1(xx)(z=zz;}

    (2) void Output(){

   X1∷Output();

   cout＜＜"z="＜＜z＜＜endl;

  }

 };

 void main()

 {

  X1 a(5);Y1 b(6,7);Z1 c(8,9);

  X1*p[3]={&a,&b,&c);

  For(int i=0;i＜3;i++){

   p[i]-＞Output();cout＜＜endl;

  }

 }

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

  【说明】

 已知某数列的前两项为2和3，其后继项根据当前最后两项的乘积按下列规则生成：

 (1)若乘积为一位数，则该乘积即为数列的后继项；

 (2)若乘积为二位数，则该乘积的十位数和个位数依次作为数列的两个后继项。

 本程序输出该数列的前n项以及它们的和。其中，函数sum(n,pa)返回数列的前n项之和，并将生成的前n项存放于首指针为pa的数组中。程序中规定输入的n值必须大于2并且不超过给定的常数值MAXNUM。

 例如：若输入n值为10，则程序输出如下内容：

 sum(10)=44

 2 3 6 1 8 8 6 4 2 4

 #include＜stdio.h＞

 #define MAXNUM 100

 int sum(int n,int *pa){

   int count,total,temp;

   *pa=2;

    (1)=3;

   total=5; count=2;

   while(count++＜n){

     temp+=*(pa-1)**pa;

     if(temp＜10){

       total+=temp;

       *(++pa)=temp;

     }

     else{

        (2)=temp/10;

       total+=*pa;

       if(count＜n){

         count++;pa++;

          (3)=temp%10;

         total+=*pa;

       }

     }

   }

    (4);

 }

 main(){

   int n,*p,*q,num[MAXNUM];

   do{

     printf("Input N=?(2＜N＜%d):",MAXNUM+1);

     scanf("%d",&n);

   }while((5));

   printf("\nsum(%d)=%d\n",n,sum(n,num));

   for(p=num,q= (6) ;p＜q;p++)printf("%4d",*p);

   printf("\n");

 }

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

  【说明】

 对20个数进行排序，可以利用选择法，即从后19个比较过程中，选择一个最小的与第一个元素交换，依次类推，即用第二个元素与后18个进行比较，并进行交换。

 【函数】

 #define N 20

 main()

 {

   int i,j,min,tem,a[N];

   printf("please input twenty num:\n");

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

   {

     printf("a[%d]=",i);

     scanf("%d",&a[i]);

   }

   printf("\n");

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

     printf(",",a[i]);

   printf("\n");

   for(i=0;(1);i)

   {

     min=(2);

     for(j=(3);j＜N;j++)

       if((4))

         min=j;

     tem=a[i];

      (5);

     a[min]=tem;

   }

   printf("After sorted \n");

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

     printf(",",a[i]);

 }

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

  【说明】

 实现矩阵(3行3列)的转置(即行列互换)。

 例如，输入下面的矩阵：

 100 200 300

 400 500 600

 700 800 900

 程序输出：

 100 400 700

 200 500 800

 300 600 900

 【函数】

 int fun(int array[3][3])

 {

   int i,j,t;

   for(i=0;(1);i++)

     for(j=0;(2);j++)

     {

       t=array[i][j];

        (3);

        (4);

     }

   }

 }

 main()

 {

   int i,j;

   int array[3][3]={{100,200,300},{400,500,600},{700,800,900}};

   clrscr();

   for (i=0;i＜3;i++)

   {

     for(j=0;j＜3;j++)

       printf("%7d",array[i][j]);

     printf("\n");

   }

   fun((5));

   printf("Converted array:\n");

   for(i=0;i＜3;i++)

   {

     for(j=0;j＜3;j++)

       printf("%7d",array[i][j]);

     printf("\n");

   }

 }

阅读下列算法说明和算法，将应填入(n)处的语句写在对应栏内。

1.  【说明】

 实现连通图G的深度优先遍历(从顶点v出发)的非递归过程。

 【算法】

 第一步：首先访问连通图G的指定起始顶点v；

 第二步：从V出发，访问一个与v(1)p，再从顶点P出发，访问与p(2)顶点q，然后从q出发，重复上述过程，直到找不到存在(3)的邻接顶点为止。

 第三步：回退到尚有(4)顶点，从该顶点出发，重复第二、三步，直到所有被访问过的顶点的邻接点都已被访问为止。

 因此，在这个算法中应设一个栈保存被(5)的顶点，以便回溯查找被访问过顶点的未被访问过的邻接点。