银符考试题库-在线练习-中级软件设计师下午试题模拟48

试题一
阅读下列说明和图，回答问题1至问题3，将解答填入对应栏内。
[说明]
某汽车数字仪表系统将完成下述功能：
(1)通过模一数转换，实现传感器和微处理器的接口。
(2)在发光二极管面板上显示数据。
(3)指示速度(mph)、行驶里程、油耗(mpg)等。
(4)指示加速或减速。
以下是经分析得到的数据流图，有些地方有待填充，假定顶层数据流图是正确的。图1-1是顶层数据流图，图1-2是第0层数据流图，图1-3是第1层数据流图，其中A是加工1的细化图，B是加工2的细化图。图中，△sps表示转速sps的瞬时变化值，若△sps＞0则汽车加速，△sps＜0则减速，△sps=0则匀速。假定题中提供的顶层图是正确的，请回答下列问题。
[图1-1]

[图1-2]

[图1-3]

1. 第0层数据流图(图1-2)中有一条缺失的数据流，请指出该数据流的起点和终点。
加工1的细化图(图1-3中的A)中有一条缺失的数据流，请指出该数据流的起点和终点。

图1-2中，缺失的数据流：速度mph，起点：加工1速度处理，终点：仪表板图1-3A中，缺失的数据流：加速/减速，起点：加工1.2确定加速/减速，终点：仪表板

分层数据流图应时刻牢记父图与子图平衡原则。对这种数据流缺失题目，认真对照父图与子图就可答案。另外，还要注意与文件的交互，包括错误数据流大多也是出在此。
将第0层数据流图(图1-2)与项层数据流图(图1-1)仔细对照，可以发现缺失了输出数据流“速度”，其起点为加工1速度处理，终点为仪表板。数据流“速度mph”虽然从加工1输出到了加工2，但这内部数据流。
同理，加工1的细化图(图1-3A)缺失了数据流“加速/减速”，其起点是加工1.2确定加速/减速，终仪表板。

2. 加工2的细化图(图1-3中的B)中有一条错误的数据流，请指出该数据流的起点或终点(若可以，指出两者)。

图1-3B中，错误的数据流：速度mph，起点：加工2.2计算油耗

仔细对照加工2(图1-2)和加工2的细化图(图1-3B)，可以发现对于加工2.2数据流“速度mph”作出数据，而该数据流应该是输入数据。

3. 小说明是用来描述加工的。小说明的描述方法有哪些?请分别用这些描述方法描述加工1.2。

小说明并不描述具体的加工过程，常用的有自然语言、结构化自然语言、判定表和判定树。
自然语言描述：若△sps＞0则汽车加速，△sps＜0则减速，△sps=0则匀速。
结构化自然语言描述：IF △sps＞0 THEN加速
ELSE IF △sps＜0 THEN减速
ELSE匀速
判定表描述：

试题二
阅读下列说明和E-R图，回答问题1至问题3，将解答填入对应栏内。
[说明]
设有下列关于学生成绩管理系统的E-R图(见图2-1)。图中矩形表示实体，圆表示属性，双圆表示关键字属性，菱形表示实体间的联系。假定已通过下列SQL语言建立了基本表：

CREATE TABLE STUDENT(SNo CHAR 6 NOT NULL UNIQUE，
SName CHAR(20)，
Sex CHAR 1 ，
Dept CHAR(20)，
Age SMALLINT)；
CREATE TABLE COURSE(CNo CHAR 6 NOT NULL UNIQUE，
CName CHAR(20)，
Hour SMALLINT，
Credit SMALLINT)；
CREATE TABLE SC (SNo CHAR 6 ，
CNo CHAR 6 ，
GRADE SMALLINT，
PRIMARY KEY (SNo，CNo))；
为了答题的方便，图中的实体和属性同时给出了中英文两种名字，回答问题时只须写出英文名即可。
填充下列SQL程序5.1～5.4中的 1 ～ 6 ，使它们分别完成以下查询功能：
程序5.1：检索选修所有课程的学生姓名。
程序5.2：给出全体学生人数。
程序5.3：按学号给出每个学生的平均成绩。
程序5.4：按学号给出每个学生选修课程的门数。
[程序5.1]
SELECT SName FROM STUDENT WHERE 1
(SELECT FROM COURSE WHERE 2
(SELECT * FROM SC WHERE 3 ))
[程序5.2]
SELECT 4 FROM STUDENT
[程序5.3]
SELECT 5 FROM SC GROUP BY SNO
[程序5.4]
SELECT 6 FROM SC GROUP BY SNO

1.

NOT EXISTS

2.

NOT EXISTS

3.

STUDENT.SN0=SC.SN0 AND COURSE.CNO=SC.CNO

4.

COUNT(*)

5.

SNO，AVG(GRADE)

6.

SNO，COUNT(CNO)

本题主要是考察SQL。SQL中数据查询是最常用的，其完整形式如下：
SELECT [ALL | DISTINCT]＜目标列表达式＞[，＜目标列表达式＞]…
FROM ＜表名或视图名＞[，＜表名或视图名＞]
[WHERE ＜条件表达式＞]
[GROUP BY＜列名1＞[HAVING＜条件表达式＞]]
[ORDER BY＜列名2＞[ASC | DESC]…]
子句顺序为SELECT、FROM、WHERE、GROUP BY、HAVING、ORDER BY，但SELECT和FROM是必须的，HAVING子句只能与GROUP BY搭配起来使用。
该成绩管理系统的关系模式有：STUDENT(SNo，SName，Sex，Dept，Age)，主键为SNo，COURSE(CNo，CName，Hour，Credit)，主键为CNo，SC(SNO，CNO，GRADE)，主键为(Sno，CNo)。
程序5.1是检索选修所有课程的学生姓名，亦即“不存在没有选修的课程”。空(1)是引出子查询的，该类连接词有：IN、NOT IN、EXISTS、NOT EXISTS，EXISTS引出的子查询一般是SELECT*型，故排除IN型；再据语意分析应填NOT EXISTS。空(2)同理得应填NOT EXISTS。空(3)是“真正”的查询条件，该查询涉及到三个表STUDENT、COURSE、CS，故应填STUDENT.SNO=SC.SNO ANDCOURSE.CNO=SC.CNO。
程序5.2是给出全体学生人数，涉及集函数的应用。常用的集函数有：COUNT、SUM、AVG、MAX、MIN。在此用到COUNT，故空(4)应填COUNT(*)。
程序5.3是按学号给出每个学生的平均成绩，同样是集函数，AVG的应用。要注意的是需要同时给出学号，故空(5)应填：SNO，AVG(GRADE)。
程序5.4是按学号给出每个学生选修课程的门数，属COUNT的用法，并注意同时给出学号。故空(6)应填：SNO，COUNT(CNO)。

试题三
阅读以下说明和程序流程图，将应填入 (n) 处的字句写在对应栏内。
[说明]
当一元多项式

中有许多系数为零时，可用一个单链表来存储，每个节点存储一个非零项的指受和对应系数。
为了便于进行运算，用带头节点的单链表存储，头节点中存储多项式中的非零项数，且各节点按指数递减顺序存储。例如：多项式8x⁵-2x²+7的存储结构为：

流程图图3-1用于将pC(Node结构体指针)节点按指数降序插入到多项式C(多项式POLY指针)中。
流程图中使用的符号说明如下：
(1)数据结构定义如下：
#define EPSI 1e-6
struct Node{ /*多项式中的一项*/
double c； /*系数*/
int e； /*指数*/
Struct Node *next；
}；
typedef struct{ /*多项式头节点*/
int n； /*多项式不为零的项数*/
struct Node *head；
}POLY；
(2)Del(POLY *C，struct Node *p)函数，若p是空指针则删除头节点，否则删除p节点的后继。
(3)fabs(double c)函数返回实数C的绝对值。
[图3-1]

1.

C-＞head：=pC

2.

pC-＞next：=C-＞head

3.

tp：=NULL

4.

t：NULL

5.

t：=NULL

该流程图是用于将pC(Node结构体指针)节点按指数降序插入到多项式C(多项式POLY指针)中。需要特别注意特殊情况：C为空多项式，即插入第一项时的处理；当pC的指数比C中的最大指数还大时的处理；当pC的指数与C中某项的指数相同时，进行系数相加，若相加后为0时的处理。
根据结构体POLY的声明，可知C-＞head为NULL意味着多项式为空，将pC作为第一项插入，故空(1)应填C-＞head：=pC。
pC-＞e＞C-＞head-＞e意味着pC的指数比C中的最大指数还大，此时应将将pC作为第一项插入，处理方式同上，故空(2)应填pC-＞next：=C-＞head。
先分析空(4)，控制流可以从两条路到达空(4)处，一是t==NULL(到了多项式C的末尾)，亦即pC的指数比C中最小的还小，此时须将pC插入到末尾；一是t-＞e=：pC-＞e(找到同指数项，进行合并)，显然t!=NULL，此时不必在作任何操作。因此可通过判断t是否为NULL区分这两种情况，故空(4)处应填t：NULL。
要将pC插入到末尾，此时t==NULL，因此须正确记录其前驱方可插入(单链表)，注意到空(4)分支t==NULL时的处理用到tp，易于判断tp正是用来记录前驱的。亦可at-＞e＞pC-＞e时的处理：tp：=t、t：=t-＞next得到验证。纵观流程，tp没有赋初值，这样，空(3)处就应该是对其赋初值，故应填tp：=NULL。
再来看空(5)，此时是t-＞e＜pC-＞e，注意到C是降序排序(对指数而言)的，也就是说t以前(不包括t)的指数均大于pC，以后(包括t)的均小于pC，这样pC就应该插在t以前(据上述分析，亦即tp以后)。而(5)后的控制流是回到判断t：NULL，因此，此处应填t：=NULL。这样，就可将pC正确的插入tp之后，t之前，这个工作由空(4)的分支t==NULL完成。

试题四
阅读下列说明和C程序，将应填入 (n) 处的字句写在对应栏中。
[说明]
借助一个栈结构，可实现二叉树的非递归遍历算法。InOrderTraverse数实现中序非递归遍历，遍历
过程如下：
若不是空树，根节点入栈，进入左子树；若已经是空树，则栈顶元素出栈，访问该元素(根节点)，进入该节点的右子树，继续直到遍历完成。
函数中使用的预定义符号如下：
typedef struct BiTNode{
int data；
struct BiTNode *iChiid，*rChiid；
} BiTNode，*BiTree；
typedef struct SNode{/*链栈的节点类型*/
BiTree elem；
struct SNode *next；
}SNode；
[函数]
int InOrderTraverse(BiTree root)
{
BiTree P；
SNode *q，*stop=NULL；/*不带头节点的单链表作为栈的存储结构*/
P=root；
while(p !=NULL || stop !=NULL){
if( 1 ){ /*不是空树*/
q=(SNode*)malloc(sizeof q)；
if(q==NULL)return-1；
/*根节点指针入栈*/
2 ；
q-＞elem=P；
stop=q；
P= 3 ； /*进入根的左子树*/
}else{
q=stop；
4 ； /*栈顶元素出栈*/
printf("%d|，q-＞elem-＞data)； /*防问根节点*/
P= 5 ； /*进入根的右子树*/
free(q)； /*释放原栈顶元素*/
}/*if*/
}/*while*/
return 0；
}/*InOrderTraverse*/

1.

P!=NULL

2.

q-＞next=stop

3.

p-＞lChild

4.

stop=stop-＞next

5.

q-＞elem-＞rChild

本题考察的是二叉树的遍历以及链栈的使用。
由注释可知，空(1)是“不是空树”的条件，应填P!=NULL。
空(2)是链栈入栈操作，stop是指向链栈栈顶的指针，故空(2)应填q-＞next=stop。
空(3)进入根的左子树，故应填P-＞lChild。
空(4)是链栈出栈操作，stop是指向链栈栈顶的指针，出栈后，应修改栈顶指针，故应填stop=stop-＞next。
空(5)是进入右子树，要注意的是，此处是通过链栈节点q进行访问，不能想当然的认为是q-＞rChild，而应该是q-＞elem-＞rChild。

试题五
阅读下列函数说明和C++代码，将应填入 (n) 处的字句写在对应栏内。
[说明]
在一些大型系统中，大多数的功能在初始化时要花费很多时间，如果在启动的时候，所有功能(包括不用的功能)都要全面初始化的话，会导致应用软件要花很多时间才能启动。因此常将程序设计成到了实际要使用某种功能的阶段才初始化该功能。
以下示例展示了Proxy(代理)模式，PrinterProxy类执行一些比较“轻”的方法，需要真正执行“重”的方法时才初始化Print类。图5-1显示了各个类间的关系。
[图5-1]

[C++代码]
class Printable{
public：
virtual void setPrinterName(string name)=0；
virtual string getprinterName()=0；
virtual void print(string name)=0；
}；
class Printer：public Printable{
private：
string name；
public：
Printer(string name){
cout＜＜"正在产生Printer的对象实例"＜＜endl；
this－＞name=name；
}
void setPrinterName(string name){
this-＞name=name；
}
string getPrinterName(){
return name；
}
void print(string msg){
cout＜＜"======="＜＜name＜＜"==========="＜＜endl；
cout＜＜msg＜＜endl；
}
}；
class printerproxy ：public 1 {
private：
String name；
Printer *real；
public：
PrinterProxy(string name){
2 =NULL；
this-＞name=name；
}
void setPrinterName(string name){
if( 3 )real-＞setPrinterName(name)；
this-＞name=name；
}
string getPrinterName(){
return name；
}
void print(string msg){
4 ；
real-＞print(msg)；
}
void realize(){
if(real==NULL)real= 5 ；
}
}；

1.

Printable

2.

real

3.

real!=NULL

4.

realize()

5.

new Printer(name)

由类图可知PrinterProxy类是Printable的子类，因此应声明为继承自Printable，故空(1)应填Printable。
real是一个Printer对象指针，应该进行初始化，初始化工作是在构造函数中完成的，若不进行初始化的话，realize()方法将不可预期，故空(2)应填real。
real是一个指针，调用之前当然得先判断real是否为空指针，只有不是空指针才能进行调用，否则将出现不可预期的结果，因此空(3)应填real!=NULL。
在执行打印时，需要保证已经正确生成了real对象，否则打印将无法完成，这也正是Proxy的核心所在，到真正需要打印时，才生产real对象，因此空(4)应填realize()。
real是Printer对象指针，空(5)是生成一个Printer对象，注意Printer类的构造函数是Printer(string name)，故应填new Printer(name)。

试题六
阅读以下说明和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.

interface

2.

implements

3.

real !=null

4.

realize()

5.

new Printer(name)

在Java中，interface和abstract class均能包含抽象方法，“类是用来继承的(extends)，接口是用来实现的(implements)。”由类Printer的声明可判知Printable应为接口，故空(1)应填interface。
因Printable是一个接口，故空(2)应填implements。该空比较简单。
real是一个引用，调用之前当然得先判断real是否为空，只有不是空才能进行调用，否则将出现不可预期的结果，因此空(3)应填real !-NULL。
在执行打印时，需要保证已经正确生成了real对象，否则打印将无法完成，这也正是Proxy的核心所在，到真正需要打印时，才生产real对象，因此空(4)应填realize()。
real是Printer对象引用，空(5)是生成一个Printer对象，注意Printer类的构造函数是Printer(string name)，故应填new Printer(name)。顺便说一下，生成real对象时，进行Treal是否为空的判断，并将方法realize()声明为synchronized，这是为了避免生成多个real对象，有一个即可。

试题七
阅读以下说明和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.

k !=i

2.

(Node *)malloc(sizeof P)

3.

q-＞cmp(p)

4.

q-＞index

5.

q==NULL

该题涉及二叉排序树的应用、直接插入排序算法等。
空(1)所在函数是直接插入排序的一个实现，理解了直接插入排序算法很容易得出答案，条件(1)成立时，需要进行交换，故空(1)应填“k!=i”。
空(2)比较简单，p声明为指针，在引用(reCompse(p，temp)之前需要申请空间，故空(2)应填“(Node *)malloc(sizeof P)”。
接下来在二叉排序上进行查找。while循环体内只有两个分支，一个是flag＜0时继续往左子树搜索，另一个就是往右子树搜索，此时应该对应的是flag＞0。据此可判知，flag存储的是查找节点p与当前节点q之间的大小关系，显然是调用类Node的cmp方法，故空(3)应填“cmp(q，p)”。注意，不能填成“cmp(p，q)”，那样将不可能找到匹配的，因为该二叉排序树是左子树小于根节点，而cmp(q，p)当p比q小时返回负值，搜索应往左子树继续。
空(4)是找到匹配时返回，根据函数注释，函数find的返回值是匹配单词在WordList数组中的下标，结构Node的index域正好存储的是下标。故空(4)应填“q-＞index”。
空(5)是查找失败的情况，对应条件为“q==NULL”。故空(5)应填“q==NULL”。