上半年初级程序员考试真题下午考卷及详解.docx
《上半年初级程序员考试真题下午考卷及详解.docx》由会员分享，可在线阅读，更多相关《上半年初级程序员考试真题下午考卷及详解.docx（17页珍藏版）》请在冰豆网上搜索。
上半年初级程序员考试真题下午考卷及详解
2015下半年初级程序员考试真题
（下午考卷）
（总分90,考试时间90分钟）
1.阅读以下说明和流程图，填补流程图中的空缺，将解答填入答题纸的对应栏内。
[说明]
下面流程图的功能是：
在给定的一个整数序列中查找最长的连续递增子序列。
设序列存放在数组A[1:
n]（n≥2）中，要求寻找最长递增子序列A[K:
K+L-1]（即A[K]＜A[K+1]＜…＜A[K+L-1]）。
流程图中，用Kj和Lj分别表示动态子序列的起始下标和长度，最后输出最长递增子序列的起始下标K和长度L。
例如，对于序列A={1，2，4，4，5，6，8，9，4，5，8}，将输出K=4，L=5。
[流程图]
注：
循环开始框内应给出循环控制变量的初值和终值，默认递增值为1，格式为：
循环控制变量=初值，终值
该问题分值:
15
n-1
Lj+1→Lj
Lj＞L
Kj
i+1[解析]本题考查程序员在设计算法，理解并绘制程序流程图方面的能力。
本题的目标是：
在给定的一个整数序列中查找最长的连续递增子序列。
查找的方法是：
对序列中的数，从头开始逐个与后面邻接的数进行比较。
若发现后面的数大于前面的数，则就是连续递增的情况；若发现后面的数并不大，则以前查看的数中，要么没有连续递增的情况，要么连续递增的情况已经结束，需要再开始新的查找。
为了记录多次可能出现的连续递增情况，需要动态记录各次出现的递增子序列的起始位置（数组下标K1）和长度（Lj）。
为了求出最大长度的递增子序列，就需要设置变量L和K，保存迄今为止最大的Lj及其相应的Kj。
正如打擂台一样，初始时设置擂主L=1，以后当Li＞L时，就将Lj放到L中，作为新的擂主。
擂台上始终是迄今为止的连续递增序列的最大长度。
而Kj则随Lj→L而保存到K中。
由于流程图中最关键的步骤是比较A[i]与A[i+1]，因此对i的循环应从1到n-1，而不是1到n。
最后一次比较应是“A[n-1]＜A[n]?
”。
因此
（1）处应填n-1。
当A[i]＜A[i+1]成立时，这是递增的情况。
此时应将动态连续递增序列的长度增1，因此
（2）处应填写Li+1→Lj。
当A[i]＜A[i+1]不成立时，表示以前可能存在的连续递增已经结束。
此时的动态长度Li应与擂台上的长度L进行比较。
即（3）处应填Lj＞L。
当Lj＞L时，则Lj将做新的擂主（Lj→L），同时执行Kj→K。
所以（4）处应填Kj。
当Lj→L不成立时，L不变，接着要从新的下标i+1处开始再重新查找连续递增子序列。
因此（5）处应填i+1。
长度Lj也要回到初始状态1。
循环结束时，可能还存在最后一个动态连续子序列（从下标Kj那里开始有长度Lj的子序列）没有得到处理。
因此还需要再打一次擂台，看是否超过了以前的擂主长度。
一旦超过，还应将其作为擂主，作为查找的结果。
试题二
1.阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
下面的代码运行时，从键盘输入一个四位数（各位数字互不相同，可以有0），取出组成该四位数的每一位数，重组成由这四个数字构成的最大四位数max4和最小四位数min4（有0时为三位数），计算max4与min4的差值，得到一个新的四位数。
若该数不等于6174，则重复以上过程，直到得到6174为止。
例如，输入1234，则首先由4321-1234，得到3087；然后由8730-378，得到8352；最后由8532-2358，得到6174。
[C代码]
#include＜stdio.h＞
intdifference（inta[]）
（intt,i,j,max4,min4;
for（i=0;i＜3;i++）{/*用简单选择排序法将a[0]～a[3]按照从大到小的顺序排列*/
t=i;
for（j=i+1;______;j++）
if（a[j]＞a[t]）______;
if（t!
=i）{
inttemp=a[t];a[t]=a[i];a[i]=temp;
}
}
max4=______;
min4=______;
returnmax4-min4;
}
intmain（）
{intn,a[4];
printf（"inputapositivefour-digitnumber:
"）;
scanf（"%d",&n）;
while（n!
=6174）{
a[0]=______;/*取n的千位数字*/
a[1]=n/100%10;/*取n的百位数字*/
a[2]=n/10%10;/*取n的十位数字*/
a[3]=______;//取n的个位数字*/
n=difference（a）;
}
return0;
}
该问题分值:
15
j＜4或等价形式
t=j
a[0]*1000+a[1]*100+a[2]*10+a[3]或等价形式
a[3]*1000+a[2]*100+a[1]*10+a[0]或等价形式
n/1000或等价形式
n%10[解析]本题考查C程序设计基本技能及应用。
题目要求在阅读理解代码说明的前提下完善代码。
由于C程序的执行是从main函数开始的，因此首先理解main函数的代码结构。
显然，调用函数difference时实参为数组a，并且从注释中可以确定空（5）的内容为“n/1000”或其等价形式，空（6）处填写“n%10”或其等价形式。
这样，数组元素a[0]～a[3]就依次保存了n值从左至右的各位数字。
接下来分析函数difference的代码结构。
双重for循环是对数组a进行简单选择排序，目的是将数组中最大数字放入a[0]，最小的数字放入a[3]。
处理思路是通过比较找出最大数字并用t记下最大数字所在数组元素的下标，第一趟需在a[0]～a[3]中进行选择，通过比较记下最大数字的下标，最后将最大数字交换至a[0]，第二趟需在a[1]～a[3]中进行选择，通过比较记下这三个数中最大者的下标，并最大者交换至a[1]，依次类推。
因此，空
（1）处应填入“j＜4”或其等价形式，以限定选择范围，空
（2）处应填入“t=j”，以记下选择范围内最大者的下标。
根据题目的说明部分，显然空（3）处应填入“a[0]*1000+a[1]*100+a[2]*10+a[3]”、空（4）处应填入“a[3]*1000+a[2]*100+a[1]*10+a[0]”，或其等价形式。
试题三
1.阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
对一个整数序列进行快速排序的方法是：
在待排序的整数序列中取第一个数作为基准值，然后根据基准值进行划分，从而将待排序列划分为不大于基准值者（称为左子序列）和大于基准值者（称为右子序列），然后再对左子序列和右子序列分别进行快速排序，最终得到非递减的有序序列。
函数quicksort（inta[],intn）实现了快速排序，其中，n个整数构成的待排序列保存在数组元素a[0]～a[n-1]中。
[C代码]
#include＜stdio.h＞
voidquicksort（inta[],intn）
{
inti,j;
intpivot=a[0];//设置基准值
i=0;j=n-1;
while（i＜j）{
while（i＜1&&______）j--;//大于基准值者保持在原位置
if（i＜j）{a[i]=a[j];i++;}
while（i＜j&&______）i++;//不大于基准值者保持在原位置
if（i＜1）{a[j]=a[i];1--;}
}
a[i]=pivot;//基准元素归位
if（i＞1）
______;//递归地对左孔序列进行快速排序
if（n-i-1＞1）
______;//递归地对右孔序列进行快速排序
}
intmain（）
{
inti,arr[]={23,56,9,75,18,42,11,67};
quicksort（______）;//调用quicksort对数组arr[]进行排序
for（i=0;i＜sizeof（arr）/sizeof（int）;i++）
printf（"%d\t",arr[i]）;
return0;
}
该问题分值:
15
a[j]＞pivot或a[j]＞=pivot或等价形式
a[i]＜=pivot或a[i]＜pivot或等价形式
quicksort（a,i）或quicksort（a,j）或等价形式
quicksort（a+i+1,n-i-1）或quicksort（a+j+1，n-j-1）或等价形式
注：
a+i+1可表示为&a[i+1]，a+j+1可表示为&a[j+1]
arr,sizeof（arr）/sizeof（int）
注：
sizeof（arr）/sizeof（int）可替换为8[解析]本题考查C程序设计基本技能及快速排序算法的实现。
题目要求在阅读理解代码说明的前提下完善代码，该题目中的主要考查点为运算逻辑和函数调用的参数处理。
程序中实现快速排序的函数为quicksort，根据该函数定义的首部，第一个参数为数组参数，其实质是指针，调用时应给出数组名或数组中某个元素的地址；第二个参数为整型参数，作用为说明数组中待排序列（或子序列）的长度。
快速排序主要通过划分来实现排序。
根据说明，先设置待排序列（或子序列，存储在数组中）的第一个元素值为基准值。
划分时首先从后往前扫描，即在序列后端找出比基准值小或相等的元素后将其移到前端，再从前往后扫描，即在序列前端找出比基准值大的元素后将其移动到后端，直到找出基准值在序列中的最终排序位置。
再结合注释，空
（1）处应填入“a[j]＞pivot”，使得比基准值大者保持在序列后端。
空
（2）处应填入“a[i]＜=pivot”，使得不大于基准值者保持在前端。
在完成1次划分后，基准元素被放入a[i]，那么分出来的左子序列由a[0]～a[i-1]这i个元素构成，右子序列由a[i+1]～a[n-1]构成，接下来应递归地对左、右子序列进行快排。
因此，结合注释，空（3）应填入“quicksort（a,i）”或其等价形式，以对左子序列的i个元素进行快排，也可以用&a[0]代替其中的a，它们是等价的，a与&a[0]都表示数组的起始地址。
空（4）所在代码实现对右子序列进行快排。
右子序列由a[i+1]～a[n-1]构成，其元素个数为n-1-（i+1）+1，即n-i-1，显然元素a[i+1]的地址为&a[i+1]或a+i+1，所以空（4）应填入“quicksort（a+i+1,n-i-1）”或其等价形式。
在main函数中，空（5）所在代码首次调用函数quicksort对main函数中的数组arr进行快排，因此应填入“arr,sizeof（arr）/sizeof（int）”或其等价形式。
试题四
1.阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
函数GetListElemPtr（LinkListL，inti）的功能是查找含头结点单链表的第i个元素。
若找到，则返回指向该结点的指针，否则返回空指针。
函数DelListElem（LinkListL,inti,ElemType*e）的功能是删除含头结点单链表的第i个元素结点，若成功则返回SUCCESS，并由参数e带回被删除元素的值，否则返回ERROR。
例如，某含头结点单链表L如下图（a）所示，删除第3个元素结点后的单链表如下图（b）所示。
#defineSUCCESS0
#defineERROR-1
typedefintStatus;
typedefintElemType;
链表的结点类型定义如下：
typedefstructNode{
ElemTypedata;
structNode*next;
}Node,*LinkList;
[C代码]
LinkListGetListElemPtr（LinkListL,inti）
{/*L是含头结点的单链表的头指针,在该单链表中查找第i个元素结点;
若找到,则返回该元素结点的指针,否则返回NULL
*/
LinkListp;
intk;/*用于元素结点计数*/
if（i＜1||!
L||!
L-＞next）returnNULL;
k=1;p=L-＞next;/*令p指向第1个元素所在结点*/
while（p&&______）{/*查找第i个元素所在结点*/
______;++k;
}
returnp;
}
StatusDelListElem（LinkListL,inti,ElemType*e）
{/*在含头结点的单链表L中,删除第i个元素,并由e带回其值*/
LinkListp,q;
/*令P指向第i个元素的前驱结点*/
if（i==1）
______;
else
p=GetListElemPtr（L,i-1）;
if（!
P||!
p-＞next）returnERROR;/*不存在第i个元素*/
q=______;/*令q指向待删除的结点*/
p-＞next=q-＞next;//从链表中删除结点*/
______;/*通过参数e带回被删除结点的数据*/
free（q）;
returnSUCCESS;
}
该问题分值:
15
k＜i
p=p-＞next
p=L
p-＞next
*e=q-＞data[解析]本题考查C语言的指针应用和运算逻辑。
本问题的图和代码中的注释可提供完成操作的主要信息，在充分理解链表概念的基础上填充空缺的代码。
函数GetListElemPtr（LinkListL，inti）的功能是在L为头指针的链表中查找第i个元素，若找到，则返回指向该结点的指针，否则返回空指针。
描述查找过程的代码如下，其中k用于对元素结点进行计数。
k=1;p=L-＞next;/*令p指向第1个元素所在结点*/
while（p&&______）{/*查找第i个元素所在结点*/
______;++k;
}
上述代码执行时，k的初始值为1，同时p指向第一个元素结点。
当找到第i个元素结点时，k应等于i，尚未到达第i个结点时，k小于i。
因此，空
（1）处应填入“k＜i”或其等价形式，使得没有达到第i个结点时继续查找。
空
（2）处应填入“p=p-＞next”，从而使得指针p沿着链表中的结点向第i个结点移动。
函数DelListElem（LinkListL,inti,ElemType*e）的功能是删除含头结点单链表的第i个元素结点，若成功则返回SUCCESS，并由参数e带回被删除元素的值，否则返回ERROR。
根据注释，空（3）所在语句需要指向第一个结点之前的结点（即头结点），显然此处应填入“p=L”。
空（4）所在语句令q指向待删除的结点，由于之前已经令p指向待删除结点的前驱结点，显然，此空应填入“p-＞next”。
空（5）所在语句通过参数e带回被删除结点的数据，由于此时只能通过指针q找到被删除的结点，所以应填入“*e=q-＞data”。
试题五
1.阅读以下说明和C++代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
在股票交易中，股票代理根据客户发出的股票操作指示进行股票的买卖操作。
其类图如下图所示，相应的C++代码附后。
类图
[C++代码]
#include＜iostream＞
#include＜string＞
#include＜vector＞
usingnamespacestd;
classStock{
private:
stringname;intquantity;
public:
Stock（stringname,intquantity）{this-＞name=name;this-＞quantity
=quantity;}
voidbuy（）{cout＜＜"[买进]股票名称:
"＜＜name＜＜",数量:
"＜＜quantity＜＜
endl;}
voidsell（）{cout＜＜"[卖出]股票名称:
"＜＜name＜＜",数量:
"＜＜quantity
＜＜endl;}
};
clasSorder{
public:
virtualvoidexecute（）=0;
};
classBuyStock:
______{
private:
Stock*stock;
public:
BuyStock（Stock*stock）{______=stock;}
voidexecute（）{stock-＞buy（）;}
};
//类SellStock的实现与BuyStock类似,此处略
classBroker{
private:
vector＜Order*＞orderList;
public:
voidtakeOrder（______order）（orderLiSt.pushback（order）;}
voidplaceorders（）{
for（inti=0;i＜orderList.Size（）;i++）{______-＞execute（）;}
0rderLiSt.clear（）;
}
};
classStockCommand{
public:
VOidmain（）{
Stock*aStock=newStock（"股票A",10）;
Stock*bStock=newStock（"股票B",20）;
Order*buyStockOrder=newBuyStock（aStock）;
Order*sellStockOrder=newSellStock（bStock）;
Broker*broker=newBroker（）;
broker-＞takeOrder（buyStockorder）;
broker-＞takeOrder（sellStockOrder）;
broker-＞______（）;
}
};
intmain（）{
StockCommand*stockCommand=newStockCommand（）;
StockCommand-＞main（）;
deleteStoCkCommand;
}
该问题分值:
15
publicOrder
this-＞stock或（*this）.stock
Order*
orderList[i]或*（orderList+i）
placeOrders[解析]本题考查C++语言程序设计能力，涉及类、对象、函数的定义和相关操作。
要求考生根据给出的案例和代码说明，认真阅读理清程序思路，然后完成题目。
先考查题目说明，在股票交易中，股票代理根据客户发出的股票操作指示进行股票的买卖操作。
根据说明进行设计，题目说明中给出了类图。
涉及到股票（Stock）、股票代理（Broker）、股票操作指示（StockCommand）、买卖股票（Order接口、BuyStock与SellStock类）等类以及相关操作。
Stock类定义了两个函数buy（）和sell（），分别实现买和卖的操作。
在构造函数中接收参数name和quantity，分别表示买卖股票的名称和数量，对当前所创建对象中的name和quantity赋值，用this表示区别当前对象，所以构造函数为：
Stock（Stringname,intquantity）{
thiS-＞name=name;
thiS-＞quantity=quantity;
}
Order虚类声明纯虚函数execute（）：
virtualvoidexecute（）=0；表示执行股票交易（即买和卖）的函数原型。
BuyStock继承Order，构造函数接收参数stock，实现函数execute（），进行股票买入，stock-＞buy（）。
SellStock和BuyStock类似，继承Order，构造函数接收参数stock，实现函数execute（），进行股票卖出，stock-＞sell（）。
Broker类实现接受客户的买卖指示tackOrder（），接收BuyStock或者SellStock的实例，BuyStock和SellStock均是Order的子类，所以BuyStock和SellStock的实例也是Order，因此tackOrder0所接收的参数用Order类型。
接收到买卖指示之后，存入vector＜Order*＞类型的orderList中，即orderList.push_back（order）。
placeOrders（）函数是实现将所有买卖股票的指示进行实际买入和卖出操作，即采用for循环，对每个orderList中的Stock实例，调用在BuyStock和SellStock中实现的execute（）加以执行。
for（inti=0;i＜orderList.Size（）;i++）{orderList[i]-＞execute（）;}
StockCommand主要是根据操作指示进行股票交易，实现为一个函数main（），其中创建欲进行交易的股票对象aStock和bStock，创建买aStock卖bStock股票的对象buyStockOrder和sellStockOrder对象：
Order*buyStockorder=newBuyStock（aStock）;
Order*sellStockOrder=newSellStock（bStock）;
再创建股票代理Broker类的对象broker，并接收买卖股票的指示：
broker-＞takeOrder（buyStockOrder）;
broker-＞takeOrder（sellStockOrder）;
最后将所有买卖指示用placeOrders（）下执行命令：
broker-＞placeOrders（）;
主控逻辑代码在main（）函数中实现。
在main（）函数中，先初始化StockCommand类的对象指针stockCommand，代码为：
StockCommand*stockCommand=newStockCommand（）;
即生成一个股票指示，并调用其main（）函数启动股票交易，即调用stockCommand的main（）函数，实现股票的买卖指示的创建和执行。
主控main（）函数中，使用完数组对象之后，需要用delete操作释放对象，对stockCommand对象进行删除，即
deleteStockCommand;
因此，空
（1）需要表示继承Order类的“publicOrder”；空
（2）需要表示当前对象的stock属性，填入“this-＞stock”或“（*this）.stock”；空（3）需要填入BuyStock和SellStock均能表示的父类“Order*”；空（4）需要orderList中每个对象指针调用execute（），即填入“orderList[i]”或“*（orderList+i）”；空（5）处为调用“placeOrders（）”来下达执行命令。
试题六
1.阅读以下说明和Java代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
在股票交易中，股票代理根据客户发出的股票操作指示进行股票的买卖操作。
其类图如下图所示。
相应的Java代码附后。
类图
[Java代码]
importJava.util.A
升级会员 