欢迎大家订阅我的专栏：算法题解：C++与Python实现！
本专栏旨在帮助大家从基础到进阶 ，逐步提升编程能力，助力信息学竞赛备战！
专栏特色
1.经典算法练习：根据信息学竞赛大纲，精心挑选经典算法题目，提供清晰的代码实现与详细指导，帮助您夯实算法基础。
2.系统化学习路径：按照算法类别和难度分级，从基础到进阶，循序渐进，帮助您全面提升编程能力与算法思维。
适合人群：
- 准备参加蓝桥杯、GESP、CSP-J、CSP-S等信息学竞赛的学生
- 希望系统学习C++/Python编程的初学者
- 想要提升算法与编程能力的编程爱好者
附上汇总帖：GESP认证C++编程真题解析 | 汇总
单选题
第1题
在C++中，（ ）正确定义了一个返回整数值并接受两个整数参数的函数。
A.int add(int a, int b) { return a + b; }
B.void add(int a, int b) { return a + b; }
C. int add(a, b) { return a + b; }
D. void add(int a, int b) { return a - b; )
【答案】：A
【解析】
函数的定义中，返回值类型写在函数名之前，参数表需要指定参数的类型。
第2题
在C++中，形参与实参的关系描述正确的是（ ）。
A.形参在函数调用时指定，实参在函数定义时传递
B.形参在函数定义时指定，实参在函数调用时传递
C.形参和实参可以互换
D.形参和实参必须是完全相同的类型，不能有任何差异。
【答案】：B
【解析】
形参在函数定义时指定，实参在函数调用时传递，Ｂ正确。调用时，实参可以隐式转换成形参的类型（如果符合隐式转换的规则），D错误。
第3题
运行以下代码，屏幕上将输出（ ）。
#include <iostream>
using namespace std;
int var = 100;
void function() {
int var = 200;
cout << var << " ";
cout << ::var << " ";
}
int main() {
cout << var << " ";
function();
var += 100;
cout << var << " ";
}
A.100 200 100 200
B.100 200 100 300
C.100 200 200 200
D.100 200 200 300
【答案】：A
【解析】
程序中有两个变量var，一个是全局变量，一个是 function 函数中定义的局部变量。程序共输出4个数，main 函数中访问的 var 是全局变量，所以输出的第一个数是100，最后一个数是200；function 函数产生第二与第三个输出，默认访问的是局部变量，所以第二个输出是200。::是域作用符，它前面没有写具体的命名空间，默认指的是全局命名空间，所以::var 访问的是全局变量var，值为100。
第4题
运行下面代码，屏幕上输出是（ ）。
int arr[3] = {24,9,7};
int* p = arr;
p++;
cout << *p << endl;
A.24
B.9
C.7
D.7
【答案】：B
【解析】
第二行定义指针p，指向数组 arr 下标为0的元素24，执行厅p++后p指向下一个元素9。
第5题
运行下面代码片段的结果是（ ）。
int x = 20;
int y = 24;
int* p = &x;
int* q = &y;
p = q;
A.将 x 赋值为24
B.将 y 赋值为20
C.将 q 指向 x 的地址
D.将 p 指向 y 的地址
【答案】：D
【解析】
指针p指向x，q指向y，p = q就是让p指向q指向的地方，也就是让p指向y的地址。操作并不改变x与与y的值。
第6题
在C++中，（ ）正确定义一个名为student 的结构体，其中包含一个name 字符数组和一个age 整数？
A.struct student { char name[20]; int age; };
B.student struct { char name[20]; int age; };
C.student struct { string name; int age; };
D.struct student { char[20] name; int age; };
【答案】：A
【解析】
结构体关键字 struct，大括号中定义结构体成员。
第7题
在C++中，（ ）正确声明了一个3行4列的二维数组。
A.int arr[3, 4];
B.int arr[3][4];
C.int arr[4][3];
D.int arr(3, 4);
【答案】：B
【解析】
声明二维数组，语法为“元素类型 数组名[行数][列数];”
第8题
一个二维数组定义为 int arr[3][4]; （假设一个int变量占4个字节），则 int arr[0] 占用（ ）个字节的内存。
A.3
B.4
C.12
D.16
【答案】：D
【解析】
intarr[0]相当于4个元素的一维数组，占用4 * 4=16个字节。
第9题
下面代码采用递推算法来实现整数的阶乘（ ），则横线上应填写（ ）。
int factorial(int n) {
int result = 1;
for (int i=2; i<=n; i++) {
_________________________ // 在此处填入代码
}
return result;
}
A.result *= i;
B.result += i;
C.result *= result;
D.result += result;
【答案】：A
【解析】
1! = 1, n! = (n-1)! * n。
第10题
在排序算法中，稳定性指的是（ ）。
A.排序后数据不会丢失
B.排序后相同元素的相对顺序保持不变
C.排序后数据不会被修改
D.排序后数据的时间复杂度不变
【答案】：B
【解析】
排序的稳定性指的是：排序后相同元素的相对顺序保持不变。
第11题
下面代码实现了冒泡排序函数，则横线上应填写（ ）。
// 交换数组arr的第i个元素和第j个元素
void swap(vector &arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
int bubble_sort(vector &arr) {
for (int i=arr.size()-1; i>0; i--) {
bool flag = false; // 标志位
_________________________ { // 在此处填入代码
if (arr[j] > arr[j+1]) {
swap(arr, j+1, j);
flag = true;
}
}
if (!flag) break; // 此轮“冒泡”未交换任何元素
}
}
A.for (int j=0; j<arr.size()-1; j++)
B.for (int j=arr.size()-1; j>0; j--)
C.for (int j=0; j<i; j++)
D.for (int j=i-1; j<=0; j--)
【答案】：C
【解析】
本程序中冒泡排序将大的元素交换至数组右边，最多共n-1轮冒泡。
第12题
上一题算法的时间复杂度为（ ）。
A. O ( n 2 ) O(n^2) O(n2)
B. O ( 2 n ) O(2^n) O(2n)
C. O ( 1 ) O(1) O(1)
D. O ( n ) O(n) O(n)
【答案】：A
【解析】
冒泡排序的时间复杂度是 O ( n 2 ) O(n^2) O(n2)。
第13题
下面代码实现了插入排序函数（升序），则横线上应填写（ ）。
void insertion_sort(vector &nums) {
for (int i=1; i<nums.size(); i++) {
int base = nums[i], j = i - 1;
___________________________ { // 在此处填入代码
nums[j+1] = nums[j];
j--;
}
nums[j+1]=base;
}
}
A.while (j>=0 && nums[j]>base)
B.while (j>0 && nums[j]>base)
C.while (j>=0 && nums[j]<base)
D.while (j>0 && nums[j]<base)
【答案】：A
【解析】
插入排序的原理是从第二个元素开始，不断将当前元素插入左侧有序部分。
第14题
小杨用文件重定向实现在 log.txt 文件中输出日志，则下面横线上应填写（ ）。
#include <iostream>
#include <fstring>
#include <string>
using namespace std;
int main() {
ofstream log_file("log.txt");
streambuf* original_cout = cout.rdbuf();
cout.rdbuf(log_file.rdbuf());
__________________________________ // 在此处填入代码
cout.rdbuf(original_cout); // 恢复原始的标准输出缓冲区
return 0;
}
A.cout << "This output will go to the log file." << endl;
B.log_file << "This output will go to the log file." << endl;
C.cout >> "This output will go to the log file." << endl;
D.log_file >> `"This output will go to the log file." << endl;
【答案】：A
【解析】
程序将标准输出重定向到一个文件log.txt。所以空白处应该用cout，输出的内容会输出到 log.txt中。然后，恢复标准输出缓冲区。
第15题
运行下面的代码，屏幕上将输出（ ）。
#include <iosteam>
using namespace std;
int divide(int a, int b) {
if (b==0) {
throw runtime_error("division by zero error");
}
return a / b;
}
int main() {
int x = 10;
int y = 0; // 设为0会导致除零错误
try {
int result = divide(x, y);
cout << "result: " << result << endl;
} catch (const runtime_error& e) {
cout << "caught an exception: " << e.what() << endl;
}
return 0;
}
A.division by zero error result: caught an exception:
B.result: caught an exception: division by zero error
C.caught an exception: division by zero error
D.division by zero error caught an exception: division by zero error
【答案】：C
【解析】
divide函数中抛出异常，try 块中的 cout 语句不再执行。异常由main函数中的catch 捕获。
判断题
第16题
代码int a=10; int*p = &a;可以正确定义指针和初始化指针。
A.正确
B.错误
【答案】：A
【解析】
指针p指向变量a。
第17题
在C++中，引用传递允许函数修改传递给它的参数的值。
A.正确
B.错误
【答案】：A
【解析】
参数以引用方式传递，修改形参同时会修改实参。
第18题
指针的大小与其所指向的变量的数据类型的大小相同。
A.正确
B.错误
【答案】：B
【解析】
指针的大小由系统与编译器决定，32位系统中指针通常为4个字节，64位系统中指针通常为8个字节。
第19题
二维数组的行的大小的必须在定义时确定，列的大小可以动态变化。
A.正确
B.错误
【答案】：B
【解析】
二维数组的列的大小的必须在定义时确定，行的大小在定义时可以暂时省略。
第20题
递推算法通过逐步求解当前状态和前一个或几个状态之间的关系来解决问题。
A.正确
B.错误
【答案】：A
【解析】
递推算法的定义，属于简单的动规
第21题
选择排序是稳定的排序算法。
A.正确
B.错误
【答案】：B
【解析】
排序的稳定性指的是：排序后相同元素的相对顺序保持不变。常见的稳定的排序方法有：直接插入排序、冒泡排序、归并排序（鬼子头上插了一直🐔）。
第22题
插入排序的时间复杂度总是比冒泡排序低。
A.正确
B.错误
【答案】：B
【解析】
两种排序方法的最坏与平均时间复杂度都是 O ( n 2 ) O(n^2) O(n2)
第23题
在C++中，如果没有捕获到异常(没有匹配的catch块)，程序会继续执行而不会终止。
A.正确
B.错误
【答案】：B
【解析】
在C++中，异常会沿调用栈向上传播，直到找到一个匹配的 catch 块。如果没有找到匹配的catch 块，程序会终止执行。
第24题
以下代码用递推法求斐波那契数列的第n项，时间复杂度为指数级。
int fibonacci(int n) {
if (n==0) return 0;
if (n==1) return 1;
int f0 = 0; // F(0)
int f1 = 1; // F(1)
int current;
for (int i=2; i<=n; i++) {
current = f0 + f1; // F(n) = F(n-1) + F(n-2)
f0 = f1;
f1 = current;
}
return current;
}
A.正确
B.错误
【答案】：B
【解析】
递推法求斐波那契数列第n项的时间复杂度是 O ( n ) O(n) O(n) 的，即线性时间复杂度。
第25题
执行下面C++代码后，输出的是20。
int point(int* p) {
return *p * 2;
}
int main() {
int a = 10;
int* p = &a;
*p = point(p);
cout << *p << endl;
}
A.正确
B.错误
【答案】：B
【解析】
p指向变量 a， point 函数的返回值是p指向的变量的2倍，也也就是20。*p=20; 的执行效果是变量a赋值为20。最终输出a的值为20。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
