一、单选题（每题2分，共30分）
| 题目 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| 答案 | B | B | B | D | B | D | D | A | A | B | A | D | A | B | D |
1.下列代码中，输出结果是（ ）
#include<bits/stdc++.h>
using namespace std;
int func(int x,int y){
int a=x,b=y;
int t;
t=a;
a=t;
b=t;
cout<<a<<" "<<b<<" ";
}
int main()
{
int c,d;
c=12;
d=24;
func(12,24);
cout<<c<<" "<<d<<endl;
}
A. 12 24 24 12
B. 24 12 12 24
C. 12 12 24 24
D. 24 24 12 12
【答案】B
【考纲知识点】函数的定义与调用
【解析】模拟一下func()函数的过程，可以发现它将变量x和y的值进行了交换，而传入的x、y的分别是12和24，交换之后便是24和12，因此前两个数输出24和12，后两个数字就是顺序输出的c、d的值，也就是12和24。
2.下面函数不能正常执行的是（）
A.
#include<iostream>
using namespace std;
int func()
{
//...
}
int main()
{
//...
}
B.
#include<iostream>
using namespace std;
int main()
{
func();
}
int func()
{
//...
}
C.
#include<iostream>
using namespace std;
int func()
{
//...
}
int main()
{
func();
}
D.
#include<iostream>
using namespace std;
int func();
int main()
{
func();
}
int func()
{
//...
}
【答案】B
【考纲知识点】函数的定义与调用
【解析】在调用函数之前，应该先定义函数。
3.下面程序输出的是（）
#include<iostream>
using namespace std;
int func();
int main()
{
int i=2;
cout<<i<<endl;
for(int x=0;x<1;x++){
int i=10;
cout<<i<<endl;
}
i=i+1;
cout<<i<<endl;
{
i=i*i;
cout<<i<<endl;
}
}
A. 2 2 3 9
B. 2 10 3 9
C. 2 10 11 121
D. 2 10 3 100
【答案】B
【考纲知识点】形参与实参、作用域
【解析】注意for循环内部的变量i只作用于for循环内部，因此第二个输出的数应该是10；而第6行的变量i的作用域则不包含for循环内部的部分，因此第3、4个数的值取决于第6行变量i的初始值，模拟计算一下即可。
4.假设变量 a 的地址是0x6ffe14，下面程序的输出是（ ）。
#include<iostream>
using namespace std;
int main(){
int *p;
int a=10;
p=&a;
p++;
cout<<p<<endl;
}
A. 10
B. 0x6ffe14
C. 0x6ffe15
D. 0x6ffe18
【答案】D
【考纲知识点】C++指针类型的概念及基本应用
【解析】一个int变量占4字节，因此当指针p移动到下一个地址时，应当加上对应的字节数4。
5. 如果下列程序输出的地址是 0x6ffe00 ，则 cout<<a+1<<endl; 输出的是（）
#include<iostream>
using namespace std;
int main(){
int a[2][3]={0};
cout<<a<<endl;
}
A. 0x6ffe04
B. 0x6ffe0C
C. 0x6ffe08
D. 0x6ffe00
【答案】B
【考纲知识点】C++指针类型的概念及基本应用
【解析】一个int变量占4字节，而a是一个2*3规模的二维数组，相当于是2个3长度的一维数组；a的地址是第0个数组的第0个元素的地址，而a+1的地址是第1个数组的第0个元素的地址；中间间隔了3个int变量，因此应当加上对应的总字节数12。
6.C++中，关于文件路径说法错误的是（）
A. "GESP.txt"：指定与当前工作目录中的程序文件相同目录中的 GESP.txt 文件
B. "../data/GESP.txt"：指定与当前工作目录中的程序文件上一级目录下的 data 目录中的 GESP.txt 文件
C. "./data/GESP.txt"：指定与当前工作目录中的程序文件同级目录下的 data 目录中的 GESP.txt 文件
D. "GESP.txt"是绝对路径
【答案】D
【考纲知识点】文件重定向
【解析】当“GESP.txt”文件前面没有其他前置路径的时候，其表示的意思就是与当前⼯作⽬录中的程序⽂件相同⽬录中的GESP.txt⽂件
7. 关于直接插入排序，下列说法错误的是（）
A.插⼊排序的最好情况是数组已经有序，此时只需要进⾏n-1次⽐较 ，时间复杂度为O(n)
B.最坏情况是数组逆序排序，此时需要进⾏n(n-1)/2次⽐较以及n-1次赋值操作（插⼊）
C.平均来说插⼊排序算法的复杂度为O(n2)
D.空间复杂度上 ，直接插⼊法是就地排序 ，空间复杂度为O(n)
【答案】D
【考纲知识点】排序算法
【解析】就地排序只需要O(1)的额外空间。
8.下列程序横线处 ，应该输⼊的是 （ ）。
#include<iostream>
using namespace std;
int n,a[10001];
void swap(int &a,int &b)
{
int t=a;
a=b;
b=t;
}
int main(){
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=n;i>1;i--)
for(int j=1;j<i;j++)
if(a[j]>a[j+1])
_____________;
for(int i=1;i<=n;i++)
cout<<a[i]<<" ";
cout<<endl;
return 0;
}
A. swap(a[j],a[j+1]);
B. swap(a[j-1],a[j]);
C. swap(a[j-1],a[j+1]);
D. swap(&a[j-1],&a[j+1]);
【答案】A
【考纲知识点】排序算法
【解析】考察冒泡排序的过程，不断地把较大的值往后放，因此，如果a[j]>a[j+1]成立，说明a[j]是较大的值，应当通过交换操作来将a[j]换到后面去。
9.下⾯关于递推的说法不正确的是（ ）。
A.递推表现为⾃⼰调用自己
B.递推是从简单问题出发，⼀步步的向前发展，最终求得问题。是正向的
C.递推中，问题的n要求是在计算中确定，不要求计算前就知道n
D.斐波那契数列可以⽤递推实现求解
【答案】A
【考纲知识点】递推算法
【解析】自己调用自己是递归的表现，而不是递推，注意区分。
10.关于几种排序算法的说法 ，下⾯说法错误的是（ ）。
A.选择排序不是⼀个稳定的排序算法
B.冒泡排序算法不是⼀种稳定的排序算法
C.插⼊排序是⼀种稳定的排序算法
D.如果排序前2个相等的数在序列中的前后位置顺序和排序后它们2个的前后位置顺序相同，则称为⼀种稳定的 排序算法
【答案】B
【考纲知识点】排序算法
【解析】在冒泡排序中，两个元素交换的条件是a[j]>a[j+1]，如果两个元素的值相等，他们并不会发生交换，因此是一种稳定的排序算法。
11.数组{45,66,23, 1, 10,97,52,88,5,33}进⾏从⼩到⼤冒泡排序过程中 ，第⼀遍冒泡过后的序列是（ ）。
A. {45,23, 1, 10,66,52,88,5,33,97}
B. {45,66, 1,23, 10,97,52,88,5,33}
C. {45,66,23, 1, 10,52,88,5,33,97}
D. {45,66,23, 1, 10,97,52,88,33,5}
【答案】A
【考纲知识点】排序算法
【解析】按照冒泡排序的过程模拟一遍即可，66会被一直交换到97的前面的位置，97会被一直交换到数组末尾的位置。
12.下⾯的排序算法程序中 ，横线处应该填⼊的是（ ）。
int a[8]={ 2,3, 4, 5, 6,2,3,1};
for (int i=1;i<8;i++)
{
int key = a[i];
int j=i-1;
while(a[j]>key && j>=0)
{
________;
j -= 1;
}
a[j + 1]= key;
}
A. a[j]=a[j-1];
B. a[j]=a[j+1];
C. a[j+1]=a[j-1];
D. a[j+1]=a[j];
【答案】D
【考纲知识点】排序算法
【解析】考察插入排序的过程，不断地将a[i]与前面的数字比较，以便找到合适的位置插入进去；因此，在已排好序的部分中，所有比a[i]大的数字都要整体往右移动一个单位；若a[j]比a[i]大，那么它往右移动一个单位之后的位置是j+1，所以应该将a[j]赋值给a[j+1]。
13.下⾯的程序中 ，如果输⼊ 10 0 ，会输出（ ）。
#include<iostream>
using namespace std;
double Division(int a,int b)
{
if(b==0)
throw "Division by zero condition!";
else
return ((double)a/(double)b);
}
void func()
{
int len,time;
cin>>len>>time;
cout<<Division(len,time)<<endl;
}
int main(){
try{
func();
}
catch(const char* errmsg){
cout<<errmsg<<endl;
}
catch(const int errmsg){
cout<<errmsg<<endl;
}
return 0;
}
A. Division by zero condition !
B. 0
C. 10
D. 100
【答案】A
【考纲知识点】函数的定义与调用、函数参数传递
【解析】输入len=10与time=0，分别传入Division()函数中的a、b，于是有a=10、b=0，条件b==0成立。
14.10条直线 ，最多可以把平⾯分为多少个区域（ ）。
A. 55
B. 56
C. 54
D. 58
【答案】B
【考纲知识点】贪心
【解析】当第x条直线加入进来的时候，我们总有一种贪心的方法，让这条直线与前面的所有x-1条直线相交，每发生一次相交都会额外产生一个区域，因此会产生x-1个区域，再加上整个平面本身会被分割一次，所以会产生x个区域，于是10条直线能够分割出来的区域数量就是1+2+3+4+5+6+7+8+9+10=55，最后不要忘记整个平面本身最初也有一个区域，所以还要加1，答案是55+1=56。
15.下⾯程序中，如果语句cout<<p<<endl;输出的是0x6ffe00，则cout<<++p<<endl;输出的是 ()
int x[10][10][10]={{0}};
int *p;
p=&x[0][0][0];
cout<<p<<endl;
cout<<++p<<endl;
A. 0x6ffe0c
B. 0x6ffe09
C. 0x6ffe06
D. 0x6ffe04
【答案】D
【考纲知识点】C++指针类型的概念及基本应用
【解析】一个int变量占4字节，p指针指向了x数组的首地址，因此，在++p之后，p指针移动到了下一个元素的地址，需要加上对应的int变量的字节数。
二、判断题（每题2分，共20分）
| 题目 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 答案 | × | √ | √ | √ | × | √ | √ | √ | √ | √ |
1.int& a 和 &a 是一样的，都是取 a 的地址。
【答案】错误
【考纲知识点】C++指针类型的概念及基本运用
【解析】&a是取a的地址，而int& a 是引用变量，作用是获取某个变量的“引用”，即给某一个变量起一个别名。
2.以下代码不能够正确执行。
#include<iostream>
using namespace std;
int main(){
int a=20;
int &ra;
ra=&a;
cout<<ra<<endl;
}
【答案】正确
【考纲知识点】C++指针类型的概念及基本运用
【解析】同上一题，int& ra 是引用变量，需要在定义时设置一个初始值。
3.引用是一个指针常量。
【答案】正确
【考纲知识点】C++指针类型的概念及基本运用
【解析】指针常量指向的内存地址无法修改，而指向的内存地址对应的值可以修改。
4.下面程序两个输出结果是一样的。
#include<iostream>
using namespace std;
int main(){
int a[2][3]={0};
cout<<a<<endl;
cout<<&a[0][0]<<endl;
}
【答案】正确
【考纲知识点】C++指针类型的概念及基本运用
【解析】输出a即直接输出数组a的首地址，而a[0][0]是数组a的第0个元素，因此&a[0][0]相当于就是取了第0个元素的地址，即首地址。
5.函数不可以调用自己。
【答案】错误
【考纲知识点】函数的定义与使用
【解析】递归算法的实现就是“函数调用自己”。
6.函数参数传递过程中，如果传常量值、常量引用和常量指针都是不能被修改的，它们可以防止函数对实参的值或地址进行修改。
【答案】正确
【考纲知识点】C++指针类型的概念及基本运用
【解析】常量无法被修改，因此若想要实参的值不被修改，传入常量即可。7.下面代码输出的值等于0。
#include<iostream>
using namespace std;
int main(){
int *p=NULL;
cout<<p<<endl;
}
【答案】正确
【考纲知识点】C++指针类型的概念及基本运用
【解析】空指针指向0地址。
8. 在下面这个程序里， a[i][j] 和一个普通的整型变量一样使用。
#include<iostream>
using namespace std;
int main(){
int a[10][10]={0};
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(i==j){
a[i][j]=1;
}
}
}
}
【答案】正确
【考纲知识点】C++二维数组与多维数组的应用
【解析】整型二维数组中的每一个元素都是一个整型变量。
9. 一个一维数组，至少含有一个自然数N，是一个合法的数列。可以在一维数组末尾加入一个自然数M，M不能超过一维数组末尾元素的一半，形成一个新的合法的一维数组，如果N=6，那么可以有6个不同的合法数组。
【答案】正确
【考纲知识点】递推
【解析】合法的6个数组分别是{6}、{6,1}、{6,2}、{6,3}、{6,3,1}、{6,2,1}
10.插⼊排序算法中 ，平均时间复杂度是O(n2)，最坏的情况逆序情况下 ，达到最⼤时间复杂度。
【答案】正确
【考纲知识点】排序算法
【解析】在最坏的逆序情况下，每一个元素都会被插入到已排好序部分的最前面。
三、编程题（每题25分，共50分）
1、黑白方块
【问题描述】
⼩杨有⼀个n⾏m列的⽹格图 ，其中每个格⼦要么是⽩⾊ ，要么是⿊⾊ 。
对于⽹格图中的⼀个⼦矩形 ，⼩杨认为它是平衡的当且仅当其中⿊⾊格⼦与⽩⾊格⼦数量相同。 ⼩杨想知道最⼤的平衡⼦矩形包含了多少个格⼦。
【输入描述】
第⼀⾏包含两个正整数n, m ，含义如题⾯所⽰ 。
之后n⾏ ，每⾏⼀个长度为 m的01串 ，代表⽹格图第 i⾏格⼦的颜⾊ ，如果为 ，则对应格⼦为⽩⾊ ，否则为⿊ ⾊ 。
【输出描述】
输出⼀个整数，代表最⼤的平衡⼦矩形包含格⼦的数量，如果不存在则输出0。
【样例输入 1】
4 5
00000
01111
00011
00011
【样例输出 1】
16
【题目大意】
【考纲知识点】
C++二维数组和多维数组的基本应用
【解题思路】
首先解决 “如何判断一个矩阵 a是一个平衡矩阵”这个问题：枚举矩阵中的每一个元素，用两个计数器a[0]、a[1]分别记录0和1的数量，如果最终a[0]==a[1]，那么就是平衡矩阵，复杂度是O(n^2)。
然后解决“如何枚举一个矩阵中的所有子矩阵”这个问题：对于任意一个子矩阵，它都有一个起始行、一个终止行、一个起始列和一个终止列，我们可以用4个for循环来分别枚举它们，这样就应该把每个子矩阵确定下来，复杂度是O(n^4)。
如此一来，我们便可以用O(n^4)的复杂度枚举每一个子矩阵，然后再花O(n^2)的复杂度判断是否是平衡矩阵，总体时间复杂度为O(n^6)。
【参考程序】
#include<bits/stdc++.h>
using namespace std;
const int N = 55;
int w[N][N];
int n,m;
bool check(int xa,int ya,int xb,int yb){
int a[2]={0,0};
for(int i = xa;i<=xb;i++){
for(int j=ya;j<=yb;j++){
a[w[i][j]]++;
}
}
return a[0]==a[1];
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
string s;
cin>>s;
for(int j=1;j<=m;j++){
w[i][j]=s[j-1]-'0';
}
}
int ans = 0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
for(int ii=i;ii<=n;ii++){
for(int jj=j;jj<=m;jj++){
if(check(i,j,ii,jj)){
ans = max(ans,(ii-i+1)*(jj-j+1));
}
}
}
}
}
cout<<ans<<"\n";
}
2、宝箱
【问题描述】
⼩杨发现了n个宝箱 ，其中第 i个宝箱的价值是ai。
⼩杨可以选择⼀些宝箱放⼊背包并带走 ，但是⼩杨的背包⽐较特殊 ，假设⼩杨选择的宝箱中最⼤价值为x，最⼩价值为y，⼩杨需要保证x - y ≤ k ，否则⼩杨的背包会损坏。
⼩杨想知道背包不损坏的情况下， ⾃⼰能够带⾛宝箱的总价值最⼤是多少。
【输入描述】
第⼀⾏包含两个正整数n, k ，含义如题⾯所⽰ 。
第⼆⾏包含n个正整数a1, a2 , · · · , an，代表宝箱的价值。
【输出描述】
输出⼀个整数 ，代表带走宝箱的最⼤总价值。
【样例输入 1】
5 1
1 2 3 1 2
【样例输出 1】
7
【题目大意】
【考纲知识点】
排序算法
【解题思路】
比较容易想到的做法是用O(n)的复杂度枚举一个a[i]作为最大值x，然后用O(n)的复杂度枚举另一个值a[j]作为最小值y，最后用O(n)的复杂度枚举数组，计算一下值处于[x,y]的元素总和sum，算出来的总和与ans取最大值即可，但是这样的做法是O(n^3)的，没有办法拿到满分；
我们发现，之所以我们最后需要O(n)的复杂度枚举数组的元素计算总和，是因为我们不知道数值处在[x,y]范围内的元素总和是多少，所以需要枚举计算。
为了解决这个问题，我们可以先将数组从小到大排序，这样一来，数组中的每个子区间[j,i]的左右端点的值a[j]、a[i]分别就对应了我们枚举的最小值x，和最大值y，又因为数组是有序的，因此，数值处于[x,y]范围内的元素正好就是区间[j,i]内的所有元素，这样一来，我们就可以在向前枚举a[j]（也就是最小值y）的同时，顺便计算区间[j,i]内的元素总和sum，时间复杂度降为了O(n^2)。
【参考程序】
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int a[N];
int n,k;
int main(){
cin>>n>>k;
for(int i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+n+1);
int ans=0;
for(int i=1;i<=n;i++){
int sum=0;
for(int j=i;j>=1;j--){
if(a[i]-a[j]<=k){
sum+=a[j];
}else break;
}
ans=max(ans,sum);
}
cout<<ans<<"\n";
}