1、单选题（每题 2 分，共 30 分）
第 1 题 关于下述代码，说法错误的是（ ）。
A. 函数 multiply 的定义应该放到函数 main 之前。
B. 函数声明 int multiply(int x, int y); 中明确指定了函数 multiply() 的返回值为整数类型。
C. 在 main 函数中，函数 multiply 通过 multiply(a, b) 被调用，其中 a 和 b 是定义在 main 函数中的变量，它们作为实参传递给了 multiply 函数的形参 x 和 y 。
D. 运行上述代码，将输出 The result is: 20 。
解析：选择A,当前程序不报错，应为第1行已经进行了函数声明。
第 2 题 执行下述代码将输出（ ）。
int x = 10;
void func() {
int x = 20;
std::cout << x;
}
int main() {
func();
std::cout << x;
return 0;
}A. 2020
B. 2010
C. 1010
D. 编译错误
解析：函数调用func()先输出了 20，然后回来第8行输出10。
第8行的输出的x是第1行定义的全局变量，第 4行输出的x是第3行定义的局部变量。
第 3 题 执行下述代码后，变量 a 的值为
int a = 10;
int* p = &a;
*p = 20A. 10
B. 20
C. 随机值
D. 编译错误
解析：第2行定义的指针存储的是a的地址，第3行修改*p的值，其实就是修改了a。
第 4 题 以下哪种参数传递方式可以避免拷贝大型对象？
A. 只能用值传递
B. 只能用引用传递
C. 只能用指针传递
D. 引用传递和指针传递均可
解析：看到了记住就好，其他的说法太绝对。
第 5 题 执行下述代码，将输出（ ）。
A. 12
B. 21
C. 22
D. 11
解析：变量交换了x,y.但是 x是值传递，y是引用传递。值传递不改变结果还是1，引用传递会改变结果，swap函数里面是变量交换b的值更新变成了a的值。所以最后x=y=1;
第 6 题 下面的描述中，（ ）正确定义一个名为 Person 的结构体并正确初始化了一个 Person 结构体的变量 p 。
解析：选择C
第 7 题 给定如下代码，
下面描述错误的是（ ）。
A. 结构 Person 内嵌套结构 Address
B. Person 有一个 Address 类型的 address 成员
C. 一个 Person 类型的变量 p 的 address 的初始化可以写成： p.address.street = "123 Main St";
p.address.city = "Anytown";
D. 结构的嵌套可以减少命名冲突，因此可以不必控制嵌套层次
解析：很明显D选项不正确，能不嵌套我们绝不嵌套。嵌套代码容易出错，时间复杂度高。
第 8 题 假设 int arr[2][3] = {{1,2,3},{4,5,6}}; ，则 arr[1][2] 的值是（ ）。
A. 2
B. 3
C. 5
D. 6
解析：下面图中坐标是下标，右边红色的是值 ，arr[1][2]=6
0，0 （1） | 0，1 （2） | 0，2 （3） |
1，0 （4） | 1，1 （5） | 1，2 （6） |
第 9 题 下面（ ）正确定义了二维数组。
A. int arr[3,4];
B. int arr[3][4];
C. int arr(3,4);
D. int a[3-4];
解析：
第 10 题 小杨正在爬楼梯，需要爬 阶才能到达楼顶。如果每次可以爬1个或2个台阶，下面代码采用递推算法来计算共有多少种不同的方法可以爬到楼顶，则横线上应填写（ ）。
解析：选择B ,递推算法带入数据即可
f1=1,f2=2;
res=1+2=3;
f1=2;
f2=3;
第 11 题 给定如下算法，其时间复杂度为（ ）。
解析：双重循环，内循环是n，外循环是n/2,最多2的n次方。所以答案选择B
第 12 题 下面关于排序稳定性的描述，正确的是（ ）。
A. 稳定性指算法的时间复杂度恒定
B. 稳定排序保证相同元素的相对顺序不变
C. 选择排序是稳定排序
D. 插入排序不是稳定排序
解析：int a[5]={3,1,,1};稳定排序升序后是{1,1,3},其中两个1在排序前后位置没有发生变化。
稳定排序算法 | 不稳定排序算法 |
冒泡排序 插入排序 归并排序 计数排序 基数排序 桶排序 | 选择排序 希尔排序 快速排序 堆排序 |
第 13 题 对数组 arr[]={5, 3, 8, 1} 进行升序排序，执行第一轮冒泡排序后数组 arr 中的内容为（ ）。
A. 3, 5, 1, 8
B. 3, 1, 5, 8
C. 3, 5, 8, 1
D. 5, 3, 8, 1
解析：需要知道是升序或者降序 。 升序一轮后 {3,5,1,8}
降序一轮后{5，8，3，1} 只能相邻的数进行比较
第 14 题 运行下面的代码，将出现（ ）。
A. 屏幕上输出 Caught: Runtime error occurred.
B. 屏幕上输出 Caught an unknown exception.
C. 程序调用 std::terminate()
D. 编译错误
解析：自己阅读程序即可
第 15 题 下面哪种方式不能实现将字符串 "Happy Spring!" 输出重定向到文件 log.txt （ ）。
解析：选择C， 对比B和C，发现C肯定是错误的。
2、判断题（每题 2 分，共 20 分）
第 1 题 函数是C++中的核心概念，用于封装可重用的代码块。
解析：说的对
第 2 题 在C++中，函数的返回类型可以省略，默认为 int 。
解析：返回类型没有省略的说法，不返回就写void
第 3 题 结构体的成员默认是 public 访问权限。
解析：记一下
第 4 题 假设整数数组 arr[4]= {0, 1, 2, 3}; 的第一个元素在内存中的地址为 0x7ffee4065820 , 经过 int* p = arr; p += 1; 后，指针 p 的值是1。
解析：p是地址变量 ，*p是地址的值。 所以答案错误
第 5 题 二维数组作为函数参数时，必须显式指定所有维度的大小。
解析：可以不写大小，传递参数的时候会更新。
第 6 题 递推是一种通过已知的初始值和递推公式，逐步求解目标值的算法。
解析：记一下
第 7 题 考虑最坏情况下冒泡排序算法的时间复杂度T(n),为待排序数字的数目为 的复杂度，则其递推关系式为
解析：记一下
第 8 题 插入排序在最好情况（已有序）下的时间复杂度是
解析：最好是n,最坏是n^2
第 9 题 对数组 arr[]={4, 3, 1, 5, 2} 进行升序排序，执行第一轮选择排序后数组arr中的内容是 {1, 4, 3, 5, 2} 。
解析：选择排序排序是固定a[1]和其他数比较最后确定4的位置，现在很明显不对。应该是{1,3,4,5,2}
第 10 题 未捕获异常会调用std::terminate终止程序。
解析：记一下
3、编程题（每题 25 分，共 50 分）
解析：用数组mat存储地图，a数组记录每个位置是否可以当成荒地。如果说<i,j>位置存在'#',进行特判如果是只有1个那么就算是删除后变成荒地的，存储在a位置。 直接是荒地的存储在ans中。
#include<bits/stdc++.h>
using namespace std;
const int N = 1005;
char mat[N][N];
int a[N][N];
const int d[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int main() {
int n, m, ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++)
scanf("%s", mat[i] + 1); //输入n行字符串
//处理过程
for (int i = 1; i <= n; i ++){
for (int j = 1; j <= m; j ++) {
int num = 0, p = -1;
for (int k = 0; k < 4; k ++) { //探索i,j周围的四个方向是否有'#'
if (mat[i + d[k][0]][j + d[k][1]] == '#')
num ++, p = k;//有num个'#',在k方向上
}
if (mat[i][j] == '.' && num == 1)//只有一个‘#’可以删除
a[i + d[p][0]][j + d[p][1]] ++;
else if (mat[i][j] == '.' && num == 0) //没有#，直接记录到ans中
ans ++;
else if (mat[i][j] == '#' && num == 0) a[i][j] ++;//本身是'#'周围没有。
}
}
//找到最多访问的位置
int mx = 0;
for (int i = 1; i <= n; i ++)
for (int j = 0; j <= m; j ++)
mx = max(mx, a[i][j]);
cout << ans + mx << endl;
return 0;
}解析：按位置判断每一个位置是否可以组成子矩阵。
核心代码：
if (a[i][j] * a[i + 1][j + 1] == a[i + 1][j] * a[i][j + 1])
#include <bits/stdc++.h>
using namespace std;
int n, m,ans;
int a[505][505];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
//判断每一个位置是否是子矩阵
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
if (a[i][j] * a[i + 1][j + 1] == a[i + 1][j] * a[i][j + 1])
ans++;
printf("%d\n", ans);
return 0;
}编辑不易，欢迎点赞评论收藏三连。