一、问答题
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，格式为：循环控制变量=初值，终值
参考答案：
n-1 Lj+1→Lj Lj＞L Kj i+1
2、阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
下面的代码运行时，从键盘输入一个四位数(各位数字互不相同，可以有0)，取出组成该四位数的每一位数，重组成由这四个数字构成的最大四位数max4和最小四位数min4(有0时为三位数)，计算max4与min4的差值，得到一个新的四位数。若该数不等于6174，则重复以上过程，直到得到6174为止。
例如，输入1234，则首先由4321-1234，得到3087；然后由8730-378，得到8352；最后由8532-2358，得到6174。
[C代码]
#include＜stdio.h＞
int difference(int
a[])
( int
t,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){
int temp=a[t];
a[t]=a[i]; a[i]=temp;
}
}
max4=______;
min4=______;
return max4-min4;
}
int main()
{ int
n,a[4];
printf("input
a positive four-digit number:");
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);
}
return 0;
}参考答案：
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
3、阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
对一个整数序列进行快速排序的方法是：在待排序的整数序列中取第一个数作为基准值，然后根据基准值进行划分，从而将待排序列划分为不大于基准值者(称为左子序列)和大于基准值者(称为右子序列)，然后再对左子序列和右子序列分别进行快速排序，最终得到非递减的有序序列。
函数quicksort(int a[],int n)实现了快速排序，其中，n个整数构成的待排序列保存在数组元素a[0]～a[n-1]中。
[C代码]
#inclLade＜stdi0.h＞
void quicksort(int
a[], int n)
{
int i,j;
int pivot=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 )
______;
//递归地对右孔序列进行快速排序
}
int main()
{
int i, 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]);
return 0;
}参考答案：
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] arrsizeof(arr)/sizeof(int) 注：sizeof(arr)/sizeof(int)可替换为8
4、
阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
函数GetListElemPtr(LinkList L，int i)的功能是查找含头结点单链表的第i个元素。若找到，则返回指向该结点的指针，否则返回空指针。
函数DelListElem(LinkList L,int i,ElemType *e)的功能是删除含头结点单链表的第i个元素结点，若成功则返回SUCCESS，并由参数e带回被删除元素的值，否则返回ERROR。
例如，某含头结点单链表L如下图(a)所示，删除第3个元素结点后的单链表如下图(b)所示。
#define SUCCESS 0 #define ERROR -1 typedef int Status; typedef int ElemType;
链表的结点类型定义如下：
typedef struct Node{
ElemType data;
struct Node *next;
}Node,*LinkList;
[C代码]
LinkList
GetListElemPtr(LinkList L,int i)
{ /*L是含头结点的单链表的头指针,在该单链表中查找第i个元素结点;
若找到,则返回该元素结点的指针,否则返回NULL
*/
LinkList p;
int k;
/*用于元素结点计数*/
if(i＜1 || !L || !L-＞next) return NULL;
k=1; p=L-＞next; /*令p指向第1个元素所在结点*/
while(p &&
______){ /*查找第i个元素所在结点*/
______; ++k;
}
return p;
}
Status
DelListElem(LinkList L,int i,ElemType *e)
{ /*在含头结点的单链表L中,删除第i个元素,并由e带回其值*/
LinkList p,q;
/*令P指向第i个元素的前驱结点*/
if(i==1)
______;
else
p=GetListElemPtr(L,i-1);
if(!P || !p-＞next) return ERROR; /*不存在第i个元素*/
q=______;
/*令q指向待删除的结点*/
p-＞next=q-＞next; //从链表中删除结点*/
______;
/*通过参数e带回被删除结点的数据*/
free(q);
return
SUCCESS;
}
参考答案：
k＜i p=p-＞next p=L p-＞next *e=q-＞data
5、阅读以下说明和C++代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
在股票交易中，股票代理根据客户发出的股票操作指示进行股票的买卖操作。其类图如下图所示，相应的C++代码附后。
类图
[C++代码]
#include＜iostream＞
#include＜string＞
#include＜vector＞
using namespace
std;
class Stock {
private:
string name;
int quantity;
public:
Stock(string
name,int quantity) {this-＞name=name;
this-＞quantity
=quantity;}
void buy() {cout＜＜"[买进]股票名称:"＜＜name＜＜",数量:"＜＜quantity＜＜
endl;}
void sell() {cout＜＜"[卖出]股票名称:"＜＜name＜＜",数量:"＜＜quantity
＜＜endl;}
};
clasS order{
public:
virtual void
execute()=0;
};
class
BuyStock:______ {
private:
Stock* stock;
public:
BuyStock(Stock*
stock){______ =stock; }
void execute(){
stock一＞buy();
}
};
//类SellStock的实现与BuyStock类似,此处略
class Broker{
private:
vector＜Order*＞ orderList;
public:
void
takeOrder(______ order)( orderLiSt.push back(order);}
void placeorders()
{
for(int i=0;i＜orderList.Size(); i++){______ -＞execute();}
0rderLiSt.clear();
}
};
class
StockCommand{
public:
VOid main(){
Stock* aStock=new
Stock("股票A",10);
Stock*bStock=new
Stock("股票B",20);
Order*buyStockOrder=new BuyStock(aStock);
Order*
sellStockOrder=new SellStock(bStock);
Broker* broker=new
Broker();
broker-＞takeOrder(buyStockorder);
broker-＞takeOrder(sellStockOrder);
broker-＞ ______ ();
}
};
int main(){
StockCommand*
stockCommand=new StockCommand();
StockCommand-＞main();
delete
StoCkCommand;
}
参考答案：
publicOrder this-＞stock 或(*this).stock Order* orderList[i] 或 *(orderList+i) placeOrders
6、阅读以下说明和Java代码，填补代码中的空缺，将解答填入答题纸的对应栏内。
[说明]
在股票交易中，股票代理根据客户发出的股票操作指示进行股票的买卖操作。其类图如下图所示。相应的Java代码附后。
类图
[Java代码]
import
Java.util.ArrayList;
import
java.util.List;
ClaSS Stock{
private String
name;
private int
quantity;
public
Stock(String name,int quantity){
thiS.name=name;this.quantity=quantity;
}
public void buy(){
System.out.println("[买进]:"+name+",数量:"
+quantity);}
public void sell()
{System.out.println("[卖出]:"+name+",数量:"
+quantity);}
}
interface Order {
VOid execute();
}
class BuyStock
______ Order {
private Stock
Stock;
public
BuyStock(Stock stock){______=stock; }
public void
execute(){ stock.buy(); }
}
//类SellStock实现和BuyStock类似,略
clasS Broker{
private List＜Order＞orderList=new ArrayList＜Order＞();
Dublic void
takeOrder(______ Order){ orderList.add(order); }
public void
placeorders(){
for {______
order:orderList) {order.execute(); }
orderLiSt.clear();
}
}
public class
StockCommand {
public static void
main(String[]args){
Stock aStock:new
Stock("股票A",10);
Stock bStock=new
Stock("股票B",20);
Order
buyStockorder=new BuyStock(aStock);
Order
sellStockOrder=new SellSt0Ck(bStoCk);
Broker broker=new
Broker();
broker.takeOrder(buyStockorder);
broker.takeOrder(sellStockOrder);
broker.______;
}
}
参考答案：
implements this.stock Order Order placeOrders()
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
