(2)

(4)

(5)

(3)

(2)

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

 [说明]

 下面程序用来将打乱的单词还原为原来的次序，比如将rty还原为try。单词的原来次序存储于wordlist.txt文件中，原则上可用穷举法(rty对应的穷举为：rty、ryt、try、tyr、ytr、yrt)，但考虑到破译速度，采用如下方法。

 注意到单词列表中不存在组成字符完全相同的单词(如Hack12与Hack21包含完全相同的字符)，因此将单词中的字符进行重组再进行比较，例如，try单词重组为rty(按ASCⅡ码顺序)，这样不管打乱的单词是什么顺序，只要是由r、t、y三个字母组成的均破译为try，大大提高破译速度。程序中借助二叉排序树以进一步提高查找效率，二叉排序树左子树(如果有)上的节点对应的值均小于根节点的值，右子树(如果有)上的节点对应的值均大于根节点的值。

 函数中使用的符号定义如下：

 #define NumberofWords 1275//单词总数

 #define MaxLength  10//最长单词所含字符数

 char WordList[NumberofWords][MaxLength]；//存储单词列表

 int cmp(Node *q，Node *p)；//q与p比较。p小，返回负值；P大返回正值：相等，返回0

 typedef struct Node(//二叉树节点

 char *eleLetters；//重组后的字符串

 int index；//对应单词表中的下标

 struct Node *lChiId，*rChiid；//左右子节点

 }Node；

 [C代码]

 void reCompose(Node *p，char *temp)

 //重纰，亦即将temp字符串中的字符升序排序，存储于p节点中

 //采用直接插入排序法

 {

 char c；

 strcpy(p-＞eleLetters，temp)；//

 int len=strlen(temp)；

 int i，j，k；

 for(i=0；i＜len－1；i++){

 k=i；

 for(j=i+1；j＜lan；j++){

 if(p-＞eleLetters[j]＜P-＞eleLetters[k])k=J；

 }

 if( (1) ){

 C=P-＞eleLetters[i]；

 P-＞eleLetters[i]=P-＞eleLetters[k]；

 P-＞eleLetters[k]=c；

 }//if

 }//for

 }；

 int find(Node &root，char *temp)

 //在二叉排序树root中查找与temp匹配的单词。

 //若匹配返回相应单词在WordList中下标；若查找失败，返回-1

 {

 Node *P，*q；

 int flag；

 P=(2)；//临时存储

 reCompose(p，temp)；//将temp重组

 q=&root；

 while((flag=(3))＆＆q !=NULL){

 if(flag＜0){//搜索左子树

 q=q-＞lChiid；

 }else(//搜索右子树

 q=q-＞rChild；

 }

 }//while

 if(flag==0){//找到匹配的，保存下标

 return (4)；

 }

 }

 if( (5) ){//查找失败

 printf("cant unscramble the following word：%s"，temp)；；

 return -1；

 }

 }；

(1)

(5)

(2)

(4)

(3)

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

 [说明]

 在一些大型系统中，大多数的功能在初始化时要花费很多时间，如果在启动的时候，所有功能(连不用的功能)都要全面初始化的话，会连带影响到应用软件要花很多时间才能启动。因此常将程序设计成到了实际要使用某种功能的阶段才初始化该功能。

 以下示例展示了Proxy(代理)模式，PrinterProxy类执行一些比较“轻”的方法——设置名称和取得名称，需要真正执行“重”的方法——真正打印——时才初始Print类。图6-1显示了各个类间的关系。

 [图6-1]

 [Java代码]

 //Printable.Java

 publiC (1) Printable{

 public abstract void setPrinterName(String name)；

 public abstract String getprinterName()；

 public abstract void print(String string)；

 }

 //Printer.Java

 public class Printer implements Printable{

 private String name；

 public Printer(){

 System.out.println("正在产生Printer的对象实例")；

 }

 public Printer(String name){

 this.name=name；

 heavyJob("正在产生Printer的对象实例("+name+")")；

 public void setPrinterName(String name){

 this.name=name；

 public String getPrinterName(){

 return name；

 public void print(String string){

 System.out.println("===" +name+" ====")；

 System.out.println(string)；

 }

 }

 //PrinterProxy.Java

 public class PrinterProxy (2) Printable{

 private String name；

 private Printer real；

 public PrinterProxy(){}

 public PrinterProxy(String name){

 this.name=name；

 }

 public gynchronized void setPrinterName(String name){

 if( (3) ){

 real.setPrinterName(name)；

 }

 this.name=name；

 }

 public String getprinterName(){

 return name；

 }

 public void print(String string){

  (4)；

 real.print(string)；

 }

 private synchronized void realize(){//产生真正的Printer对象

 if(real==null){

 real=(5)；

 }

 }

 }

(1)