最全程序员软考考试下午模拟试题合集

申明：此为最全程序员软考考试下午模拟试题合集，一共32套。

均配有答案。

由于文件过大，拆成上午试题和下午试题，在百度文库同样可以搜索“最全程序员软考考试上午模拟试题合集“。

此外还有程序员软考试题真题提供，百度文库搜索“最全历年程序员软考考试上午真题合集”和“最全历年程序员软考考试下午真题合集”。

每套后面均配有答案，接近30套，每年两套。

注：如果图片显示不全，适当将图片缩小即可。

过来人总结，多做做下午场试题，最好打印。

上午场试题对着电脑即可，只要不是一点不懂基本上午场没问题。

初级程序员下午试题模拟37
试题一
阅读以下说明和流程图，填补流程图中的空缺1～2，将解答填入对应栏内。

[说明]
假设数组A中的各元素A1,A4,…,A(M)已经按从小到大排序(M≥1)；数组B中的各元素B1,B4,…,B(N)也已经按从小到大排序(N≥1)。

执行下面的流程图后，可以将数组A与数组B 中所有的元素全都存入数组C中，且按从小到大排序(注意：序列中相同的数全部保留并不计排列顺序)。

例如，设数组A中有元素：2,5,6,7,9；数组B中有元素：2,3,4,7；则数组C 中将有元素：2,2,3,4,5,6,7,7,9。

[流程图]
试题二
阅读以下说明和C函数，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
某单位准备进行一次选举，对指定的n名(n＜80)候选人进行投票。

为了简化选举工作，事先印制了写有这n名候选人姓名的选票，投票者只需将选中者名下的圆圈涂黑即可。

规定每张选票上被涂黑的圆圈数不得超过3个，也不得少于1个，否则视为无效选票。

投票
结束后，所有选票经计算机扫描处理，形成了描述选票状态的文本文件。

例如，n=8时所形成的文件如下：
01011000
10010100
10011000
11111111
00000000
00111000
其中，每行表示一张选票的数据，每列代表一位候选者的得票情况。

第i行第j列为1，表示第i张选票上投了第j名候选人1票。

函数statistic15的功能是读入选票数据，并统计每位候选者的得票数，函数返回有效选票数。

[C语言函数]
int statistic (FILE *fp, int candidate[], int n)
{ /*从文件中读入选票数据，n为候选人数量(n＜80)，
从有效选票中统计每位候选者的得票数并存入candidate[]，函数返回有效选票数*/
char str[80]; /*str保存读入的一张选票数据*/
int i, tag=0;/* tag用于判断每张选票是否有效*/
int q=0;/* q用于计算有效选票数*/
for (i=0;i＜n;i++)
candidate[i]=0；
while ( 10 ) {
fgets (str,80,fp); /*读入一张选票数据*/
for (tag=0,i=0; ( 11 );i++)
if (str[i]=='1') tag++;
if ( 12 ) {/*(若是有效选票，则进行统计*/
( 13 );
for (i=0;i＜n;i++)
if (str[i]=='1') 14 ;
}
}
return q;
} /*statistic*/
试题三
阅读以下说明和C语言函数，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
一棵非空二叉树中“最左下”结点定义为：若树根的左子树为空，则树根为“最左下”结点：否则，从树根的左子树根出发，沿结点的左孩子分支向下查找，直到某个结点不存在左孩子时为止，该结点即为此二叉树的“最左下”结点。

例如，下图所示的以A为根的二叉树的“最左下”结点为D，以C为根的子二叉树中的“最左下”结点为C。

二叉树的结点类型定义如下：
typedef struct BSTNode{
int data；
struct BSTNode *1ch,*rch; /*结点的左、右孩子指针*/
}*BSTree;
函数BSTree Find_Del(BSTree root)的功能是：若root指向一棵二叉树的根结点，则找出该结点的右子树上的“最左下”结点*p，并从树下删除以*p为根的子树，函数返回被册除子树的根结点指针：若该树根的右子树上不存在“最左下”结点，则返回空指针。

[函数]
BSTree Find_Del(BSTree root)
{
BSTree p,pre;
if (!root)return NULL; /*root指向的二叉树为空树*/
15 ; /*令p指向根结点的右子树*/
if (!p) return NULL;
16 ; /*设置pre的初值*/
while (p-＞1ch) {
pre=p;p= 17 ;
}
if ( 18 ==root) /*root的右子树根为"最左下"结点*/
pre-＞rch=NULL;
else
19 =NULL; /*删除以"最左下"结点为根的子树*/
return p;
}
试题四
阅读以下函数说明和C语言函数，将应填入(n) 的字句写在答题纸的对应栏内。

[说明1]
函数int fun1(int m, int n)的功能是：计算并返回正整数m和n的最大公约数。

[函数1]
int fun1(int m, int n)
{
while ( 20 ) {
if (m＞n) m=m-n;
else n=n-m;
}
21 ;
}
[说明2]
函数long fun2(char*str)的功能是：自左至右顺序取出非空字符串str中的数字字符形成一个十进制整数(最多8位)。

例如，若字符串str的值为“f3g8d5.ji2e3p12fkp”，则函数返回值为3852312。

[函数2]
long fun2(char *str)
{
int i=0;
long k=0;
char *p=str;
while (*p!='＼0' && 22 ) {
if (*p＞='0' && *p＜='9') {
k= 23 + *p - '0';
++i;
}
24 ;
}
return k;
}
试题五
从下列2道试题(试题5至试题6)中任选1道解答。

如果解答的试题数超过1道，则题号小的1道解答有效。

阅读下列说明、图和C++代码，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
已知对某载客车辆(Car)进行类建模，如图5-1所示，其中类Engine表示发动机引擎，类Wheel表示车轮，类Body表示车身，类Driver表示司机，类Passenger表示乘客。

[C++代码]
const int 25 =7; //定义最多载客数
const int MAX WHEELS=5; //定义最多轮胎数class Body{
//此处代码省略
}; //车身类
class Passenger{
//此处代码省略
}; //乘客类
class Wheel{
//此处代码省略
};//车轮类
class Driver{ //司机类
public:
string name；//表示第几路公交车司机
Driver(string driverName):name( 26 ){}; //构造函数
};
class Engine{ //引擎类
public:
string engineNo; //引擎编号
Engine(string engineNo){ 27 -＞engineNo=engineNo;} //构造函数
};
class Car{ //汽车类
protected:
Engine * engine; Driver * driver; Body body;
Wheel * wheels[MAX_HEELS]; Passenger * passengers[MAX_PASSENGERS]; public:
Car(Driver * driver){//构造函数
this-＞driver=driver;
engine=new Engine("TX6536型号引擎");
int index;
for (index=0; index＜MAX_HEELS; index++){
wheels[index]=new Wheel30;
}
for(index=0; index＜MAX_PASSENGERS; index++){
passengers[index]=NULL;
}
}
virtual～Car30 {//析构函数
for (int index=0; index＜MAX_WHEELS; index++)
delete wheels[index];
delete 28 ;
}
int getPassengerNumber30{//获取车上乘客数量
//此处代码省略
}
void getOnPassenger(Passenger * aPassenger){//乘客上车
//此处代码省略
}
void run30{//开车
if(driver==NULL) { cout＜＜"司机尚未上车!"; return; }
//此处代码省略
}
)；
void main30{
Driver driver("第五路公交车司机");
Car car ( 29 );
Passenger passengers [MAX_PASSENGERS];
for (int index = 0; index＜MAX PASSENGERS; index++) //乘客上车处理
car.getOnPassenger(&passengers[index]);
car.run30;
}
试题六
阅读下列说明、图和Java代码，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
已知对某载客车辆(Car)进行类建模，如图6-1所示，其中类Engine表示发动机引擎，类Wheel表示车轮，类Body表示车身，类Driver表示司机，类Passenger表示乘客。

[Java代码]
class Body{
//此处代码省略
}; //车身类
class Passenger{
//此处代码省略
}; //乘客类
class Wheel{
//此处代码省略
}; //车轮类
class Driver{//司机类
public String name;//表示第几路公交车司机
public Driver(String driverName){name=driverName;)//构造函数
};
class Engine{//引擎类
public String engineNo; //引擎编号
public Engine(String engineNo) {this.engineNo=engineNo;)//构造函数};
public class Car{//汽车类
static final int 30 =7;//定义最多载客数
static final int MAX WHEELS=5;//定义最多轮胎数
protected Engine engine;
protected Driver driver;
protected Body body=new Body35;
protected Wheel[] wheels;
protected Passenger[] passengers;
public Car(Driver driver) {//构造函数
31 .driver=driver;
engine=new Engine("TX6536型号引擎");
wheels=new Wheel[MAX WHEELS];
passengers=new Passenger[MAX_PASSENGERS];
for (int index=0; index＜MAX_WHEELS; index++) { wheels[index]=new Wheel35;
}
for(int index=0; index＜MAX_PASSENGERS; index++){ passengers[index]=null;
}
}
int getPassengerNumber35 {//获取车上乘客数量
//此处代码省略
return 0;
}
void getOnPassenger(Passenger aPassenger) {//乘客上车//此处代码省略
}
void run35 {//开车
if( 32 ) {System.out.println("司机尚未上车!");return;}
//此处代码省略
}
public static void main(String args[]){
Driver driver=new Driver("第五路公交车司机");
Car car=new Car( 33 );
for (int index=0; index＜MAX_PASSENGERS; index++)
car.getOnPassenger( 34 Passenger35);
car.run35;
}
}
答案:
试题一
1、2、A(i) 3、B(j) 4、5、6、B(j) 7、A(i) 8、9、
试题二
10、!feof(fp) 11、i＜n && str[i]!='＼0' 12、tag＞=1 && tag＜=3 13、q++ 14、candidate[i]++
试题三
15、p=root-＞rch 16、pre=root 17、p-＞lch 18、pre 19、pre-＞lch
试题四
20、m!=n 21、return n或return m 22、i＜8 23、k*10 24、p++
试题五
25、MAX_PASSENGERS 26、driverName 27、this 28、engine 29、&driver
试题六
30、MAX_PASSENGERS 31、this 32、driver==null 33、driver 34、new
初级程序员下午试题模拟38
试题一
阅读以下说明和算法，完善算法并回答问题，将解答写在对应栏内。

[说明]
假设以二维数组G[1..m,1..n]表示一幅图像各像素的颜色，则G[i,j]表示区域中点(i,j]处的颜色，颜色值为0到k的整数。

下面的算法将指定点(i0,j0)所在的同色邻接区域的颜色置换为给定的颜色值。

约定所有与点(i0,j0)同色的上、下、左、右可连通的点组成同色邻接区域。

例如，一幅8×9像素的图像如图1-1所示。

设用户指定点(3,5)，其颜色值为0，此时其上方(2,5)、下方(4,5)、右方(3,6)邻接点的颜色值都为0，因此这些点属于点(3,5)所在的同色邻接区域，再从上、下、左、右四个方向进行扩展，可得出该同色邻接区域的其他点(见
图1-1中的阴影部分)。

将上述同色区域的颜色替换为颜色值7所得的新图像如图1-2所示。

[算法]
输入：矩阵G，点的坐标(i0,j0)，新颜色值newcolor。

输出：点(i0,j0)所在同色邻接区域的颜色置换为newcolor之后的矩阵G。

算法步骤(为规范算法，规定该算法只在第七步后结束)：
第一步：若点(i0,j0)的颜色值与新颜色值newcolor相同，则 1 ；
第二步：点(i0,j0)的颜色值→oldcolor；创建栈S，并将点坐标(i0,j0)入栈；
第三步：若 2 ，则转第七步；
第四步：栈顶元素出栈→(x,y)，并 3 ；
第五步：
1) 若点(x,y-1)在图像中且G[x,y-1]等于oldcolor,则(x,y-1)入栈S；
2) 若点(x,y+1)在图像中且G[x,y+1]等于oldcolor,则(x,y+1)入栈S；
3) 若点(x-1,y)在图像中且G[x-1,y]等于oldcolor,则(x-1,y)入栈S；
4) 若点(x+1,y)在图像中且G[x+1,y)等于oldcolor,则(x+1,y)入栈S：
第六步：转 4 ；
第七步：算法结束。

[问题]
是否可以将算法中的栈换成队列?回答： 5 。

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

[说明]
下面的程序按照以下规则输出给定名词的复数形式：
a．若名词以“y”结尾，则删除y并添加“ies”；
b．若名词以“s”、“ch”或“sh”结尾，则添加“es”；
c．其他所有情况，直接添加“s”。

[C语言程序]
# include ＜stdio.h＞
# include ＜string.h＞
char *plural (char *word)
{
int n;
char *pstr;
n=strlen(word); /*求给定单词的长度*/
pstr=(char *) malloc(n+3); /*申请给定单词的复数形式存储空间*/
if (!pstr||n＜2)
return NULL;
strcpy (pstr,word);/*复制给定单词*/
if( 6 )
{
pstr[n-1] = 'i-'; pstr[n]='e'; pstr[n+1]='s'; 7 ;
}
else if(pstr[n-1]=='s' ||pstr[n-1]=='h' && ( 8 )
{
pstr[n]='e'; pstr[n+1]='s'; pstr[n+2]='＼0';
}
else
{pstr[n]='s'; pstr[n+1]='＼0';}
9 ；
}
main 11
{
int i; char *ps;
char wc[9][10]={"chair", "dairy", "boss", "circus", "fly", "dog", "church", "clue", "dish");
for(i=0; i＜9; i++) {
ps= 10 ；
printf("%s: %s＼n",wc[i],ps); /*输出单词及其复数形式*/
free (ps);/*释放空间*/
}
system ("pause");
}
试题三
阅读以下说明和C函数，将应填入(n) 处的字句写在对应栏内。

[说明]
若一个矩阵中的非零元素数目很少且分布没有规律，则称之为稀疏矩阵。

对m行n列的稀疏矩阵M，进行转置运算后得到n行m列的矩阵MT，如图3-1所示
为了压缩稀疏矩阵的存储空间，用三元组(即元素所在的行号、列号和元素值、表示稀疏矩阵中的一个非零元素，再用一维数组逐行存储稀疏矩阵中的所有非零元素也称为三元组顺序表)。

例如，图3-1所示的矩阵M相应的三元组顺序表如表3-1所示。

其转置矩阵MT 的三元组顺序表如表3-2所示。

函数TransposeMatrix(Matrix M)的功能是对用三元组顺序表表示的稀疏矩阵M进行转置运算。

对M实施转置运算时，为了将M中的每个非零元素直接存入其转置矩阵MT三元组顺序表的相应位置，需先计算M中每一列非零元素的数目(即MT中每一行非零元素的数目)，并记录在向量num中；然后根据以下关系，计算出矩阵M中每列的第一个非零元素在转置矩阵MT三元组顺序表中的位置：
cpot[0]=0
cpot[j]=cpot[j-1]+num[j-1]) /*j为列号*/
类型ElemType，Triple和Matrix定义如下：
typedef int ElemType;
typedef struct{ /*三元组类型*/
int r,c; /*矩阵元素的行号、列号*/
ElemType e; /*矩阵元素的值*/
}Triple;
typedef struct{ /*矩阵的元组三元组顺序表存储结构*/
int rows,cols,elements; /*矩阵的行数、列数和非零元素数目*/
Triple data[MAXSIZE.;
}Matrix;
[C语言函数]
int TransposeMatrix(Matrix M)
{
int j,q,t;
Matrix MT; /*MT是M的转置矩阵*/
num=(int*)malloc(M.cols*sizeof(int));
cpot=(int*)malloc(M.cols*sizeof(int));
if(!num ||cpot)
return ERROR;
MT.rows= 11 ; /*设置转置矩阵MT行数、列数和非零元素数目*/
MT.cols= 12 ;
MT.elements=M.elements;
if(M.elements＞0){
for (q=0 ; q＜M. cols ; q++)
num[q]=0;
for (t=0; t＜M.elements;++t) /*计算矩阵M中每一列非零元素数目*/ num [M.data[t].c]++;
/*计算矩阵M中每列第一个非零元素在其转置矩阵三元组顺序表中的位置*/
13 ;
for(j=1;j＜M.cols;j++)
cpot[j]= 14 ;
/*以下代码完成转置矩阵MT三元组顺序表元素的设置*/
for(t=0;t＜M.elements;t++){
j= 15 ; /*取矩阵M的一个非零元素的列号存入j*/
/*q为该非零元素在转置矩阵MT三元组顺序表中的位置(下标)*/
MT.data[q].r=M.data[t].c;
MT.data[q].c=M.data[t].r;
MT.data[q].e=M.data[t].e;
++cpot[j]; /*计算M中第j列的下一个非零元素的目的位置*/
}/*for*/
} /*if*/
free(num); free(cpot);
/*此处输出矩阵元素，代码省略*/
return OK;
}/*TransposeMatrix*/
试题四
阅读以下说明和C语言函数，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
假设一个剧场有N*N个座位，顾客买票时可以提出任意有效的座号请求。

下面用二维数组a[N][N]模拟剧场中的座位，a[i][j]等于0表示第i排第j列(0≤i,j≤N-1)的票尚未售出。

函数int Find(inta[][N],int R,int *row, int *col)的功能是：在部分票已售出的情况下，找出剧场中的R*R个空座位，要求这些座位的排列形成一个正方形。

若找到满足要求的一个座位排列，则函数返回1，并算出该正方形左上角的行、列号；若未找到，则返回0。

例如，一个7×7个座位的剧场如下图(a)所示，已售出部分座位的剧场如下图(b)所示，图中阴影部分表示已售出的座位，从图(b)中找出的3×3正方形空座位如图(c)中斜线区所示。

[C语言函数]
int Find(int a[][N],int R,int *row,int *col)
{
int i,j,k,c,t; int FOUND=0;
for(i=0; !FOUND && i＜N-R+1;i++) { /*从第0排开始查找*/
16 ;
while(j＜N-R+1 &&!FOUND. {
for(k=0; 17 && a[i][j+k]==0; k++); /*查找第i排连续的R个座位*/
if(k＞=R) { /*找到第i排连续的R个空座位*/
for(c=0;c＜R;c++) { /*查找其余的R*(R-1)个座位*/
for(t=1;t＜R;t++)
if(a[ 18 ][j+c]!=0)break;
if(t＜R)break;
}/*for*/
if( 19 )FOUND=1;
} /*if*/
20 ;
} /*while*/
} /*for i*/
if(FOUND.{
*row=i-1; *col=j-1; /*计算正方形区域的左上角坐标*/
return 1;
}
return 0;
}
试题五
阅读以下说明和C函数，将应填入(n) 处的字句写在答题纸的对应栏内。

[说明]
某班级有N名学生，他们可根据自己的情况选修名称和数量不尽相同的课程。

设N等于6，学生信息、所选课程及成绩用链表结构存储，如图5-1所示。

程序中相应的类型定义如下：
#define N 6
struct node{
char cname[5]; /*课程名*/
int grade; /*成绩*/
struct node *next; /*指针，指示某学生选修的下一门课程及成绩*/ };
struct student{
char xh[5]; /*学号*/
char name[20]; /*姓名*/
struct node *link; /*指针，指示出选修的课程及成绩链表*/
}stud_info[n];
Stud_info[]为一个全局数组。

函数func(char kc[],int *num)的功能是统计选修了课程名为kc的学生的人数，并返回该课程的平均成绩(若无人选修该课程，则平均成绩为0)，参数num带回选修课程kc的学生人数。

[C语言函数]
double func(char kc[], int *num)
{
int i, count=0, sum=0; /*count用于记录选修课程名为kc的学生的人数*/
double avg=0.0;
struct node *p;
for(i=0; i＜N; i++){
p= 21 ; /*取第土个学生所修课程链表的头指针*/
while (p){
if( 22 ){
sum= 23 ;
count++;
break;;
} /* if*/
p=p-＞next;
} /*while*/
}
24 ;
if( 25 )
avg=(double) sum /count; /*计算平均成绩*/
return avg;
} /*func*/
从下列的2道试题(试题六至试题七)中任选1道解答。

如果解答的试题数超过1道，则题号小的1道解答有效。

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

[说明]
在下面的C++代码中，类SalesTicket能够完成打印票据正文的功能，类HeadDecorator
与FootDecorator分别完成打印票据的抬头和脚注的功能。

已知该程序运行后的输出结果如下所示，请填补该程序代码中的空缺。

这是票据的抬头!
这是票据正文!
这是票据的脚注!
--------------------------------------
这是票据的抬头!
这是票据的脚注!
[C++程序代码]
#include＜iostream＞
using namespace std;
class SalesTicket{
public;
26 printTicket31{cout＜＜"这是票据正文!"＜＜endl;}
};
class Decorator：public SalesTicket{
SalesTicket *ticket;
public：
Decorator (SalesTicke *t){ticket=t;}
void printTicket 31{
if (ticket!=NULL)
ticket-＞printTicket31 ;
}
};
class HeadDecorator:public Decorator{ public:
HeadDecorator(SalesTicket *t): 27 {}
void printTicket31{
cout＜＜"这是票据的抬头!" ＜＜endl;
Decorator::printTicket31;
}
};
class FootDecorator:public Decorator{ public:
FootDecorator(SalesTicket *t): 28 {}
void printTicket31{
Decorator::printTicket31;
cout＜＜"这是票据的脚注!"＜＜endl;
}
};
void main (void){
SalesTicket t;
FootDecorator f(&t);
HeadDecorator h( 29 );
h.printTicket31;
cout＜＜"---------------------"＜＜endl;
FootDecorator a(NULL);
HeadDecorator b( 30 );
b.printTicket31;
}
试题七
阅读以下说明和Java程序代码，将应填入(n)处的字句写在答题纸的对应栏内。

[说明]
在下面的Java程序代码中，类SalesTicket能够完成打印票据正文的功能，类HeadDecorator与FootDecorator分别完成打印票据的抬头和脚注的功能。

己知该程序运行后的输出结果如下所示，请填补该程序代码中的空缺。

这是票据的抬头!
这是票据正文!
这是票据的脚注!
---------------------------------------
这是票据的抬头!
这是票据的脚注!
[Java程序代码]
public class SalesTicket{
public void printTicket36{
System.out.println("这是票据正文!");
}
}
public class Decorator extends SalesTicket{ SalesTicket ticket;
public Decorator(SalesTicket t){
ticket =t；
}
public void printTicket36{
if(ticket!=null)
ticket. printTicket36;
}
}
public class HeadDecorator extends Decorator{ public HeadDecorator(SalesTicket t){
31 ;
}
public void printTicket36{
System.out.rintln("这是票据的抬头!");
Super.printTicket36;
}
}
public class FootDecorator extends Decorator{
public FootDecorator(SalesTicket t){
32 ;
}
public void printTicket36{
super.printTicket36;
System.out.println("这是票据的脚注!");
}
}
public class Main{
public static void main(String[] args){
Decorator T=
new HeadDecorator( 33 );
T. 34 ;
System.out.println("-----------------------------------------");
T=new FootDecorator( 35 );
T.printTicket36;
}
}
答案:
试题一
1、转第七步
2、栈为空
3、newcolor→G[x,y]
4、转第三步
5、可以
试题二
6、pstr[n-1]=='y'
7、pstr[n+2]='\0'
8、pstr[n-2]＝'c'||pstr[n-2]=='s'
9、return pstr 10、plufal(wc[i])
试题三
11、M.cols 12、M.rows 13、cpot[0]=0 14、cpot[j-1]+num[j-1] 15、M.data[t].c
试题四
16、j=0 17、k＜R 18、i+t 19、c＞=R 20、j++或j+=1 试题五
21、stud_info[i].link 22、!strcmp(p-＞cname,kc) 23、sum+p-＞grade 24、*num=count 25、count!=0
试题六
26、virtual void 27、Decorator(t) 28、Decorator(t) 29、&f 30、&a
试题七
31、super(t) 32、super(t) 33、newFootDecoratro(new SalesTicke())
34、print Ticket() 35、new HeadDecorator(null)
初级程序员下午试题模拟39
试题一
1、阅读以下说明和流程图回答问题，将解答填入对应栏。

[说明]
“直接插入法”排序是一种N2运算量的例程，只能用在N较小的时候，其方法是：挑出第二个数将它按与第一个数大小的顺序插入，然后挑出第三个数将它按大小顺序插入到前两个数中，如此下去，一直到最后一个也插入。

注：流程中循环开始的说明按照“循环变量：循环初值，循环终值，增量”格式描述。

[问题]
将流程图的(1)～(5)处补充完整。

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

[说明1]
函数int factors(int n)的功能是判断整数n(n＞=2)是否为完全数。

如果n是完全数，则
函数返回0，否则返回-1。

所谓“完全数”是指整数n的所有因子(不包括n)之和等于n自身。

例如：28的因子为1，2，4，7，14，而28=1+2+4+7+14，因此28是“完全数”。

[C函数1]
int factors(int n)
{ int i，S;
for(i=l，s=0;i＜=n/2;i++)
if(n%i==O) (1) ;
if( (2) )return 0；
rerurn -1;
}
[说明2]
函数int maxint(int a[],int k)的功能是用递归方法求指定数组中前k个元素的最大值，并作为函数值返回。

[C函数2]
int maxint(int a[],int k)
{ int t;
if( (3) )return (4) ;
t=maxint(a+1, (5) )j
return(a[0]>t) ? a[0] ：t;
}
试题三
3、阅读以下函数说明和C语言函数，将应填入(n) 处的字句写在对应栏内。

[说明]
该程序从正文文件test.txt中读入一批整数，并将它们按照递增的顺序存放在一个链表中。

其中，函数struct Link*insertChain(struct Link*head,structLink*k)用来寻找结点k在链表head中的插入位置，并插入该结点。

[C程序]
#include ＜stdio.h＞
#include ＜stdlib.h＞
struct Link
{ int number;
struct Link *next;
}
struct Link *insertChain(struct Link *head,struct Link *k);
VOid main()
{ struct Link *ptr, *head;
FILE *fd;
int hum;
if((fd=fopen("test.txt","r"))==NULL)
{print("Cannot open this file!\n");
return;
}
head=NULL；
while(fscanf(fd，"%d",hum)==1)
{ ptr= (1) ;
if(!ptr) return;
ptr-＞number=hum;
ptr-＞next=NULL;
head=insertChain(head，ptr);
}
(2) ;
return;
}
struct Link *insertChain(struct Link *head,struct Link *k)
{ struct Link *ptr,*u;
ptr=head;
while(ptr ＆＆k ＆＆k-＞number＞ptr-＞number) { u=ptr; (3) }
if(ptr == head) head=k;
else (4) ;
(5) ;
return head;
}
试题四
4、阅读以下函数说明和C语言函数，将应填入(n) 处的字句写在对应栏内。

[说明]
这是一个模拟渡口管理的算法。

某汽车轮渡口，过江渡船每次能载10辆车过江。

过江车辆分为客车类和火车类，上船有如下规定：同类车先到先上船，客车先于货车上渡船，且每上4辆客车，才允许上一辆货车；若等待客车不足4辆，则以货车代替，若无货车等待则允许客车都上船。

程序中用到的函数有enqueue(queue*sq，elemtype*x)在队列sq中入队一个元素x；outqueue(queue*sq，elemtype*x)在队列sq中出队一个元素，并将其值赋给x；empty(queue*sq)判断队列sq是否为空队，若为空，返回1；否则返回0。

[C程序]
#include＜stdio.h＞
void pass(){
queue bus,truct; /*bus表示客车队列，truck表示货车队列*/
char ch;
int n,tag；/* ]n为车号，tag为标志，tag=0表示客车，tag=1表示货车*/
intcount=0，countbus=0，counttruck=0; /*分别表示上渡船汽车数、客车数、货车数*/
while(1){
printf("输入命令: \n");
Scanf("%c"，&ch);
switch(ch){
case'e':
case'E': printf("车号: \n");
Scanf("%d"，&n);
printf("客车\货车(0\1): \n");
scanf("%d"，&tag);
if( (1) )
enqueue(&bus,n);
else
enqueue(&truck,n);
break;
case'i':
case'I': while(count＜10){
if( (2) && empty(&bus)==0){ /*客车出队*/ outqueue(&bus,&n);
printf("上船的车号为: \n");
count++;
(3) ;
}
eise if( (4) ){ /*货车出队*/
countbus=0;
outqueue(&truck,&n);
printf("上船的车号为: \n");
count++;
counttruck++;
}
else if(empty(&bus)==0){
(5) ;
outqueue(&truck,&n);
printf("没有10辆车排队轮渡\n");
count++;
countbus++;
}
else{
printf("没有10辆车排队轮渡\n");
retUrn;
}
break;
}
case'q':
case'Q':break;
}
if(ch=='q' || ch=='Q')
break;
}
}
试题五
5、阅读以下说明和C++程序，将应填入(n) 处的字句写在对应栏内。

[说明]
下面程序输出一个矩形面积，以及矩形区域上的假想的作物产量。

[C++程序]
#include ＜iostream.h＞
class crop_assessment
{
int actual_crop;
int ideal_crop;
public:
void set(int in_actual,int in_ideal)
{
actual crop=in_actual;
ideal_crop=in_ideal;
}
int get_actual_crop(void){ (1) ;}
int get_ideal_crop(void){ (2) ;) };
Class lot_size
{
int length;
int width;
(3) crop;
public:
void set(int 1,int w,int a,int i)
{
length=1;
width=w;
crop.set(a,i);
}
int get_area(void){return length*width;} int get_data(void){return (4) ;}
int get_data2(void)freturn (5) ;}
}
int main()
{
Los_size small，medium;
small.set(5,5,5,25);
medium.set(10,10,10,50);
cout＜＜"For a small lot of area"＜＜smallget_area()＜＜“\n”;
cout＜＜"the actual crops are$"＜＜small.get_data2()＜＜"\n";
cout＜＜"and ideal crops are$”＜＜small.get_data()＜＜"\n";
cout＜＜"For a medium Lot of area"＜＜medium.get area()＜＜:\n”;
cout＜＜"the actual crops are$"＜＜medium.get_data2()＜＜"\n";
cout＜＜"and ideal crops are$"＜＜medium.get_data()＜＜"\n";
return 0;
}
试题六
6、阅读以下说明和Java程序，将应填入(n) 处的字句写在对应栏内。

[说明]
下面程序输出一个矩形面积，以及矩形区域上的假想的作物产量。

[Java程序]
public class MainJava {
public static void main(String[] args){
Lot_size small=new Lot_size();
Lot_size medium=new Lot_size();
small.set(5,5,5，25);
medium.set(10,10,10,50);
System.out.println("For a small lot of area"
+small.get_area()+"\n");
System.out.println("the actual crops are $"
+small.get_data2()+"\n");
System.out.println("and ideal crops are $"
+small.get data()+"\n");
System.out.println("For a medium lot of area"
+medium.get_area()+“\n”)；
System.out.println("the actual crops are $"
+medium.get_data2()+"\n");
System.out.println ("and ideal crops are $"
+medium.get_data()+"\n");
}
}
class Crop_assessment{
private int actual_crop;
private int ideal_crop;
public void set(int in_actual,int in ideal){
actual_crop=in_actual;
ideal_crop=in_ideal;
}
public int get_actual_crop(){return (1) ;}
public int get_ideal_crop()(return (2) ;} }
class Lot_size{
private int length;
private int width;
private Crop_assessment crop= (3) ;
public void set(int 1,int W,int a,int i){
length=1;
width=W;
crop.set(a,i);
}
public int get_area(){return length*width;}
public int get_data()freturn (4) ;}
public int get_data2()(return (5) ;}
}
答案:
试题一
1、1，n-1，1；(2) a[j]；(3) a[j]＜a[i]；(4) a[i+1]=a[i]；(5) a[i+1]=a；[解析]
本题目考查流程图。

题目中已经给出了直接插入法排序的算法，由于该算法是从数组中第二个数起，取出并与前面的数进行排序，直到数组中最后一个数排序完成，所以，循环变量初值为1，终值为N-1，增量为1，按照题目中要求的格式，则为“1，N-1，1”。

由题目中的算法可知，我们要将取出来的数同排在其前面的数做比较，并插入，所以，首先要把取出来的数赋给一个变量，即(2)填入“a[j]”。

然后从第j-1个数开始，如果a[i]＞a[j]，那么我们就将a[i]N移一位，以便空出一个位置来插入a[j]，所以(4)填入“a[i+1]=a[i]”这样一直进行到a[i]＜a[j]或者i＜0，这时，我们就找到了a[j]要插入的位置，可以将a[j]插入，即(3)填入“a[j]＜a[i]”，(5)填入“a[i+1]=a”。

试题二
2、s+=i (2) n==s (3) k-1或k-1==0 (4) a[0]或*a或a[k-1]
(5) k-1或--k
[解析]
对于函数1，是判断整数n(n＞=2)是否为完全数。

首先用for循环求该整数的所有因子之和，所以(1)填“s+=i”若其和等于整数本身，则为完全数，返回值为0，则(2)填“n==s”；否则返回值为-1。

对于函数2，是用递归方法找出数组中的最大元素。

该递归的出口条件为k=1，即(3)
填“k==1”或“k-1==0”：只有一个数时，它本身就是最大的，(4)填“a[0]”或“*a”或“a[k-1]”；对于多个数的情况，在剩下的k-1个元素中找到最大的，并与首元素值比较，返回最大的一个，所以(5)填“k-1”或“--k”。

试题三
3、(struct Link*)malloc(sizeof (struct Link)) (2) fclose(fd)
(3) ptr=ptr-＞next或ptr=u-＞next
(4) u-＞next=k (5) k-＞next=ptr
[解析]
本题采用文件的输入方式，其主要思路：①打开文件；②从文件读入一个整数，动态申请一个结点；③将结点插入到以head为头指针的链表中；④反复执行②和③直到文件结束；⑤关闭文件。

通过上述分析，不难得到(1)为申请结点，应该填“(struct Link*)malloc(sizeof(structLink))”；(2)为关闭文件，即fclose(fd)。

在插入结点时，让u指向插入结点ptr之前，因此(3)为u的下一个结点，填“ptr=ptr-＞next”或“ptr=u-＞next”。

插入结点时分为在头结点插入和u之后插入两种情况。

(4)为在u之后插入的情况，应该填“u-＞next=k”，(5)填“k-＞next=ptr”。

试题四
4、tag==O (2) count＜4 (3) countbus++ (4)empty(&truck)==0 (5) counttruck=0 [解析]
命令E(e)表示有汽车来等船渡江，按客车、货车分类进入相应的队列排队。

所以空(1)
填“tag==0”，表示客车来渡船。

命令I(i)表示渡船到渡口，在count小于10时环形：①若count＜4，客车队列又非空，将客车队列的队头汽车出队上渡船。

count和countbus增1；否则转②。

所以空(2)填“count＜4”，空(3)填“countbus++”。

②若count＞=4，或客车队列为空队且货车队列非空，将货车队列的队头汽车出队上渡船。

count和counttruck增1，否则转③。

即空(4)填“empty(&tmck)==0”。

③若货车队列为空队且客车队非空，将客车队列的队头汽车出队上渡船。

count和countbus增1，否则转④。

因此(5)填“counttruck=0”。

④提示相应错误信息并退出程序运行。

试题五
5、return actual_crop (2) return ideal_crop (3) Crop_assessment
(4) crop．get_ideal_crop() (5) crop.get_actual_crop()
[解析]
本题以C++语言为载体，考查面向对象程序设计中的几个重要概念—类的嵌套及函数的使用。

本题的功能是通过已定义的粮食收成类定义了一个计算特定矩形域上粮食收成的类，在主函数中定义了两个对象，并调用了相应的函数，来输出理想和实际的粮食产量。

首先，由于Crop_assessment定义的成员数据缺省为私有的，所以想要获得实际和理想的粮食产量，要通过两个公有成员函数，所以(1)处应填入“return actual_crop”，(2)处应填入“return ideal_crop”。

其次，在类Lot_size中，由于我们要反映矩形域上的粮食产量，所以我们在类中嵌套定义了一个类，(3)应填入“Crop_assessment”。

最后，由于我们想通过Lot_size类中的getdata和get_data2函数得到粮食产量，但
由于这两个成员数据是私有函数，所以我们必须通过定义的对象调用它，所以(4)应填入“crop.get ideal_crop()”，(5)应填入“crop.get actual_crop()”。

试题六
6、return actual_crop (2) return ideal_crop (3) new Crop_assessment()
(4) crop.get_ideal_crop (5) crop.get_actual_crop()
本题以Java语言为载体，考查面向对象程序设计中的几个重要概念—类的嵌套及函数的使用。

本题的功能是通过已定义的粮食收成类定义了一个计算特定矩形域上粮食收成的类，在主函数中定义了两个对象，并调用了相应的函数，来输出理想和实际的粮食产量。

首先，由于Crop assessment定义的成员数据缺省为私有的，所以想要获得实际和理想的粮食产量，要通过两个公有成员函数，所以(1)处应填入“return actual_crop”，(2)处应填入“return ideal_crop”。

其次，在类Lot size中，由于我们要反映矩形域上的粮食产量，所以我们在类中嵌套定义了一个类，Java中对象需要实例化，故(3)应填入“new Crop_assessment()”。

最后，由于我们想通过Lot_size类中的get_data和get_data2函数得到粮食产量，但由于这两个成员数据是私有函数，所以我们必须通过定义的对象调用它，所以(4)应填入“crop.get_ideal_crop()”，(5)应填入“crop.get_actual_crop()”。

初级程序员下午试题模拟40。