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

【流程图】

下面的流程图描述了对16位二进制整数求补的算法。计算过程是：从二进制数的低位 (最右位)开始，依次向高位逐位查看，直到首次遇到“1”时，停止查看。然后，对该“1”位左面的更高位(如果有的话)，逐位求反，所得的结果就是对原二进制数求补的结果。

 例如：对二进制整数10111001 10101000求补的结果是01000110 01011000。

 设16位二进制整数中的各位，从低位到高位，依次存放在整型数组BIT的BIT[1]～BIT[16]中。例如，二进制整数10111001 10101000存放在数组BIT后，就有BIT1[1]=0， BIT[2]=0，……，BIT[15]=0，BIT[16]=1。

 流程图(如图1所示)中(1)处按“循环变量名：循环初值，增量，循环终值”格式描述。若流程图中存在空操作，则用NOP表示。

阅读以下说明和Java代码，将解答写入对应栏内。

【说明】

 下面是一个Applet程序，其功能是输出已定义好的两个变量x和chr。请改正程序中的错误(有下划线的语句)，使程序能输出正确的结果。

 注意：不改动程序的结构，不得增行或删行。

 import java. awt.*;

  (1) 

  (2) 

 {

   int x=10;

    (3) 

   Label output1;

   Label output2;

  (4) 

   }

    output1 = new Label("定义int类型变量"+"x,的初值为"+x);

    output2 = new Label("定义char类型变量"+"chr,的初值为"+chr);

    add(output1);

    add(output2);

  }

 }

 ＜HTML＞

 ＜HEAD＞

  ＜TITLE＞ ex34_3 ＜/TITLE＞

 ＜/HEAD＞

 ＜BODY＞

    (5) 

    width=400 height=400＞

   ＜/applet＞

  ＜/BODY＞

 ＜/HTML＞

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

【说明】

 以下程序的功能是设计一个栈类stack＜T＞，并建立一个整数栈。

 【程序】

 #include ＜ iostream. h ＞

 #include ＜ stdlib. h ＞

 const int Max =20;           //栈大小

 template ＜ class T ＞

 class stack{              //栈元素数组

 T s[Max];                //栈顶下标

 int top;

 public:

   stack( )

   {

     top =-1;            //栈顶初始化为-1

   }

   void push( const T &item);     //item入栈

   T pop( );              //出栈

   int stackempty( ) const;      //判断栈是否为

 };

 template ＜ class T ＞

 void stack ＜T ＞::push(const T &item)

 {

   if(top==(1))

   {

     cout ＜＜"栈满溢出" ＜＜endl;

     exit(1);

   }

   top ++

   s[top] = item;

 }

 template ＜ class T ＞

 T stack＜T＞ ::pop()

 {

   T temp;

   if(top==(2))

   {

     cout ＜＜"栈为空，不能出栈操作" ＜ ＜ endl;

     exit(1);

   }

   temp =s[top];

   top --;

   return temp;

 }

 template ＜ class T ＞

 int stack ＜ T ＞:: stackempty( ) const

 {    return top == -1;

 {

 void main( )

 {

   stack ＜int＞ st;

   int a[] ={1,2,3,4,5};

   cout ＜＜"整数栈" ＜＜endl;

   cout ＜＜"入栈序列:" ＜＜endl;

   for(int i=0;i＜4;i ++)

   {

     cout ＜＜a[i] ＜＜" ";

      (3);

   }

   cout ＜＜ endl ＜＜"出栈序列";

   while((4))

   tout＜＜(5)＜＜" ";

   cout＜ ＜ endl;

 }

阅读以下应用说明及Visual Basic程序代码，将应填入(n)处的字句写在对应栏内。

【说明】

 本应用程序是一个乘法计算器，其运行窗口如图2所示。

在该界面中，“被乘数”、“乘数”以及“积”等文字为标签，相应的3个输入输出数据框为文本框，此外还有3个命令按钮。用户在“被乘数”和“乘数”相应的文本框内输入数据，再单击“运算”按钮，便能在“积”对应的文本框中看到相乘的结果；当用户单击“清除”按钮时，就会清除各文本框中的数据；当用户单击“关闭”按钮时就会关闭该窗口并退出应用程序。用户不能在“积”对应的文本框中输入数据。

 【属性设置】

 各个对象、有关的属性名以及需要修改的属性值设计如下：

 【程序】

 Private Sub cmdMultiply_Click( )

   txt3. Text =Trim(Str＄ ((3))  '加法运算获得和数

 End Sub

 Private Sub (4) (

   txt1. Text=" "  '空字符串赋值给文本框txt1的内容

   txt2. Text=" "  '空字符串赋值给文本框txt2的内容

   txt3. Text=" "  '空字符串赋值给文本框txt3的内容

 End Sub

 Private Sub cmdClose_Click( )

    (5)      '退出应用程序

 End Sub

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

【说明】

 将一正整数序列{K1，K2，…，K9}重新排列成一个新的序列，新序列中，比K1小的数都在K1的前面(左面)，比K1大的数都在K1的后面(右面)，最后调用writeDat()函数的新序列输出到文件out.dat中。

 在程序中已给出了10个序列，每个序列有9个正整数，并存入数组a[10][9]中，分别求出这10个新序列。

 例：序列{6，8，9，1，2，5，4，7，3}

 经重排后成为{3，4，5，2，1，6，8，9，7}

 【函数】

 #include ＜ stdio. h ＞

 #include ＜ conio. h ＞

 void jsValue( int a [10] [9] )

 { int i,j,k,n,temp;

   int b[9];

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

   { temp=a[i] [0];

    k=8;n=0;

    for(j=8;j=0;j--)

     { if(temp ＜ a[i] [j]) (1)=a[i][j];

       if(temp ＞a[i] [j]) (2)=a[i][j];

       if(temp =a[i] [j]) (3)= temp;

     }

     for(j=0;j＜9;j++) a[i][j] =b[j];

   }

 }

 void main( )

   int a[10] [9] = {{6,8,9,1,2,5,4,7,3},{3,5,8,9,1,2,6,4,7},

         {8,2,1,9,3,5,4,6,7}, {3,5,1,2,9,8,6,7,4},

         {4,7,8,9,1,2,5,3,6}, {4,7,3,5,1,2,6,8,9},

         {9,1,3,5,8,6,2,4,7}, {2,6,1,9,8,3,5,7,4},

         {5,3,7,9,1,8,2,6,4}, {7,1,3,2,5,8,9,4,6}

   };

   int i,j;

    (4);

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

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

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

       if((5))printf(",");

     }

     printf(" \n" );

   }

   getch( );

 }

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

【说明】

 函数DelA_InsB(LinkedList La，LinkedList Lb，int key1，int key2，int len)的功能是：将线性表A中关键码为key1的结点开始的len个结点，按原顺序移至线性表B中关键码为key2的结点之前，若移动成功，则返回0；否则返回-1。线性表的存储结构为带头结点的单链表，La为表A的头指针，Lb为表B的头指针。单链表结点的类型定义为

 typedef struct node {

   int key;

   struct node * next;

 } *LinkedList;

 【函数】

 int DelA_InsB ( LinkedList La, LinkdeList Lb,int key1,int key2,,int len)

 { LinkedList p,q,s,prep,pres;

   int k;

   if( ! La-＞next || ! Lb-＞ next ||| en ＜=0)return-1;

   p = La -＞ next;prep = La;

   while(p&&p- ＞key != key1) {  /*查找表A中键值为key1的结点*/

    prep = p;p = p -＞ next;

   }

   if( ! p) return - 1;     /*在表A中不存在键值为key1的结点*/

   q=p;k=1;

   while(q &&(1))}  /*表A中不存在要被删除的len个结点*/

     (2);k++;

   }

   if( ! q)return -1;      /*表A中不存在要被删除的len个结点*/

   s = Lb -＞ next;(3);

   while(s && s -＞ key != key2) { /*查找表B中键值为key2的结点*/

     pres =s;s =s-＞next;

   }

   if( ! s) return - t;     /*表B中不存在键值为key2的结点*/

   (4)=q-＞ next;   /*将表A中的len个结点删除*/

   q-＞next=(5);

   pres -＞ next = p;       /*将len个结点移至表B */

   return 0;

 }

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

【说明】

 函数print(BinTreeNode*t; DateType &x)的功能是在二叉树中查找值为x的结点，并打印该结点所有祖先结点。在此算法中，假设值为x的结点不多于一个。此算法采用后序的非递归遍历形式。因为退栈时需要区分右子树。函数中使用栈ST保存结点指针ptr以及标志tag，Top是栈顶指针。

 【函数】

 void print( BinTreeNode * t; DateType &x) {

 stack ST; int i, top; top = 0;//置空栈

 while(t! = NULL &&t-＞ data!= x || top!=0)

 {  while(t!= NULL && t-＞ data!=x)

    {

      /*寻找值为x的结点*/

      (1);

      ST[top]. ptr = t；

      ST[top]. tag = 0;

      (2);

    }

    if(t!= Null && t -＞ data == x) { /*找到值为x的结点*/

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

      printf("%d" ,ST[top]. ptr -＞data);

    else {

      while((4))

      top--;

      if(top＞0)

      {

        ST[top]. tag = 1;

         (5);

      }

    }

 }

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

【流程图】

下面的流程图描述了对16位二进制整数求补的算法。计算过程是：从二进制数的低位 (最右位)开始，依次向高位逐位查看，直到首次遇到“1”时，停止查看。然后，对该“1”位左面的更高位(如果有的话)，逐位求反，所得的结果就是对原二进制数求补的结果。

 例如：对二进制整数10111001 10101000求补的结果是01000110 01011000。

 设16位二进制整数中的各位，从低位到高位，依次存放在整型数组BIT的BIT[1]～BIT[16]中。例如，二进制整数10111001 10101000存放在数组BIT后，就有BIT1[1]=0， BIT[2]=0，……，BIT[15]=0，BIT[16]=1。

 流程图(如图1所示)中(1)处按“循环变量名：循环初值，增量，循环终值”格式描述。若流程图中存在空操作，则用NOP表示。