填空题[说明] 编写一个学生类Student，要求：
(1) 学生类Student 属性有：
id: long 型，代表学号
name: String类对象，代表姓名
age: int 型，代表年龄
sex: boolen 型，代表性别(其中：true 表示男，false 表示女)
phone: String 类对象，代表联系电话
(2) 学生类Student 的方法有：
Student (long i，String n，int a，boolean s，String p)
：有参构造函数，形参表中的参数分别初始化学号、姓名、
年龄、性别和联系电话。
int getAge ()：获取年龄作为方法的返回值。
boolean getSex ()：获取性别作为方法的返回值。
String getPhone ()：获取联系电话作为方法的返回值。
public String to String ()：以姓名：性别：学号：联系电话的形式作为方法的返
import java. applet. Applet;
import java. awt.* ;
public class Student extends Applet {
long id;
String name, phone;
int age;
boolean sex;
Student(long i, String n, int a, boolean s, String p)
{
id=i;
name = n;
age = a;
sex= s;
phone = p;
{
public void paint( Graphics g)
{
Student x= new Student (5000," xiaoliu" , 89, true, " 8989898" );
{{U}} (1) {{/U}};
{{U}} (2) {{/U}}
g. drawstring( x. getPhone( ), 140,140);
}
int getAge( )
{ return age; }
boolean getsex ( )
{ return sex; }
String getPhone( )
{ return phone; }
String ToString( )
{
{{U}} (3) {{/U}}
}
}
填空题阅读以下说明和Jrdva代码，将应填入(n)处的字句写在对应栏内。[说明]在销售系统中常常需要打印销售票据，有时需要在一般的票据基础上打印脚注。这样就需要动态地添加一些额外的职责。如下展示了Decorator(修饰)模式。SalesOrder对象使用一个SalesTicket对象打印销售票据。图6-1显示了各个类间的关系。以下是Java语言实现，能够正确编译通过。[图6-1][Java代码]//Component.java文件public(1)classComponentabstractpublicvoidprtTicket()；//salesTicket.java文件publicclassSalesTicketextendsComponentpublicvoidprtTicket()//SalesticketprintingcodehereSystem.out.printin("SalesTicket")；//Decorator.java文件publicabstractclassDecoratorextendsComponentpublicvoidprtTicket()if(myComp!=null)myComp.prtTicket()；private(2)myComp；publicDecorator(ComponentmyC)myComp=myC；//Footer.java文件publicclassFooterextendsDecoratorpublicFooter(ComponentmyC)(3)；publicvoidprtTicket()(4)；prtFooter()；publicvoidprtFooter()//placeprintingfootercodehereSystem.out.println("Footer")；//salesorder.java文件publicclassSalesOrdervoidprtTicket()ComponentmyST；myST=newFooter((5))；//PrintTicketwithfootersasneededmyST.prtTicket()；
填空题[说明]一般的树结构常采用孩子-兄弟表示法表示，即用二叉链表作树的存储结构，链表中节点的两个链域分别指向该节点的第一个孩予节点和下一个兄弟节点。例如，图4-1(a)所示的树的孩子-兄弟表示如图4-1fb)所示。函数LevelTraverse()的功能是对给定树进行层序遍历。例如，对图4-1所示的树进行层序遍历时，节点的访问次序为：DBAEFPC。对树进行层序遍历时使用了队列结构，实现队列基本操作的函数原型如下表所示。Bool、Status类型定义如下：typedefenumFALSE=0,TRUE=1Bool;typedefenumOVERFLOW=-2,UNDERFLOW=-1,ERROR=0,OK=1Status;树的二叉链表节点定义如下：typedefstructNodechardata；；structNode*fimrstchiid,*nextbrother;Node,*TreeNode;[函数]StatusLevelTraverse(TreeNoderoot)/*层序遍历树，树采用孩子-兄弟表示法，root是树根节点的指针*/QueuetempQ;TreeNodeptr,brotherptr;if(!root)returnERROR;InitQueue(＆tempQ);(1);brotherptr=root-＞nextbrother;while(brotherptr)EnQueue((2);/*end-while*/while((3))(4);printf("%c＼t",ptr-＞data);if((5))continue;(6);brotherptr=ptr-＞firstchild-＞nextbrother;while(brotherptr)EnQueue((7);/*end-while*//*end-while*/returnOK;)/*LevelTraverse*/
填空题[说明] 打印输出10行杨晖三角形。形式如下：杨晖三角形：11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 11 7 21 35 35 21 7 11 8 28 56 70 56 28 8 11 9 36 84 126 126 84 36 9 1 class yanghui public static void main (String args [] ) int i, j; (1) int yanghui [] []; System. out. println( “杨晖三角形：” ); yanghui = new int [ yhleve1] []; for(i =0;i ＜ yanghui, length; i + + ) yanghui[i] = new int [i + 1]; (2) for( (3) ) yanghui [i] [0] = 1; for(j = 1 ;j ＜ yanghui[i], length - 1 ;j + + ) yanghui[i] [j] = yanghui[i - 1] [j - 1] + yanghui[i - 1] [j]; yanghui[i] [yanghui[i]. length - 1 ] = 1; for ( i=0; i ＜ yanghui. length; i + + ) for(j =0;j ＜ yanghui[i]. length; j + + ) (4) System. out. println( );
填空题阅读以下说明和程序流程图，将应填入(n)处的字句写在对应栏内。[说明]假定用一个整型数组表示一个长整数，数组的每个元素存储长整数的一位数字，则实际的长整数m表示为：m=a[k]×10k-2+a[k-1]×10k-3+…+a[3]×10+a[2]其中a[1]保存该长整数的位数，a[0]保存该长整数的符号：0表示正数、1表示负数。注：数组下标从0开始。流程图(图4-1)用于计算长整数的加(减)法。运算时先决定符号，再进行绝对值运算。对于绝对值相减情况，总是绝对值较大的减去绝对值较小的，以避免出现不够减情况。注，此处不考虑溢出情况，即数组足够大。这样在程序中引进两个指针pA和pB，分别指向绝对值较大者和较小者。而对绝对值相加,情况，让pA指向LA，pB指向LB，不区分绝对值大小。pA±pB可用通式pA+flag*pB来计算，flag为+1时即对应pA+pB，flag为-1时即对应pA-pB。需特别注意的是，对于相减，不够减时要进行借位，而当最高位借位后正好为0时，结果的总位数应减1；对于加法，有最高进位时，结果的总位数应加1。流程图中涉及的函数说明如下：(1)cmp(int*LA，int*LB)函数，用于比较长整数LA与LB的绝对值大小，若LA绝对值大于LB绝对值则返回正值，LA绝对值小于LB绝对值返回负值，相等则返回0。(2)max(intA，intB)函数，用于返回整数A与B中较大数。另外，对流程图中的写法进行约定：(1)“：=”表示赋值，如“flag：=LA[0]+LB[0]”表示将“LA[0]+LB[0]”的结果赋给flag，相当于C中的赋值语句：“flag=LA[0]+LB[0]；”；(2)“：”表示比较运算，如“flag：1”表示flag与1比较。
填空题[说明]假定用一个整型数组表示一个长整数，数组的每个元素存储长整数的一位数字，则实际的长整数m表示为：m=a[k]×10k-2+a[k-1]×10k-3+...+a[3]×10+a[2]其中a[1]保存该长整数的位数，a[0]保存该长整数的符号：0表示正数、1表示负数。注：数组下标从0开始。流程图用于计算长整数的加(减)法。运算时先决定符号，再进行绝对值运算。对于绝对值相减情况，总是绝对值较大的减去绝对值较小的，以避免出现不够减情况。注，此处不考虑溢出情况，即数组足够大。这样在程序中引进两个指针pA和pB，分别指向绝对值较大者和较小者。而对绝对值相加情况，让pA指向LA，pB指向LB，不区分绝对值大小。pA±pB可用通式pA+flag*pB来计算，flag为+1时即对应pA+pB，flag为-1时即对应pA-pB。需特别注意的是，对于相减，不够减时要进行借位，而当最高位借位后正好为0时，结果的总位数应减1；对于加法，有最高进位时，结果的总位数应加1。流程图中涉及的函数说明如下：(1)cmp(int*LA，int*LB)函数，用于比较长整数LA与LB的绝对值大小，若LA绝对值大于LB绝对值则返回正值，LA绝对值小于LB绝对值返回负值，相等则返回0。(2)max(intA,intB)函数，用于返回整数A与B中较大数。另外，对流程图中的写法进行约定：(1)“:=”表示赋值，如“flag:=LA[0]+LB[0]”表示将“LA[0]+LB[0]”的结果赋给flag，相当于C中的赋值语句：“flag=LA[0]+LB[0];”；(2)“:”表示比较运算，如“flag:1”表示flag与1比较。
填空题阅读下列函数说明和C代码， [说明] 所谓货郎担问题，是指给定一个无向图，并已知各边的权，在这样的图中，要找一个闭合回路，使回路经过图中的每一个点，而且回路各边的权之和最小。 应用贪婪法求解该问题，程序先计算由各点构成的所有边的长度(作为边的权值)，按长度大小对各边进行排序后，按贪婪准则从排序后的各边中选择组成回路的边，贪婪准则使得边的选择按各边长度从小到大选择。 函数中使用的预定义符号如下： #define M 100 typedef struct/*x为两端点p1、p2之间的距离，p1、p2所组成边的长度*/ float x； int p1，p2； tdr； typedef struct/*p1、p2为和端点相联系的两个端点，n为端点的度*/ int n，p1，p2； tr； typedef struct/*给出两点坐标*/ float x，y； tpd； typedef int tl[M]； int n=10； [函数] float distance(tpd a，tpd b)；/*计算端点a、b之间的距离*/ void sortArr(tdr a[M]，int m)； /*将已经计算好的距离关系表按距离大小从小到大排序形成排序表，m为边的条数*/ int isCircuit(tr r[M]，int i，int j)； /*判断边(i，j)选入端点关系表r[M]后，是否形成回路，若形成回路返回0*/ void selected(tr r[M]，int i，int j)；/*边(i，j)选入端点关系表r*/ void course(tr r [M]，tl l[M])；/*从端点关系表r中得出回路轨迹表*/ void exchange(tdr a[M]，int m，int b)； /*调整表排序表，b表示是否可调，即是否有长度相同的边存在*/ void travling(tpd pd [M]，int n，float dist，tl locus[M]) /*dist记录总路程*/ tdr dr[M]；/*距离关系表*/ tr r[M]；/*端点关系表*/ int i，j，k，h，m；/*h表示选入端点关系表中的边数*/ int b；/*标识是否有长度相等的边*/ k=0； /*计算距离关系表中各边的长度*/ for(i=1；i＜n； i++) for(j=i+1；J＜=n；j++) k++; dr[k]．x= (1) ; dr[k]．pl=i; dr[k]．p2=j; m=k； sortArr(dr，m)；/*按距离大小从小到大排序形成排序表*/ do b=1; dist=0； k=h=0： do k++； i=dr[k]．p1； j=dr[k]．p2； if((r(i]．n＜=1)(r[j]．n＜=1))/*度数不能大于2*/ if (2) /*若边(i，j)加入r后形成回路，则不能加入*/ (3) ; h++； dist+=dr[k]．x； else if (4) /*最后一边选入r成回路，则该边必须加入且得到解*/ selected(r，i，j)； h++： dist+=dr[k]．x; while((k !=n) (h !=n))； if(h==n)/*最后一边选入构成回路，完成输出结果*/ course(r，locus)； else(/*找不到解，调整dr，交换表中边长相同的边在表中的顺序，并将b置0*/ (5) ; while(!b);
填空题阅读以下说明和程序流程图，将应填入(n)处的字句写在对应栏内。[说明]当一元多项式中有许多系数为零时，可用一个单链表来存储，每个节点存储一个非零项的指受和对应系数。为了便于进行运算，用带头节点的单链表存储，头节点中存储多项式中的非零项数，且各节点按指数递减顺序存储。例如：多项式8x5-2x2+7的存储结构为：流程图图3-1用于将pC(Node结构体指针)节点按指数降序插入到多项式C(多项式POLY指针)中。流程图中使用的符号说明如下：(1)数据结构定义如下：#defineEPSI1e-6structNode/*多项式中的一项*/doublec；/*系数*/inte；/*指数*/StructNode*next；；typedefstruct/*多项式头节点*/intn；/*多项式不为零的项数*/structNode*head；POLY；(2)Del(POLY*C，structNode*p)函数，若p是空指针则删除头节点，否则删除p节点的后继。(3)fabs(doublec)函数返回实数C的绝对值。[图3-1]
填空题Private Sub Command1_ Click( )
If List1. ListIndex ＞ ={{U}} (1) {{/U}}Then List1. RemoveItem{{U}} (2) {{/U}}Label1. Caption ={{U}} (3) {{/U}}
Else
MsgBox “请选择要删除的项目”
End If
End Sub
填空题[说明]以下函数完成求表达式的值，请填空使之完成此功能。floatsum(floatx)floats=0.0;intsign=1;(1);for(inti=1;(2);i++)t=t*x;s=s+(3);sign=-sign;(4);
填空题
阅读以下说明和Jrdva代码，将应填入{{U}} (n) {{/U}}处的字句写在对应栏内。
[说明]
在销售系统中常常需要打印销售票据，有时需要在一般的票据基础上打印脚注。这样就需要动态地添加一些额外的职责。如下展示了Decorator(修饰)模式。SalesOrder对象使用一个SalesTicket对象打印销售票据。图6-1显示了各个类间的关系。以下是Java语言实现，能够正确编译通过。
[图6-1] [Java代码]
//Component.java文件 public{{U}} (1) {{/U}}class
Component { abstract publ ic void prtTicket()；
} //salesTicket.java文件 public class
SalesTicket extends Component{ public void prtTicket(){
//Sales ticket printing code here
System.out.printin("SalesTicket")； } }
//Decorator.java文件 publ ic abstract class
Decorator extends Component{ public void prtTicket(){
if(myComp!=null)myComp.prtTicket()； }
private{{U}} (2) {{/U}}myComp； public
Decorator(Component myC){ myComp=myC； }
} //Footer.java文件 public
class Footer extends Decorator { public Footer(Component myC){
{{U}} (3) {{/U}}； }
public void prtTicket(){ {{U}} (4) {{/U}}；
prtFooter()； } publ ic void
prtFooter(){ //place printing footer code here
System.out.println("Footer")； } }
//salesorder.java文件 public class SalesOrder{
void prtTicket(){ Component myST；
myST=new Footer({{U}} (5) {{/U}})； //Print Ticket
with footers as needed myST.prtTicket()； }
}
填空题
阅读下列函数说明和C代码，将应填入{{U}} (n) {{/U}}外的字句写在对应栏内。
[说明]
为网球比赛的选手安排比赛日程。设有n(n=2m)位选手参加网球循环赛，循环赛共进行n-1天，每位选手要与其他n-1位选手赛一场，且每位选手每天赛一场，不轮空。
设n位选手被顺序编号为1，2，…，n，比赛的日程表是一个n行n-1列的表，第i行j列的内容是第i号选手第j天的比赛对手。用分治法设计日程表，就是从其中一半选手(2m-1位)的比赛日程导出全体2m选手的比赛日程。从众所周知的只有两位选手的比赛日程出发，反复这个过程，直至为n位选手安排好比赛日程为止。
如两位选手比赛日程表如下所示：
1
1
2
2
1如四位选手比赛日程表如下所示：
1
2
3
1
2
3
4
2
1
4
3
3
4
1
2
4
3
2
1 函数中使用的预定义符号如下：
#define M 64 int a[M+1][M];
[函数] voidd main(){ int
twoml,twom,i,j,m,k; printf("指定n(=2的k次幂)位选手，请输入k：/n");
scanf("%d",＆k); /*8预设两位选手的比赛日程*/
a[1][1] =2; a[2][1] =1; m=1;
twoml=1; while ({{U}} (1) {{/U}}){
m++; twoml+=twoml;
twom=twoml*2;/*为2^m位选手安排比赛日程*/ /*填日程表的左下角*/
for(i=twoml+1;{{U}} (2) {{/U}};i++){ for(j=1;
j a[i][j]=a[i-twoml][j]+twoml;
} } /*填日程表的右上角*/
a[1][twoml]={{U}} (3) {{/U}};/+填日程表右上角的第1列*/
for(i=2; i a[i][twoml]=a[i-1][twoml]+1;
} /*填日程表右上角的其他列，参照前一列填当前列*/
for(j=twoml+1; j(twom;j++){ for(i=1; i
a[i][j]={{U}} (4) {{/U}}; }
a[twoml][j]=a[1][j-1]; } /*填日程表的右下角*/
for(j=twoml; j for(i=1;i a[{{U}} (5) {{/U}}[j]=i; }
} /*输出日程表*/ for(i=1;
i for(j=1;j
printf("%4d",a[i][j]); } printf("/n");
} printf("/n"); }
}
填空题阅读以下说明和程序流程图，将应填入{{U}}(n){{/U}}处的字句写在对应栏内。[说明]当一元多项式中有许多系数为零时，可用一个单链表来存储，每个节点存储一个非零项的指受和对应系数。为了便于进行运算，用带头节点的单链表存储，头节点中存储多项式中的非零项数，且各节点按指数递减顺序存储。例如：多项式8x5-2x2+7的存储结构为：流程图图3-1用于将pC(Node结构体指针)节点按指数降序插入到多项式C(多项式POLY指针)中。流程图中使用的符号说明如下：(1)数据结构定义如下：#defineEPSI1e-6structNode{/*多项式中的一项*/doublec；/*系数*/inte；/*指数*/StructNode*next；}；typedefstruct{/*多项式头节点*/intn；/*多项式不为零的项数*/structNode*head；}POLY；(2)Del(POLY*C，structNode*p)函数，若p是空指针则删除头节点，否则删除p节点的后继。(3)fabs(doublec)函数返回实数C的绝对值。[图3-1]
填空题[说明] 编写一个Application，从键盘输入整数n，并计算从1到n的累加和。 import java. io. *; public class Application1 public static void main(String [] args) String s = " "; int n, sum = 0; System. out. println (“计算从1到n 的累加和。”); System. out. print( “请输入n的值:”); try (1) BufferedReader br = new BufferedReader(isr); (2) catch(Exception e) (3) for(int i=l; i＜ =n; i++) (4) System. out. println ( “你刚才的输入是：” + n); System. out. println ( “1到n的累加和是：”+ sum);
填空题
阅读以下说明和Java代码，将应填入{{U}} (n) {{/U}}处的字句写在对应栏内。 [说明]
在一些大型系统中，大多数的功能在初始化时要花费很多时间，如果在启动的时候，所有功能(连不用的功能)都要全面初始化的话，会连带影响到应用软件要花很多时间才能启动。因此常将程序设计成到了实际要使用某种功能的阶段才初始化该功能。
以下示例展示了Proxy(代理)模式，PrinterProxy类执行一些比较“轻”的方法——设置名称和取得名称，需要真正执行“重”的方法——真正打印——时才初始Print类。图6-1显示了各个类间的关系。
[图6-1] [Java代码]
//Printable.Java publiC{{U}} (1) {{/U}}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{{U}} (2) {{/U}}Printable{ private String
name； private Printer real； public
PrinterProxy(){} public PrinterProxy(String name){
this.name=name； } public gynchronized
void setPrinterName(String name){ if({{U}} (3) {{/U}}){
real.setPrinterName(name)； }
this.name=name； } public String
getprinterName(){ return name； }
public void print(String string){ {{U}} (4)
{{/U}}； real.print(string)； }
private synchronized void realize(){//产生真正的Printer对象
if(real==null){ real={{U}} (5) {{/U}}；
} } }
填空题阅读以下说明和Java代码，将应填入(n)处的字句写在对应栏内。[说明]在一些大型系统中，大多数的功能在初始化时要花费很多时间，如果在启动的时候，所有功能(连不用的功能)都要全面初始化的话，会连带影响到应用软件要花很多时间才能启动。因此常将程序设计成到了实际要使用某种功能的阶段才初始化该功能。以下示例展示了Proxy(代理)模式，PrinterProxy类执行一些比较“轻”的方法——设置名称和取得名称，需要真正执行“重”的方法——真正打印——时才初始Print类。图6-1显示了各个类间的关系。[图6-1][Java代码]//Printable.JavapubliC(1)PrintablepublicabstractvoidsetPrinterName(Stringname)；publicabstractStringgetprinterName()；publicabstractvoidprint(Stringstring)；//Printer.JavapublicclassPrinterimplementsPrintableprivateStringname；publicPrinter()System.out.println("正在产生Printer的对象实例")；publicPrinter(Stringname)this.name=name；heavyJob("正在产生Printer的对象实例("+name+")")；publicvoidsetPrinterName(Stringname)this.name=name；publicStringgetPrinterName()returnname；publicvoidprint(Stringstring)System.out.println("==="+name+"====")；System.out.println(string)；//PrinterProxy.JavapublicclassPrinterProxy(2)PrintableprivateStringname；privatePrinterreal；publicPrinterProxy()publicPrinterProxy(Stringname)this.name=name；publicgynchronizedvoidsetPrinterName(Stringname)if((3))real.setPrinterName(name)；this.name=name；publicStringgetprinterName()returnname；publicvoidprint(Stringstring)(4)；real.print(string)；privatesynchronizedvoidrealize()//产生真正的Printer对象if(real==null)real=(5)；
填空题Private Sub Command1_ Click( )If List1. ListIndex ＞ = (1) Then List1. RemoveItem (2) Label1. Caption = (3) ElseMsgBox “请选择要删除的项目”End IfEnd Sub
填空题[说明] 若s和t是用单链表存储的两个串，设计一个函数将s串中首次与串t匹配的字串逆置。 linkstring * invert - substring ( s, t) linkstring * s, * t; linkstring *prior, *p, *t1, *r, *q, *u; prior =s; p=s; t1 =t; if ( (1) ) printf ( "error/n") ; else while p ! = NULL t1 = t1- ＞link; else (2) p = prior - ＞ link; t1 = t- ＞link; if ( t1 ! : NULL) printf ("cannot find"); else (3) r = q- ＞link; q- ＞link = p; while (r ! = p) u = r- ＞link; (4) q=r; r = u; (5)
填空题[说明] 设计一个普通函数distance (Point
public:
Point(int i, int j) {{{U}} (1) {{/U}}
int getx( ) { return x;}
int gety( ) { return y; }
void disp( )
{
{{U}} (2) {{/U}}
}
};
float distance( Point
{{U}}(3) {{/U}}
return d;
}
void main( )
{
{{U}} (4) {{/U}}
p1. disp ( ); cout ＜ ＜“与”; p2. diap( );
cout＜ ＜“之间距离=” ＜ ＜distance (p1,p2) ＜ ＜end1;
}
填空题[说明] 已有一个工程文件，窗体上有两个图片框，名称为P1，P2。分别用来表示信号灯合汽车，其中在P1中轮流装入“黄灯.ico”、“红灯.ico”、“绿灯.ico”文件来实现信号灯的切换；还有两个计时器 Timer1 和Timer2，Timer1 用于变换信号灯，黄灯1秒，红灯2秒，绿灯3秒；Timer2用于控制汽车向左移动。运动时，信号灯不断变换，单击“开车”按钮后，汽车开始移动，如果移动到信号灯前或信号灯下，遇到红灯或黄灯，则停止移动。下面是实现上述功能的程序，请填空。
Private Sub Timer41_ Timer()
a=a+1
If{{U}} (1) {{/U}}Then
a=1
End If
Select Case a
Case 1
P1. Picture = LoadPicture( “黄灯.ico” )
Case 2, 3
P1. Picture = LoadPicture( “红灯”.ico” )
Case4, 5, 6
P1. Picture = LeadPicture( “绿灯. ico” )
{{U}} (2) {{/U}}
End Select
End Sub
Private Sub Timer2_Timer( )
If{{U}} (3) {{/U}}And (P2. Left ＞ P1. Left And P2. Left ＜ P1. Left + P1. Width) Or P2. Left ＜ = 100 Then
Timer2. Enabled = False
Else
{{U}} (4) {{/U}}
End If
End Sub