题目导航

林老师 · 客观题题库 · 专题 05 栈与队列 · 复习强化

专题 05 栈与队列 · 复习强化

100 题 · 每题对应一个知识细节 · 全部原创

真题
复刻

试卷编号ORIG-专题05栈与队列-复习强化

题目总数111 题 · 100 分

试卷类型客观题

考生须知：
① 本卷共 11 大部分，合计 111 题 · 100 分，全部为客观题；
② 试卷右上角设有 「提交答卷」 与 「重置考试」 按钮，提交后系统自动判分并显示答题正确情况，请确认全部作答后再行提交；
③ 试卷不显示答案，提交后方可查看每题作答与正确答案的对照；
④ 答卷进度会保留在本地缓存中，刷新或再次打开仍可继续作答；
⑤ 本卷仅供学生练习使用；请勿用于其他用途；题面有问题请联系：i64coder@163.com。

判分报告

0 / 100 分

答对 · 得 0 分

答错 · 失 0 分

未作答

当前筛选下没有题目

壹

栈的概念与操作

6 QUESTIONS · 2 POINTS EACH

第 1 题 A1 未作答

栈这种数据结构的特点是（）。

（1 分）

随机存取

按关键字大小存取

后进先出

先进先出

第 2 题 A2 未作答

栈中允许插入和删除的一端称为（）。

（1 分）

栈顶

栈底

任意位置

中间元素

第 3 题 A3 未作答

栈 S 依次执行：push(1)、push(2)、push(3)、pop()、push(4)。此时栈中从栈底到栈顶的元素是（）。

（1 分）

2 3 4

1 2 4

1 2 3 4

1 3 4

第 4 题 A4 未作答

阅读下面的程序（top 指向栈顶元素）：

01int st[100], top = -1;
02st[++top] = 1;
03st[++top] = 2;
04cout << st[top];
05cout << st[top];

程序的输出是（）。

（1 分）

2 只输出一次

22

21

12

第 5 题 A5 未作答

数组实现的栈用 top = -1 表示栈空。pop 操作前应检查的条件是（）。

（1 分）

top > 0

top == 0

top < 100

top == -1

第 6 题 A6 未作答

某数据结构依次执行「压入 A、压入 B、弹出 B、压入 C」后，容器内从底到顶为 A、C。该数据结构是（）。

（1 分）

哈希表

队列

二叉搜索树

栈

贰

出栈序列

14 QUESTIONS · 2 POINTS EACH

第 7 题 B1 未作答

入栈顺序为 a, b, c, d, e，下列可能的出栈序列是（）。

（1 分）

b a e d c

a c e b d

c d a b e

a e d b c

第 8 题 B2 未作答

入栈顺序为 1, 2, 3, 4，若 4 个元素全部入栈后再依次出栈，出栈序列是（）。

（1 分）

2 1 4 3

1 2 3 4

4 3 2 1

1 4 3 2

第 9 题 B3 未作答

入栈顺序为 1, 2, 3，若每个元素入栈后立即出栈（进一个出一个），出栈序列是（）。

（1 分）

3 2 1

1 3 2

1 2 3

2 1 3

第 10 题 B4 未作答

6 个元素按 6, 5, 4, 3, 2, 1 的顺序进栈，下列非法的出栈序列是（）。

（1 分）

3 4 6 5 2 1

6 5 4 3 2 1

2 3 4 1 5 6

5 4 3 6 2 1

第 11 题 B5 未作答

3 个不同元素依次进栈（可随时出栈），可能的出栈序列共有（）种。

（1 分）

$6$

$5$

$4$

$3$

第 12 题 B6 未作答

入栈顺序 1, 2, 3, 4（按此顺序依次到达）。关于出栈序列，下列说法正确的是（）。

（1 分）

只有 4 3 2 1 一种

只有 1 2 3 4 一种

部分排列可能（如 1 2 3 4、4 3 2 1、2 1 4 3 等，但如 4 1 2 3 不可能）

$4! = 16$ 种排列都可能

第 13 题 B7 未作答

判断一个出栈序列是否合法的实用方法是（）。

（1 分）

看序列是否递减

模拟：按入栈序逐个压栈，栈顶等于目标就弹出，最后栈空则合法

数一下每个元素后面比它小的元素个数

看序列是否包含入栈序作为子序列

第 14 题 B8 未作答

入栈顺序为 1, 2, 3, 4, 5，下列不可能的出栈序列是（）。

（1 分）

3 4 2 5 1

4 3 5 1 2

4 5 3 2 1

5 4 3 2 1

第 15 题 B9 未作答

入栈顺序为 a, b, c, d, e，栈的容量为 3（同时最多存 3 个元素）。下列出栈序列中，因容量不足而不可能实现的是（）。

（1 分）

c d e b a

b c d e a

a b c d e

e d c b a

第 16 题 B10 未作答

3 个元素 e1, e2, e3 依次到达，每个元素按「进栈 S、出栈 S、进队列 Q、出队列 Q」处理，元素之间的操作可以交错。最终不同的出队列序列共有（）种。

（1 分）

$6$

$1$

$3$

$5$

第 17 题 B11 未作答

关于合法出栈序列的性质，下列说法正确的是（）。

（1 分）

出栈序列中任何元素后面比它小的元素必然递减排列

出栈序列本身就是入栈序列的某个循环移位

出栈序列中任意元素后面比它小的元素必须递增排列

出栈序列中不能有连续递减的三段

第 18 题 B12 未作答

入栈顺序为 1, 2, 3, 4, 5, 6，下列不可能的出栈序列是（）。

（1 分）

1 3 5 6 4 2

4 5 3 6 2 1

6 4 2 1 3 5

2 4 3 6 5 1

第 19 题 B13 未作答

4 个不同元素依次进栈（可随时出栈），可能的出栈序列共有（）种。

（1 分）

$24$

$16$

$10$

$14$

第 20 题 B14 未作答

入栈顺序为 a, b, c, d。若 a 是第一个出栈的元素，满足条件的出栈序列共有（）种。

（1 分）

$14$

$5$

$6$

$4$

叁

表达式转换

15 QUESTIONS · 2 POINTS EACH

第 21 题 C1 未作答

表达式 a*(b+c)*d 的后缀表达式是（）。

（1 分）

a b c + d * *

a b c + * d *

a b + c * d *

a * b c + * d

第 22 题 C2 未作答

后缀表达式 6 2 3 + - 3 8 2 / + * 对应的中缀表达式是（）。

（1 分）

6 - 2 + 3 * 3 + 8 / 2

(6 - 2 + 3) * (3 + 8) / 2

6 - (2 + 3) * (3 + 8 / 2)

(6 - (2 + 3)) * (3 + 8 / 2)

第 23 题 C3 未作答

表达式 a+(b-c)*d 的前缀表达式是（）。

（1 分）

a b c - d * +

+ * a - b c d

+ a * - b c d

a + b - c * d

第 24 题 C4 未作答

后缀表达式 3 4 + 2 * 的值是（）。

（1 分）

$14$

$18$

$24$

$11$

第 25 题 C5 未作答

前缀表达式 * + 3 4 2 的值是（）。

（1 分）

$14$

$24$

$10$

$11$

第 26 题 C6 未作答

后缀表达式（逆波兰式）的最大优点是（）。

（1 分）

不需要知道运算符优先级就能算——因为它按运算顺序直接排列，无需括号

书写最短

人人易读

按运算顺序直接排列，无需括号和优先级

第 27 题 C7 未作答

中缀表达式 (a+b)*c 转成后缀时，括号（）。

（1 分）

保留为特殊符号

转换为优先级标记

消失（运算顺序已体现在排列中）

转移到运算符前

第 28 题 C8 未作答

后缀表达式 a b c + * 对应的前缀表达式是（）。

（1 分）

* + a b c

+ a * b c

a b c + *

* a + b c

第 29 题 C9 未作答

用运算符栈把中缀 a + b * c 转后缀，读到 * 时（a、+、b 已处理），运算符栈从底到顶是（）。

（1 分）

+

空

+ *

* +

第 30 题 C10 未作答

双栈法求中缀表达式的值时，读到新运算符，若其优先级高于栈顶运算符，正确的做法是（）。

（1 分）

先弹出栈顶运算符计算，再入栈

丢弃新运算符

直接把新运算符入栈（等更高优先级或结束时再算）

把栈中运算符全部弹出计算

第 31 题 C11 未作答

把中缀表达式 (a+b)*c 画成一棵表达式树（操作数在叶、运算符在内点），对该树做后序遍历得到的是（）。

（1 分）

前缀表达式

中缀表达式

括号表达式

后缀表达式

第 32 题 C12 未作答

表达式 a+b*c-(d/e+f)*g 的后缀表达式是（）。

（1 分）

a b c * + d e / f + g * -

a b c * + d e f + / * g -

a b + c * d e / f + g * -

a b c * + d e / f + * -

第 33 题 C13 未作答

前缀表达式 * + a b - c d 对应的中缀表达式是（）。

（1 分）

a + b * c - d

(a + b) * (c - d)

(a - b) * (c + d)

(a + b) * c - d

第 34 题 C14 未作答

后缀表达式 7 2 3 * - 的值是（）。

（1 分）

$19$

$11$

$-19$

$1$

第 35 题 C15 未作答

前缀表达式又称（），后缀表达式又称（）。

（1 分）

中缀式、前缀式

波兰式、逆波兰式

逆波兰式、波兰式

波兰式、中缀式

肆

队列

13 QUESTIONS · 2 POINTS EACH

第 36 题 D1 未作答

队列的特点是（）。

（1 分）

两端都可进出且等价

后进先出

先进先出

按值大小有序

第 37 题 D2 未作答

队列中允许删除的一端是（），允许插入的一端是（）。

（1 分）

队头、队尾

两端都行

中间、队尾

队尾、队头

第 38 题 D3 未作答

空队列依次执行 push(1)、push(2)、push(3)、pop()、push(4) 后（push 表示入队），从队头到队尾的元素是（）。

（1 分）

1 2 3 4

1 3 4

2 3 4

4 3 2

第 39 题 D4 未作答

元素 1, 2, 3 依次入队（只入队出队，无其他操作），出队序列是（）。

（1 分）

3 2 1

取决于实现

2 1 3

1 2 3

第 40 题 D5 未作答

容量为 $5$ 的循环队列（数组下标 $0\sim4$ ），rear = 4 时再入队一个元素，新的 rear 是（）。

（1 分）

$5$

$0$

$1$

$4$

第 41 题 D6 未作答

容量为 $n$ 的循环队列用 (rear + 1) % n == front 判满时，实际最多能存（）个元素。

（1 分）

$n$

$n + 1$

$n - 1$

$2n$

第 42 题 D7 未作答

容量为 $8$ 的循环队列（下标 $0\sim7$ ），当前 front = 2、rear = 5。执行 2 次出队、3 次入队后，front 和 rear 分别是（）。

（1 分）

front = 4、rear = 1

front = 4、rear = 0

front = 5、rear = 0

front = 4、rear = 8

第 43 题 D8 未作答

循环队列判空可以用 front == rear，也可以用一个 size 计数器。前一种方案的特点是（）。

（1 分）

只适用于链式存储

不用牺牲存储单元

少维护一个变量，但要牺牲一个存储单元区分满与空

判满判空写法完全相同

第 44 题 D9 未作答

$5$ 个人编号 $1\sim5$ 围成一圈，从 $1$ 号开始报数，报到 $3$ 的人出圈，用队列模拟。出圈的顺序是（）。

（1 分）

3 5 1 2 4

3 1 5 4 2

3 1 5 2 4

1 4 2 5 3

第 45 题 D10 未作答

广度优先搜索（BFS）逐层扩展节点时使用队列而不是栈，原因是（）。

（1 分）

先发现的节点应先被扩展，队列的先进先出恰好保证"同层先处理"

队列出队更快

栈无法存储节点编号

队列内存占用更小

第 46 题 D11 未作答

双端队列（deque）与普通队列的区别是（）。

（1 分）

两端都可以进行插入和删除

没有区别

中间也可以插入

只能从队尾插入

第 47 题 D12 未作答

输入序列 1, 2, 3, 4, 5，全部进入容器后再全部取出：经过栈的输出是（），经过队列的输出是（）。

（1 分）

1 2 3 4 5、5 4 3 2 1

5 4 3 2 1、1 2 3 4 5

两者都是 1 2 3 4 5

两者都是 5 4 3 2 1

第 48 题 D13 未作答

阅读下面的程序：

01int q[100], front = 0, rear = 0;
02while (front != rear) {
03    cout << q[front] << " ";
04    front = (front + 1) % 100;
05}

若循环队列当前为空，该循环的执行情况是（）。

（1 分）

输出一个垃圾值后停止

一次也不执行（front == rear 立即成立）

输出 100 个 0

死循环

伍

栈队列综合

12 QUESTIONS · 2 POINTS EACH

第 49 题 E1 未作答

栈和队列的共同点是（）。

（1 分）

都必须用数组实现

出入顺序相同

都只能在一端操作

都是操作受限的线性结构，插入删除都在特定端进行

第 50 题 E2 未作答

「编辑器的撤销操作」和「打印任务排队」分别适合用（）实现。

（1 分）

都是队列

都是栈

队列、栈

栈、队列

第 51 题 E3 未作答

用两个栈 S1（入）和 S2（出）模拟队列，元素 1, 2, 3 依次入 S1 后，要取出队头元素 1 的操作是（）。

（1 分）

无法模拟

把 S1 全部弹出压入 S2，再从 S2 弹出

从 S1 弹出 3 个取最后一个

直接从 S1 弹出

第 52 题 E4 未作答

用队列模拟栈的 pop 操作（栈顶出），需要（）。

（1 分）

用取模运算定位栈顶

从队尾出队（若链式实现）

直接从队头出队

把前 $n-1$ 个元素依次出队再入队，最后出队剩下的那个

第 53 题 E5 未作答

栈 S 和队列 Q 初始为空。元素 e1, e2, e3, e4 依次执行「进 S、出 S、进 Q、出 Q」且各元素操作不交错。最终出 Q 的序列是（）。

（1 分）

e4 e3 e2 e1

e2 e4 e1 e3

不确定

e1 e2 e3 e4

第 54 题 E6 未作答

初始空的整数栈 S 和队列 P，依次处理输入 7, 5, 8, 3：奇数压入 S、偶数入 P。处理完后先弹出 S 的全部（从栈顶往下）再输出 P 的全部（从队头往后），得到的序列是（）。

（1 分）

7 5 3 8

8 3 5 7

3 5 7 8

5 7 3 8

第 55 题 E7 未作答

下列关于数据结构的表述中，不恰当的是（）。

（1 分）

栈和队列都可以用数组和链表实现

栈的进出端和队列的进出端都可以任意选择

队列是先进先出的线性表

栈是后进先出的线性表

第 56 题 E8 未作答

用栈 S1（入队）和 S2（出队）模拟队列：1, 2, 3 已压入 S1，此时执行一次出队（把 S1 倒入 S2 后弹出 1）。新元素 4 此时应压入（）。

（1 分）

S2

先压 S2 再倒回 S1

S1（保持"入队永远进 S1"的纪律）

两个都可以，效果相同

第 57 题 E9 未作答

用队列模拟栈的 pop 操作，需要把前 $n-1$ 个元素转移，单次 pop 的时间代价是（）。

（1 分）

$O(n)$

$O(n^2)$

$O(1)$

$O(\log n)$

第 58 题 E10 未作答

输入序列 1, 2, 3, 4, 5 经过一个栈（可随时进出）后得到输出序列。下列输出序列中无法实现的是（）。

（1 分）

4 5 3 1 2

2 1 5 4 3

1 2 3 4 5

4 5 3 2 1

第 59 题 E11 未作答

输入序列 a, b, c 经过某个容器后输出 c, b, a；同样的输入经过另一个容器输出 a, b, c。这两个容器分别是（）。

（1 分）

都是队列

栈、队列

队列、栈

都是栈

第 60 题 E12 未作答

输入序列 1, 2, 3, 4，要得到输出 1 2 4 3。下列判断正确的是（）。

（1 分）

两者都不能实现

用队列可以实现，用栈不能

用一个栈可以实现（1 进即出、2 进即出、3 4 进后 4 先出），用队列不能（队列只能保序）

两者都能实现

陆

代码阅读

16 QUESTIONS · 2 POINTS EACH

第 61 题 F1 未作答

阅读下面的程序：

01int st[100], top = -1;
02void push(int x) {
03    st[++top] = x;
04}
05push(1); push(2); push(3);
06cout << top;

程序的输出是（）。

（1 分）

100

-1

2

1

第 62 题 F2 未作答

阅读下面的程序：

01int st[100], top = 2;   // 栈中已有 3 个元素
02int x = st[top--];
03cout << x << " " << top;

程序的输出是（）。

（1 分）

1 2

2 1

2 2

2 3

第 63 题 F3 未作答

阅读下面的程序：

01int q[100], head = 0, tail = 0;   // tail 指向队尾下一个空位
02q[tail++] = 10;
03q[tail++] = 20;
04int x = q[head++];
05cout << x << " " << tail - head;

程序的输出是（）。

（1 分）

10 2

10 1

20 1

10 0

第 64 题 F4 未作答

容量为 $10$ 的循环队列，front = 3、rear = 7（rear 指向队尾下一空位），当前队列中的元素个数是（）。

（1 分）

$10$

$7$

$-4$

$4$

第 65 题 F5 未作答

阅读下面的程序（判断括号序列是否匹配）：

01bool match(string s) {
02    stack<char> st;
03    for (char c : s) {
04        if (c == '(') st.push(c);
05        else if (c == ')' && !st.empty()) st.pop();
06        else if (c == ')') return false;
07    }
08    return st.empty();
09}

调用 match("(()") 的返回值是（）。

（1 分）

死循环

true

编译错误

false

第 66 题 F6 未作答

阅读下面的程序（后缀表达式求值）：

01stack<int> st;
02int a = 3, b = 4, c = 2;
03st.push(a); st.push(b); st.push(c);
04int x = st.top(); st.pop();
05int y = st.top(); st.pop();
06st.push(x * y);
07int z = st.top(); st.pop();
08int w = st.top(); st.pop();
09st.push(z + w);
10cout << st.top();

程序的输出是（）。

（1 分）

$11$

$24$

$10$

$14$

第 67 题 F7 未作答

C++ STL 中，栈和队列对应的容器适配器分别是（）。

（1 分）

stack<int>、queue<int>

vector、list

stack、queue 都是基础容器

set、map

第 68 题 F8 未作答

阅读下面的程序（中缀转后缀，操作数为小写字母）：

01string toPost(string s) {
02    stack<char> op;  string out;
03    for (char c : s) {
04        if (isalpha(c)) out += c;
05        else if (c == '(') op.push(c);
06        else if (c == ')') {
07            while (op.top() != '(') { out += op.top(); op.pop(); }
08            op.pop();
09        } else {
10            while (!op.empty() && prio(op.top()) >= prio(c)) {
11                out += op.top(); op.pop();
12            }
13            op.push(c);
14        }
15    }
16    while (!op.empty()) { out += op.top(); op.pop(); }
17    return out;
18}

处理运算符 c 时 while 弹栈（条件 prio(op.top()) >= prio(c)）的作用是（）。

（1 分）

只在遇括号时才执行

保证栈中不低于 c 优先级的运算符先输出（维持后缀中运算的先后）

没有作用，可以删掉

保证低优先级运算符先输出

第 69 题 F9 未作答

阅读下面的完整程序（把后缀表达式转换成中缀表达式）：

01#include <iostream>
02#include <stack>
03#include <string>
04using namespace std;
05
06int main() {
07    string post = "xy+z*";   // 后缀表达式，操作数为字母
08    stack<string> st;
09    for (char c : post) {
10        if (c == '+' || c == '*') {
11            string b = st.top(); st.pop();  // 先弹出
12            string a = st.top(); st.pop();  // 后弹出
13            st.push("(" + a + c + b + ")");
14        } else {
15            st.push(string(1, c));
16        }
17    }
18    cout << st.top();
19    return 0;
20}

程序运行到处理字符 * 的那一刻，变量 b 和 a 的值分别是（）。

（1 分）

b = "x"、a = "y"

b = "y"、a = "x"

b = "(x+y)"、a = "z"

b = "z"、a = "(x+y)"

第 70 题 F10 未作答

阅读下面的程序（双栈求中缀值，个位数字，运算符 + - *，prio('*') > prio('+') = prio('-')）：

01int calc(string s) {
02    stack<int> num;  stack<char> op;
03    auto doOp = [&]() {
04        int b = num.top(); num.pop();
05        int a = num.top(); num.pop();
06        num.push(op.top() == '+' ? a + b :
07                 op.top() == '*' ? a * b : a - b);
08        op.pop();
09    };
10    for (char c : s) {
11        if (isdigit(c)) num.push(c - '0');
12        else {
13            while (!op.empty() && prio(op.top()) >= prio(c)) doOp();
14            op.push(c);
15        }
16    }
17    while (!op.empty()) doOp();
18    return num.top();
19}

calc("2+3*4") 的返回值是（）。

（1 分）

$14$

$20$

$5$

$11$

第 71 题 F11 未作答

阅读下面的程序：

01stack<int> s;
02s.push(1); s.push(2); s.pop();
03s.push(3); s.push(4);
04cout << s.top() << " " << s.size();

程序的输出是（）。

（1 分）

4 4

4 3

3 4

2 3

第 72 题 F12 未作答

阅读下面的程序：

01queue<int> q;
02q.push(1); q.push(2); q.pop();
03q.push(3);
04cout << q.front() << " " << q.back();

程序的输出是（）。

（1 分）

3 2

2 1

2 3

1 3

第 73 题 F13 未作答

链栈（用单链表头做栈顶）的 push 操作，正确的步骤是（）。

（1 分）

node->next = top; top = node;

node->next = top->next; top = node;

top->next = node; top = node;

node->next = NULL; top = node;

第 74 题 F14 未作答

补全下面的循环队列入队代码（容量 m）：

01void enqueue(int x) {
02    q[rear] = x;
03    ____;
04}

横线处应填（）。

（1 分）

rear = (rear + 1) % (m + 1)

front = (front + 1) % m

rear = (rear + 1) % m

rear++

第 75 题 F15 未作答

补全括号匹配代码（检测小括号）：

01bool match(string s) {
02    stack<char> st;
03    for (char c : s) {
04        if (c == '(') st.push(c);
05        else if (c == ')') {
06            if (____) return false;
07            st.pop();
08        }
09    }
10    return st.empty();
11}

横线处应填（）。

（1 分）

st.top() == ')'

st.size() == 1

c == '('

st.empty()

第 76 题 F16 未作答

阅读下面的程序（用栈输出 x 的二进制）：

01int x = 6;
02stack<int> st;
03while (x > 0) { st.push(x % 2); x /= 2; }
04while (!st.empty()) { cout << st.top(); st.pop(); }

程序的输出是（）。

（1 分）

011

110

0110

6

柒

易错

6 QUESTIONS · 2 POINTS EACH

第 77 题 G1 未作答

数组栈有两种常见实现约定：

约定一：top 指向栈顶元素，空栈时 top = -1；
约定二：top 指向栈顶的下一个空位，空栈时 top = 0。

两种约定各自合法。下列 push / pop 的配对全部正确的是（）。

（1 分）

约定一 push: st[++top] = x、pop: st[top--]；约定二 push: st[top++] = x、pop: st[--top]

两种约定的 pop 都写 st[top--]

约定一 push: st[top++] = x、pop: st[--top]；约定二 push: st[++top] = x、pop: st[top--]

两种约定的 push 都写 st[top++] = x

第 78 题 G2 未作答

对空栈执行 pop() 且代码没有判空保护，结果是（）。

（1 分）

读/写下标越界（top 变 -1 等），行为未定义

自动跳过

返回 0

抛出异常

第 79 题 G3 未作答

循环队列判满 (rear + 1) % n == front 与判空 front == rear 会冲突吗？最常用的解决方案是（）。

（1 分）

不会冲突，两者恒不同

每次判满前清空队列

用额外的 -1 标记空

牺牲一个存储单元区分：判满时 front 在 rear 的下一格

第 80 题 G4 未作答

顺序队列 head（front）和 tail（rear）的移动规则是（）。

（1 分）

head 随出队后移、tail 随入队后移

head 入队、tail 出队

head、tail 都指向同一元素

都只增不减

第 81 题 G5 未作答

容量 100 的顺序队列，经历多次入队出队后 front = tail = 100（数组末尾），虽然中间位置全空却无法再入队。这种现象叫（）。

（1 分）

真溢出

假溢出（解决：改用循环队列）

内存泄漏

栈溢出

第 82 题 G6 未作答

不用循环结构时，顺序队列出队操作的另一种实现是（）。

（1 分）

从队尾删除

删除数组第一个元素（其余前移一位）

无法实现

出队后把剩余元素整体前移（代价 $O(n)$ ，故实际多用循环队列）

捌

括号匹配

6 QUESTIONS · 2 POINTS EACH

第 83 题 H1 未作答

下列括号序列中，完全匹配（合法）的是（）。

（1 分）

()()

()(

(()

())(

第 84 题 H2 未作答

括号序列 ((())) 在栈法匹配过程中，栈的最大高度（最大嵌套深度）是（）。

（1 分）

$3$

$1$

$6$

$2$

第 85 题 H3 未作答

下列序列中，多种括号匹配正确的是（）。

（1 分）

[(])

([)]

((]

([])

第 86 题 H4 未作答

括号序列 ((() 至少再添加（）个括号才能变成完全匹配。

（1 分）

$0$

$3$

$2$

$1$

第 87 题 H5 未作答

$3$ 对括号能组成的合法括号序列共有（）种。

（1 分）

$3$

$20$

$5$

$6$

第 88 题 H6 未作答

用栈法处理括号序列 (()())，处理完全部字符后栈的状态是（）。

（1 分）

剩 $1$ 个 (

剩 $2$ 个 (

不确定

空（完全匹配）

玖

栈队列与其他知识的联系

6 QUESTIONS · 2 POINTS EACH

第 89 题 I1 未作答

函数 f 调用 g、g 调用 h。关于返回顺序，正确的是（）。

（1 分）

顺序不确定

h 先返回，然后 g，最后 f（函数调用栈后进先出）

f 先返回

同时返回

第 90 题 I2 未作答

递归函数 f(3) 依次调用 f(2)、f(1)。递归最深时，函数调用栈中 f 的活动记录有（）层。

（1 分）

$3$

$1$

$2$

$4$

第 91 题 I3 未作答

深度优先搜索（DFS）和广度优先搜索（BFS）分别主要借助（）实现。

（1 分）

都是队列

栈、队列

都是栈

队列、栈

第 92 题 I4 未作答

BFS 从起点出发逐层向外扩展：第 1 层的邻居先处理完，才会处理第 2 层。保证这种"层次顺序"的数据结构特性是（）。

（1 分）

后进先出

先进先出（先发现的先扩展）

按值排序

随机顺序

第 93 题 I5 未作答

用栈判断字符串 abba 是否回文：把前一半 ab 压栈，再逐个扫描后一半与弹出的元素比对。比对结果是（）。

（1 分）

第 1 次比对 a 与 b（扫到 b 弹出 b），第 2 次比对 b 与 a——不等，判定不是回文（方法错误）

栈法不能判断回文

两次都相等，是回文

只需比对一次

第 94 题 I6 未作答

字符串 abc 的每个字符依次入栈，然后全部弹出输出，得到的是（）。

（1 分）

abc

acb

bca

cba

拾

综合难题

6 QUESTIONS · 2 POINTS EACH

第 95 题 J1 未作答

元素按 3, 1, 2 的顺序依次到达栈。仅借助这个栈，得到输出 1 2 3 的操作序列是（）。

（1 分）

不可能实现

3 入栈即出、1 入栈即出、2 入栈即出

3 入栈、1 入栈即出、2 入栈即出、3 出栈

三个全入再全出

第 96 题 J2 未作答

初始空的栈 S 和队列 P，依次处理 7, 5, 8, 3, 1, 4, 2：奇数压入 S、偶数入 P。全部处理完后先弹尽 S（从栈顶）再出尽 P（从队头），输出序列是（）。

（1 分）

7 5 3 1 8 4 2

8 4 2 7 5 3 1

1 3 5 7 2 4 8

1 3 5 7 8 4 2

第 97 题 J3 未作答

对初始空栈依次执行：push 1、push 2、push 3、pop、push 4、push 5、pop、pop、push 6。此时栈中从栈底到栈顶是（）。

（1 分）

1 2 6

1 2 3 6

1 6

1 2 4 6

第 98 题 J4 未作答

用队列模拟栈时，push 操作的正确做法及其代价是（）。

（1 分）

需要先转移元素， $O(n)$

直接把元素入队， $O(1)$

需要排序， $O(n \log n)$

需要两个队列同时操作， $O(n)$

第 99 题 J5 未作答

两个栈共享一个长度为 $m$ 的数组：栈 1 的 top1 从 $-1$ 向右增长，栈 2 的 top2 从 $m$ 向左增长。判"栈满"的条件是（）。

（1 分）

top1 + 1 == top2

top1 == m - 1 && top2 == 0

top1 == top2

top1 + top2 == m

第 100 题 J6 未作答

双栈法求中缀表达式的值（含括号，括号优先级最高）。表达式 (2+3)*4 的值是（）。

（1 分）

$24$

$14$

$20$

$11$

拾壹

真题演练

11 QUESTIONS · 真题演练不计分

第 102~107 题阅读程序（共 0 分）未作答

1  #include <cstdio>
2  #include <cstring>
3  using namespace std;
4  char st[100];
5  int main() {
6      scanf("%s", st);
7      int n = strlen(st);
8      for (int i = 1; i <= n; ++i) {
9          if (n % i == 0) {
10              char c = st[i - 1];
11              if (c >= 'a')
12                  st[i - 1] = c - 'a' + 'A';
13          }
14      }
15      printf("%s", st);
16      return 0;
17  }

102.

输入的字符串只能由小写字母或大写字母组成。（）

正确

错误

103.

若将第 $8$ 行的 i = 1 改为 i = 0，程序运行时会发生错误。（）

正确

错误

104.

若将第 $8$ 行的 i <= n 改为 i * i <= n，程序运行结果不会改变。（）

正确

错误

105.

若输入的字符串全部由大写字母组成，那么输出的字符串就跟输入的字符串一样。（）

正确

错误

106.

若输入的字符串长度为 $18$ ，那么输入的字符串跟输出的字符串相比，至多有（）个字符不同。

$18$

$10$

$6$

$1$

107.

若输入的字符串长度为（），那么输入的字符串跟输出的字符串相比，至多有 $36$ 个字符不同。

$36$

$1$

$128$

$100000$

CSP-J 2019 · 阅读程序第16-21题｜知识点字符数组、字符ASCII运算、枚举

第 7 题单选未作答

下图中所使用的数据结构是（）。图示依次执行“压入 A、压入 B、弹出 B、压入 C”。

（0 分）

栈

队列

二叉树

哈希表

CSP-J 2020 · 单选第11题｜知识点栈、栈的应用

第 8 题单选未作答

对于入栈顺序为 a, b, c, d, e 的序列，下列（）不是合法的出栈序列。

（0 分）

a, b, c, d, e

e, d, c, b, a

b, a, c, d, e

c, d, a, e, b

CSP-J 2021 · 单选第5题｜知识点栈、栈的应用

第 9 题单选未作答

表达式 a*(b+c)*d 的后缀表达式为（），其中 * 和 + 是运算符。

（0 分）

**a+bcd

abc+*d*

abc+d**

*a*+bcd

CSP-J 2021 · 单选第9题｜知识点栈的应用、栈

第 10 题单选未作答

有 $6$ 个元素，按照 $6$ 、 $5$ 、 $4$ 、 $3$ 、 $2$ 、 $1$ 的顺序进入栈 S，请问下列哪个出栈序列是非法的（）。

（0 分）

5 4 3 6 1 2

4 5 3 1 2 6

3 4 6 5 2 1

2 3 4 1 5 6

CSP-J 2022 · 单选第2题｜知识点栈、栈的应用

第 11 题单选未作答

对假设栈 S 和队列 Q 的初始状态为空。存在 e1~e6 六个互不相同的数据，每个数据按照进栈 S、出栈 S、进队列 Q、出队列 Q 的顺序操作，不同数据间的操作可能会交错。已知栈 S 中依次有数据 e1、e2、e3、e4、e5 和 e6 进栈，队列 Q 依次有数据 e2、e4、e3、e6、e5 和 e1 出队列。则栈 S 的容量至少是（）个数据。

（0 分）

$2$

$3$

$4$

$6$

CSP-J 2022 · 单选第5题｜知识点栈、队列、模拟

第 12 题单选未作答

对表达式 a+(b-c)*d 的前缀表达式为（），其中 +、-、* 是运算符。

（0 分）

*+a-bcd

+a*-bcd

abc-d*+

abc-+d

CSP-J 2022 · 单选第6题｜知识点栈的应用、栈

第 13 题单选未作答

以下对数据结构的表述不恰当的一项为：（）。

（0 分）

图的深度优先遍历算法常使用的数据结构为栈。

栈的访问原则为后进先出，队列的访问原则是先进先出。

队列常常被用于广度优先搜索算法。

栈与队列存在本质不同，无法用栈实现队列。

CSP-J 2022 · 单选第10题｜知识点栈、队列、图的DFS遍历

第 14 题单选未作答

后缀表达式 6 2 3 + - 3 8 2 / + * 2 ^ 3 + 对应的中缀表达式是（）。

（0 分）

$((6 - (2 + 3)) * (3 + 8 / 2)) ^ 2 + 3$

$6 - 2 + 3 * 3 + 8 / 2 ^ 2 + 3$

$(6 - (2 + 3)) * ((3 + 8 / 2) ^ 2) + 3$

$6 - ((2 + 3) * (3 + 8 / 2)) ^ 2 + 3$

CSP-J 2023 · 单选第8题｜知识点栈的应用、栈

第 15 题单选未作答

给定一个空栈，支持入栈和出栈操作。若入栈操作的元素依次是 1 2 3 4 5 6，其中 1 最先入栈、6 最后入栈，下面哪种出栈顺序是不可能的？（）

（0 分）

6 5 4 3 2 1

1 6 5 4 3 2

2 4 6 5 3 1

1 3 5 2 4 6

CSP-J 2024 · 单选第13题｜知识点栈、栈的应用

第 16 题单选未作答

给定一个初始为空的整数栈 $S$ 和一个空的队列 $P$ 。我们按顺序处理输入的整数队列 $A: 7, 5, 8, 3, 1, 4, 2$ 。对于队列 $A$ 中的每一个数，执行以下规则：如果该数是奇数，则将其压入栈 $S$ ；如果该数是偶数，且栈 $S$ 非空，则弹出一个栈顶元素，并加入到队列 $P$ 的末尾；如果该数是偶数，且栈 $S$ 为空，则不进行任何操作。当队列 $A$ 中的所有数都处理完毕后，队列 $P$ 的内容是什么？（）

（0 分）

5, 1, 3

7, 5, 3

3, 1, 5

5, 1, 3, 7

CSP-J 2025 · 单选第15题｜知识点栈、双端队列、泛洪算法

重置作答

专题 05 栈与队列 · 复习强化

判 分 报 告

栈的概念与操作

出栈序列

表达式转换

队列

栈队列综合

代码阅读

易错

括号匹配

栈队列与其他知识的联系

综合难题

真 题 演 练

打印

导出 HTML 子卷

判分报告

真题演练