1. 符号表示异或运算， 的结果是（）。
A.
B.
C.
D.
2. 每个操作数都只有一位，后缀表达式 863-* 对应的前缀表达式为（）。
A. *8-63
B. *86-3
C. *-863
D. 8*-63
3. 将数组 变为从小到大有序的序列，每次可以交换相邻两个元素，问最少需要交换多少次（）。
A.
B.
C.
D.
4. 以下排序算法的常见实现中，哪个选项的说法是错误的（）。
A. 计数排序是不稳定的
B. 冒泡排序是稳定的
C. 简单插入排序是稳定的
D. 简单选择排序是不稳定的
5. 小图刚买了一个新内存，容量为 GB，以下哪个容量和小图新内存的容量相同（）。
A. TB
B. MB
C. KB
D. B
6. 假设 a 数组是长度为 n 的整数数组，从小到大有序，下面这段代码的时间复杂度是多少（）。
int f(int l, int r, int key) {
if (l > r) return -1;
int mid = (l + r) / 2;
if (key == a[mid]) return mid;
else if (key < a[mid]) return f(l, mid - 1, key);
else return f(mid + 1, r, key);
}
A.
B.
C.
D.
7. 以下哪组操作能完成在双向循环链表中删除节点 p 的效果（其中，next 域为节点的直接后继，prev 域为节点的直接前驱）（）。
A. p->next->prev = p->next; p->prev->next = p->prev;
B. p->next->prev = p->prev; p->prev->next = p->next;
C. p->next->prev = p; p->prev->next = p;
D. p->next = p->pre; p->pre = p->next;
8. 在一个无向简单图（无自环和重边）中有五个节点，编号为 ，以下选项中，都会给出每个节点的度数，哪一种情况是不符合实际的（）。
A.
B.
C.
D.
9. 个无标号节点可以组成 （） 个不同的二叉树。
A.
B.
C.
D.
10. 以下程序的输出是（）。
int sum = 0;
for (int i = 1, j = 2; i <= 8; i++, j *= 2) {
sum += j;
}
cout << sum << endl;
A.
B.
C.
D.
11. 字符串 ABBBCDD 中有 （） 个不同的子串。
A.
B.
C.
D.
12. 一棵二叉树的层序遍历为 ABCDEF， 中序遍历为 EDFBAC， 则其先序遍历为 （）。
A. ABCDEF
B. ABCEFD
C. ABDEFC
D. BDEFAC
13. 有一个容量为 的空栈 S, 将 A, B, C, D, E依次入栈，则 （） 不是可能的出栈序列。
A. A, D, E, C, B
B. B, A, E, D, C
C. C, D, B, E, A
D. D, E, C, B, A
14. 现有 ABCDE 个人排队，要求 D 一定要在 C 和 E 之间（ 个人不一定需要相邻），共有 （） 种不同的排队方法。
A.
B.
C.
D.
15. 在一个数轴上，每一次可以向左或者向右走 步，从 位置出发走 步后位于 位置，一共有 （）种不同的走法。
A.
B.
C.
D.
01 #include <iostream>
02 using namespace std;
03
04 int f1(int a, int b) {
05 if (a == b) return a;
06 else if (a > b) return f1(a - b, b);
07 else return f1(a, b - a);
08 }
09
10 int f2(int a, int b) {
11 if (b == 0) return a;
12 else return f2(b, a % b);
13 }
14
15 int main() {
16 int a, b;
17 cin >> a >> b;
18 cout << f1(a, b) << endl;
19 cout << f2(a, b) << endl;
20 return 0;
21 }
输入的数为不超过 的正整数，完成下面的判断题和单选题。
输入的两个数为 和 ，第一行输出的结果为 。（ ）
两个函数的时间复杂度相同。（ ）
（2 分）两个函数的功能相同。（ ）
（4 分）输入的两个数为 和 ，第二行输出的结果为（ ）。
A.
B.
C.
D.
以下哪一对输入数据，会让 f1 函数被调用的次数最多（ ）。
A.
B.
C.
D.
01 #include <iostream>
02 using namespace std;
03
04 const int N = 1e4 + 10;
05
06 int n, m, f[N];
07
08 void getPrimeFacs(int n) {
09 for (int i = 2; i * i <= n; i++) {
10 int cnt = 0;
11 while (n % i == 0) {
12 n /= i;
13 cnt++;
14 }
15 f[i] = max(f[i], cnt);
16 }
17 if (n > 1) f[n] = max(f[n], 1);
18 }
19
20 int main() {
21 cin >> n;
22 for (int i = 0; i < n; i++) {
23 cin >> m;
24 getPrimeFacs(m);
25 }
26 for (int i = 2; i < N; i++) {
27 if (f[i] > 0) {
28 cout << i << "^" << f[i] << " ";
29 }
30 }
31 return 0;
32 }
输入的每个数都是不超过 的正整数，完成下面的判断题和单选题。
当输入为 2 5 7 时，程序的输出为 2^1 5^1 7^1。（ ）
当输入为 2 4 5 时，程序的输出为 2^2 5^1。（ ）
（2 分）如果删除第 行并且将第 行修改为 for (int i = 2; i <= n; i++)，则对于任意合法输入，程序的输出保持不变。（ ）
（2 分）程序运行的过程中，变量 cnt 的值不可能超过 13 。（ ）
程序的时间复杂度为（ ）。
A.
B.
C.
D.
如果删除第 行，以下哪一组输入仍然能得到正确的（与删除之前一样的）输出（ ）。
A. 2 30 97
B. 2 100 88
C. 2 3072 1024
D. 2 121 18
01 #include <iostream>
02 using namespace std;
03
04 const int N = 5010;
05
06 int a[N];
07
08 int findMin(int l, int r) {
09 int pos = l;
10 for (int i = l; i <= r; ++i) {
11 if (a[i] < a[pos]) pos = i;
12 }
13 return pos;
14 }
15
16 long long sol(int l, int r, int h) {
17 if (l > r) return 0;
18 if (l == r) return a[l] > h;
19 int pos = findMin(l, r);
20 long long horizontal = (a[pos] - h) + sol(l, pos - 1, a[pos]) + sol(pos + 1, r, a[pos]);
21 long long vertical = r - l + 1;
22 return min(horizontal, vertical);
23 }
24
25 int main() {
26 int n;
27 cin >> n;
28 for (int i = 1; i <= n; ++i) {
29 cin >> a[i];
30 }
31 cout << sol(1, n, 0) << "\n";
32 return 0;
33 }
输入一个整数 和 个整数 ，完成下面的判断题和单选题。
（2 分）若数组 a 的所有元素相同，则程序输出 1。（ ）
（2 分）程序一定不会执行到第 17 行的 return 0。（ ）
（2 分）在 sol 函数中，递归子问题的参数 h 不小于原问题的参数 h。（ ）
若将 sol 函数中第 22 行的 return min(horizontal, vertical); 改为 return horizontal;，则程序的功能变为（ ）。
A. 计算数组 a 中的最大值
B. 计算数组 a 中不同元素的个数
C. 计算数组 a 中最小值的位置（若存在多个最小值，则返回第一个）
D. 以上均不正确
程序的时间复杂度为（ ）。
A
B.
C.
D.
若程序输入为 5 1 5 2 2 5，则程序输出为（ ）。
A. 3
B. 4
C. 5
D. 6
小明有一本新书，预估需要 分钟看完。接下来 天里，小明每天的空闲时间有 分钟。小明期望用连续的若干天把这本书看完，问最少需要多少天。
数据范围满足
提示：可以采用枚举和二分答案来求解，时间复杂度 。
试补全程序。
01 #include <iostream>
02 using namespace std;
03
04 const int N = 2e5 + 10;
05
06 int m, n;
07 int t[N], sum[N];
08
09 bool check(int start, int end) {
10 return /*____1____*/;
11 }
12
13 int binary_answer(int start, int l, int r) {
14 while (l <= r) {
15 int mid = (l + r) / 2;
16 if (/*____2____*/) r = mid - 1;
17 else l = mid + 1;
18 }
19 return /*____3____*/;
20 }
21
22 int main() {
23 cin >> m >> n;
24 for (int i = 1; i <= n; i++) cin >> t[i];
25 for (int i = 1; i <= n; i++) sum[i] = sum[i-1] + t[i];
26 int ans = n;
27 for (int i = 1; i <= n; i++) {
28 int tmp = binary_answer(i, i, n);
29 if (/*____4____*/) ans = min(ans, /*____5____*/);
30 }
31 cout << ans << endl;
32 return 0;
33 }
/*____1____*/ 处应填（ ）
A. sum[end] - sum[start - 1] >= m
B. sum[end] - sum[start - 1] > m
C. sum[end] - sum[start] >= m
D. sum[end] - sum[start] > m
/*____2____*/ 处应填（ ）
A. check(l, mid)
B. check(start, mid)
C. check(start, r)
D. check(mid, r)
/*____3____*/ 处应填（ ）
A. r - 1
B. r
C. l
D. l + 1
/*____4____*/ 处应填（ ）
A. i + tmp < n
B. i + tmp <= n
C. i + tmp - 1 <= n
D. tmp <= n
/*____5____*/ 处应填（ ）
A. tmp
B. tmp - i
C. tmp - i + 1
D. n - tmp + 1
小图最近学习了字符串和栈，他想模拟文本编辑器的一些操作，初始时编辑器文本为空，光标位于最左端。小图的程序要执行 次操作，每次操作为以下 种指令之一，代表含义如下：
L：光标左移一格（若已经在最左端则忽略此操作）；R：光标右移一格（若已经在文本最右端则忽略此操作）；I x：在光标左侧插入 x（x 为输入的某个英文字母）；D：删除光标左侧字符（若光标在最左端则忽略此操作）。 次操作后，从左到右输出最终的文本内容。
试补全程序。
01 #include <iostream>
02 #include <stack>
03 #include <string>
04 using namespace std;
05
06 stack<char> lStack, rStack;
07
08 int main() {
09 int q;
10 cin >> q;
11 while (q--) {
12 char op, x;
13 cin >> op;
14 if (op == 'L') {
15 if (lStack.empty()) continue;
16 rStack.push(lStack.top());
17 lStack.pop();
18 }
19 else if (op == 'R') {
20 if (rStack.empty()) continue;
21 /*____1____*/;
22 rStack.pop();
23 }
24 else if (op == 'I') {
25 cin >> x;
26 /*____2____*/;
27 }
28 else {
29 if (/*____3____*/) continue;
30 lStack.pop();
31 }
32 }
33 string s;
34 while (!lStack.empty()) {
35 /*____4____*/;
36 lStack.pop();
37 }
38 while (!rStack.empty()) {
39 /*____5____*/;
40 rStack.pop();
41 }
42 cout << s << '\n';
43 return 0;
44 }
/*____1____*/ 处应填（ ）
A. lStack.push_front(rStack.front())
B. lStack.push(rStack.top())
C. lStack.push(rStack.top() - 1)
D. lStack.push(rStack[0])
/*____2____*/ 处应填（ ）
A. lStack.push(x)
B. lStack.push('x')
C. rStack.push(x)
D. rStack.push(lStack.top()); lStack.push(x)
/*____3____*/ 处应填（ ）
A. op != 'D'
B. lStack.top() != x
C. lStack.empty()
D. lStack.empty() && rStack.empty()
/*____4____*/ 处应填（ ）
A. s += lStack.top()
B. cout << lStack.top()
C. rStack.push(lStack.top())
D. rStack.push(lStack.front())
/*____5____*/ 处应填（ ）
A. s = rStack.top() + s
B. s.insert(s.begin(), rStack.top())
C. s.replace(s.size() - 1, 0, rStack.top())
D. s.push_back(rStack.top())