挑战你的数据结构技能：复习题来袭【3】

chap3 练习1

一. 单选题

1. (单选题)栈和队列具有相同的（）

• A. 抽象数据类型
• B. 逻辑结构
• C. 存储结构
• D. 运算

答案: B:逻辑结构

答案分析：逻辑结构都属于线性结构,只是它们对数据的运算不同。

2. (单选题)栈是()

• A. 顺序存储的线性结构
• B. 链式存储的非线性结构
• C. 限制存取点的线性结构
• D. 限制存储点的非线性结构

答案: C:限制存取点的线性结构

答案分析：首先是线性结构，其次按存储结构不同可分为顺序栈和链栈

3. (单选题)（）不是栈的基本操作

• A. 删出栈顶元素
• B. 删除栈底元素
• C. 判断栈是否为空
• D. 将栈置为空栈

答案: B:删除栈底元素;

答案分析：栈先进后出

A. 删出栈顶元素（出栈操作）

C. 判断栈是否为空（检查栈是否为空）

D. 将栈置为空栈（清空栈）

但是，删除栈底元素并不是栈的基本操作，因为栈只能对栈顶进行操作，即只能删除栈顶元素。

4. (单选题)假定利用数组a[n]顺序存储一个栈，用top表示栈顶指针，用top==-1表示栈空，并已知栈未满，当元素x进栈时所执行的操作为(   )

• A. a[--top]=x
• B. a[top--]=x
• C. a[++top]=x
• D. a[top++]=x

答案: C:a[++top]=x;

答案分析：在数组实现的栈中，top 表示栈顶元素的索引。

当元素 x 进栈时，需要先将 top 加 1（即 ++top），然后将 x 存储在数组的该位置上（即 a[++top] = x）。

这样，top 就指向新的栈顶位置，而 x 也成功地进栈了。

5. (单选题)

设有一个空栈，栈顶指针为1000H，每个元素需要一个存储单元，执行push，push，pop，push，pop，push，pop，push操作后，栈顶指针的值为(   )

• A. 1002H
• B. 1003H
• C. 1004H
• D. 1005H

答案: A:1002H;

答案分析：每个元素需要1个存储单元，每入栈(push)一次top+1,每出栈(pop)一次top-1，指针top的值加来减去，得1002H。

6. (单选题)

和顺序栈相比，链栈有一个比较明显的优势，即（ ）

• A. 通常不会出现栈满的情况
• B. 通常不会出现栈空的情况
• C. 插入操作更容易实现
• D. 删出操作更容易实现

答案:A.通常不会出现栈满的情况

答案分析：顺序栈采用数组存储，数组的大小固定，不能动态分配大小

链表可以动态地分配存储空间。

7. (单选题)设链表不带头结点且所有操作均在表头进行，则下列最不适合作为链栈的是（  ）

• A. 只有表头结点指针，没有表尾指针的双向循环链表
• B. 只有表尾节点指针，没有表头指针的双向循环链表
• C. 只有表头指针，没有表尾指针的单向循环链表
• D. 只有表尾结点指针，没有表头指针的单向循环链表。

答案:C.只有表头指针，没有表尾指针的单向循环链表

答案分析：对于双向循环链表，不管是表头指针还是表尾指针，都方便在表头做插入或删除操作。

单循环链表通过尾指针可以很方便地找到表头结点，但通过头指针找尾节点需要遍历一次链表。

8. (单选题)向一个栈顶指针为top的链栈中插入一个x结点，则执行（ ）

• A. top-->next=x
• B. x->next=top->next;top->next=x
• C. x->next=top;top=x
• D. x->next=top;top=top->next

答案:C:x->next=top;top=x

答案分析：

链栈的插入操作需要将新节点 x 插入到栈顶，并更新栈顶指针 top 使其指向新节点 x。具体步骤如下：

1. 设置新节点 x 的 next 指针指向当前的栈顶节点，即 x->next = top。
2. 更新栈顶指针 top 使其指向新节点 x，即 top = x。

这样，x 就成为了新的栈顶节点。

9. (单选题)链栈执行Pop操作，并将出栈的元素存在x中，应该执行（ ）

• A. x=top；top=top->next
• B. x=top->data
• C. top=top->next;x=top->data
• D. x=top->data;top=top->next

答案:D:x=top->data;top=top->next

答案分析：

Pop 操作的步骤如下：

1. 取得当前栈顶节点的数据，即 x = top->data。
2. 更新栈顶指针 top，使其指向原栈顶节点的下一个节点，即 top = top->next。

这样，出栈操作就完成了，同时 x 中存储了出栈的元素。

10. (单选题)

经过以下栈的操作后，变量x的值为（  ）

• A. a
• B. b
• C. NULL
• D. FALSE

答案:A:a

答案分析：

逐步分析变量 x 的值：

1. Initstack(st); 初始化栈 st。
2. Push(st,a); 将元素 a 压入栈中。
3. Push(st,b); 将元素 b 压入栈中。此时栈顶元素为 b。
4. Pop(st,x); 将栈顶元素弹出，并赋值给变量 x。因此，x 的值为 b。
5. Top(st,x); 再次将栈顶元素赋值给 x。由于 b 已经被弹出，现在栈顶元素是 a。

11. (单选题)3个不同元素一次进栈，能得到（ ）种不同的出栈序列

• A. 4
• B. 5
• C. 6
• D. 7

答案:B:5

答案分析：

可以通过列举所有可能的出栈序列来验证这个结论。假设元素为 A、B、C，按照它们的入栈顺序为：

1. A B C
2. A C B
3. B A C
4. B C A
5. C B A

12. (单选题)设a，b，c，d，e，f以所给的次序进栈，若进栈操作时，允许出栈操作，则下面得不到的序列为（  ）

• A. fedcba
• B. bcafed
• C. dcefba
• D. cabdef

答案:D:cabdef

答案分析：

模拟栈的操作:假设元素以 a, b, c, d, e, f 的顺序进栈，我们检查每个选项的可能性：

1. fedcba:

   • 进栈 a, b, c, d, e, f。
   • 按顺序出栈 f, e, d, c, b, a。
   • 这是可能的序列。

2. bcafed:

   • 进栈 a, b。
   • 出栈 b。
   • 进栈 c。
   • 出栈 c。
   • 出栈 a。
   • 进栈 d, e, f。
   • 按顺序出栈 f, e, d。
   • 这是可能的序列。

3. dcefba:

   • 进栈 a, b, c, d。
   • 出栈 d。
   • 进栈 e。
   • 出栈 e。
   • 进栈 f。
   • 出栈 f。
   • 出栈 c, b, a。
   • 这是可能的序列。

4. cabdef:

   • 进栈 a。
   • 进栈 b。
   • 进栈 c。
   • 出栈 c。
   • 出栈 b。
   • 出栈 a。
   • 进栈 d, e, f。
   • 按顺序出栈 f, e, d。

这是 不可能的 序列，因为 c 出栈之前，b 和 a 必须都在栈中，而序列要求 b 先出栈。

13. (单选题)用S表示进栈操作，用X表示出栈操作，若元素的进栈顺序是1234，为了得到1342的出栈顺序，相应的S和X的操作序列为（  ）

• A. SXSXSSXX
• B. SSSXXSXX
• C. SXSSXXSX
• D. SXSSXSXX

答案:D:SXSSXSXX

答案分析：

为了得到出栈顺序 1342，相应的 S 和 X 的操作序列应该是：

1. 进栈 1（S）
2. 出栈 1（X）
3. 进栈 2（S）
4. 进栈 3（S）
5. 出栈 3（X）
6. 进栈 4（S）
7. 出栈 4（X）
8. 出栈 2（X）

14. (单选题)

若元素a，b，c，d，e，f一次进栈，允许进栈、退栈操作交替进行，但不允许连续3次进行退栈操作，不可能得到的出栈序列是（  ）

• A. dcefa
• B. cbdaef
• C. bcaefd
• D. afedcb

答案:D:afedcb

答案分析：

模拟栈的操作并考虑约束条件：

A. dcefa

1. 进栈 a (S)
2. 进栈 b (S)
3. 进栈 c (S)
4. 进栈 d (S)
5. 出栈 d (X)
6. 进栈 e (S)
7. 出栈 c (X)
8. 出栈 e (X)
9. 进栈 f (S)
10. 出栈 f (X)
11. 出栈 a (X)

这是可能的，因为没有连续3次退栈操作。

B. cbdaef

1. 进栈 a (S)
2. 进栈 b (S)
3. 进栈 c (S)
4. 出栈 c (X)
5. 出栈 b (X)
6. 进栈 d (S)
7. 出栈 d (X)
8. 进栈 e (S)
9. 出栈 a (X)
10. 进栈 f (S)
11. 出栈 e (X)
12. 出栈 f (X)

这是可能的，因为没有连续3次退栈操作。

C. bcaefd

1. 进栈 a (S)
2. 进栈 b (S)
3. 出栈 b (X)
4. 进栈 c (S)
5. 出栈 c (X)
6. 进栈 d (S)
7. 进栈 e (S)
8. 出栈 a (X)
9. 出栈 e (X)
10. 出栈 f (X)

这是可能的，因为没有连续3次退栈操作。

D. afedcb

1. 进栈 a (S)
2. 进栈 b (S)
3. 进栈 c (S)
4. 进栈 d (S)
5. 进栈 e (S)
6. 进栈 f (S)
7. 出栈 f (X)
8. 出栈 e (X)
9. 出栈 d (X)

此时无法继续，因为下一步需要再次退栈 c，这将导致连续4次退栈操作。此序列违反了不允许连续3次退栈操作的规则。

15. (单选题)

若栈S1中保存整数，栈S2中保存运算符，函数F()一次执行下述各步操作：

• A. -15
• B. 15
• C. -20
• D. 20

答案:B:15

答案分析：

函数F()的操作步骤可能包括从栈S1中弹出两个操作数，从栈S2中弹出一个运算符，执行运算，并将结果压回栈S1中。如果栈S1中的操作数依次是5, 8, 3, 2（2在栈顶），而栈S2中的运算符依次是*, -, +（+在栈顶），那么执行三次F()函数后，栈S1栈顶的值应该是 15。

这是通过以下步骤计算得出的：

1. 第一次调用F()：弹出2和3，运算符是+，执行3+2得到5，压入栈S1。
2. 第二次调用F()：弹出5和8，运算符是-，执行8-5得到3，压入栈S1。
3. 第三次调用F()：弹出3和5，运算符是*，执行5*3得到15，压入栈S1。

16. (单选题)设栈S和队列Q的初始状态均为空，元素abcdefg一次进入栈S，若每个元素出栈后立即进入队列Q，且7个元素出队的顺序是bdcfeag，则栈S的容量至少为（ ）

• A. 1
• B. 2
• C. 3
• D. 4

答案:C:3

答案分析：

1. 依次将元素 a, b, c 压入栈中，栈此时的状态：[a, b, c]
2. 弹出栈顶元素 c, 栈状态：[a, b]
3. 压入元素 d, 栈状态：[a, b, d]
4. 弹出栈顶元素 d, 栈状态：[a, b]
5. 压入元素 e, 栈状态：[a, b, e]
6. 弹出栈顶元素 e, 栈状态：[a, b]
7. 压入元素 f, 栈状态：[a, b, f]
8. 弹出栈顶元素 f, 栈状态：[a, b]
9. 弹出栈顶元素 b, 栈状态：[a]
10. 弹出栈顶元素 a, 栈状态：[]

为了使这个顺序成立，我们分析最大需要保持的元素数：

• 一次将三个元素 (a, b, c) 存入栈，容量需要至少为 3。
• 之后每次有一个新的元素压入和出栈，栈的容量维持为3。

通过这个过程，我们确定栈 SSS 的容量至少为 3。

17. (单选题)若一个栈的输入序列是1，2，3，......，n，输出序列的第一个元素是n，则第i个输出元素是（ ）

• A. 不确定
• B. n-i
• C.n-i-1
• D. n-i+1

答案:D:n-i+1

答案分析：

根据栈的后进先出（LIFO）原则，如果一个栈的输入序列是1，2，3，…，n，且输出序列的第一个元素是n，那么可以推断出，除了n之外的所有元素都已经按顺序进入了栈中。因此，输出序列将按照n, n-1, n-2, …, 3, 2, 1的顺序进行，如果第一个输出元素是n，那么第i个输出元素将是n减去i加1，即n-i+1。这个规律是因为每次输出都是从栈顶取出元素，而栈顶元素是最后进入的元素。例如，如果n是5且i是2，那么第二个输出元素将是5-2+1，即4。

18. (单选题)

一个栈的输入序列为1，2，3.......，n，输出序列的第一个元素是i，则第j个输出元素是（ ）

• A. i-j-1
• B. i-j
• C. j-i+1
• D. 不确定

答案:D:不确定

19. (单选题)

• A. a,b,c,d
• B. c,b,d,a
• C. d,c,a,b
• D. a,c,b,d

答案:C:d,c,a,b

答案分析：

如果某个元素先出栈，那么它后面出栈的元素必须是在它之前进栈的元素，并且这些元素应该是按照进栈的逆序出栈的。

分析一下每个选项：

• A. a, b, c, d：这是可能的输出序列，因为所有元素都是按照进栈的顺序出栈的。
• B. c, b, d, a：这也是可能的，因为 c 和 b 可以先出栈，然后 d 和 a 按照进栈的逆序出栈。
• C. d, c, a, b：这是不可能的输出序列。因为一旦 d 出栈，c 也出栈了，那么 a 就不能在 b 之前出栈，因为 b 在 a 之前进栈。
• D. a, c, b, d：这是可能的，因为 a 可以先出栈，然后 c, b, d 按照进栈的逆序出栈。

20. (单选题)

• A. 可能是2
• B. 一定是2
• C. 不可能是2
• D. 不可能是3

答案:C:不可能是2

答案分析：

因为P3=1，所以在1之前进栈的元素只能是2和3，而且3必须在2之前进栈。

因此，P1不能是2，因为那样的话2就会在3之前进栈，这与栈的后进先出原则相违背。

21. (单选题)

• A. 2，4
• B. 2，1
• C. 4，3
• D. 3，4

答案:C:4，3

答案分析：

逐个判断每个选项可能的入栈出栈顺序。

对于A，可能的顺序是1入，1出，2入，2出，3入；3出，4入，4出。

对于B，可能的顺序是1入，2入，3入，3出，2出，4入，4出，1出。

对于D,可能的顺序是1入，1出，2入，3入，3出，2出，4入，4出。

C没有对应的序列，因为当4在栈中时，意味着前面的所有元素（1，2，3）都已在栈中或曾经入过栈，此时若4第二个出栈，即栈中还有两个元素，且这两个元素是有序的（对应入栈顺序)，只能为(1,2),(1,3),(2,3），若是序列(1,2),则3已在p1位置出栈，不可能再在p4位置出栈，若是（1,3)和(2，3)这种情况中的任意一种，则3一定是下一个出栈元素，即p3一定是3，所以p4不可能是3。

22. (单选题)
一个栈的入栈序列为1，2，3.......,n，出栈序列为P1,P2,P3...,Pn，若P2=3，则P3可能取值的个数是（  ）

• A. n-3
• B. n-2
• C. n-1
• D. 无法确定

答案:C:n-1

答案分析：

p3可能取3外的所有数，个数为n-1.

23. (单选题)

• A. 4
• B. 5
• C. 3
• D. 6

答案:C:3

答案分析：

在C语言中，标识符的命名规则是：

1. 标识符必须以字母或下划线开头，不能以数字开头。
2. 标识符只能包含字母、数字和下划线。
3. 标识符区分大小写。

给定的字符序列“n1_”作为栈的输入，我们可以生成的有效C语言标识符序列有：

• n1_
• 1n_ (无效，因为不能以数字开头)
• _n1
• n_1
• _1n (无效，因为不能以数字开头)

所以，有效的C语言标识符序列有3个。

24. (单选题)

• A. top2-top1==1
• B. top1-top2==1
• C. top1==top2
• D. 以上都不对

答案:A:top2-top1==1

答案分析：

在顺序共享栈中，两个栈共享一个数组空间，其中一个栈从数组的开始位置向后增长，另一个栈从数组的末尾向前增长。栈顶指针top1和top2分别表示这两个栈的栈顶位置。当第一个栈的栈顶指针top1的初值为-1，第二个栈顶指针top2的初值为n时，共享栈满的条件是两个栈顶指针相邻，即它们之间没有空间可以存放新的元素。正确的判断条件是：

• A. top2-top1==1

这意味着当top2的位置比top1的位置大1时，两个栈顶指针相邻，没有更多空间可以用来存储元素，因此共享栈被认为是满的。

25. (单选题)采用共享栈的好处是（  ）

• A. 减少存储时间，降低发生上溢的可能
• B. 节省存储空间，降低发生上溢的可能
• C. 减少存取时间，降低发生下溢的可能
• D. 节省存储空间，降低发生下溢的可能

答案:B：节省存储空间，降低发生上溢的可能

答案分析：

上溢：存储器满，还往里写

下溢：存储器空，还往外读

chap3 练习2

一. 单选题

1. (单选题) 栈和队列得主要区别在与 （）

• A. 他们的逻辑结构不一样
• B. 它们的存储结构不一样
• C. 所包含的元素不一样
• D. 插入、删除操作的限定不一样

答案:D

2. (单选题)
队列的”先进先出“特性是指（  ）

（1）最后插入队列中的元素总是最后被删除

（2）当同时进行插入、删除操作时，总是插入操作优先

（3）每当有删除操作时，总要先做一次插入操作

（4）每次从队列中删除的总是最早插入的元素

• A. （1）
• B. （1）（4）
• C. （2）（3）
• D. （4）

答案:B

3. (单选题) 允许对队列进行的操作有（ ）

• A. 对队列中的元素排序
• B. 取出最近进队的元素
• C. 在队列元素之间插入元素
• D. 删除队头元素

答案:D

4. (单选题)
一个队列的入队顺序是1，2，3，4，则出队的输出顺序是（  ）

• A. 4，3，2，1
• B. 1，2，3，4
• C. 1，4，3，2
• D. 3，2，4，1

答案:B

5. (单选题) 循环队列存储在数组A[0...n]中，入队时的操作为（  ）

• A. rear=rear+1
• B. rear=（rear+1） mod （n-1)
• C. rear=（rear+1） mod n
• D. rear=（rear+1） mod （n+1)

答案：D

答案分析：

数组下表范围0~n,因此数组容量为n+1.循环队列中元素入队的操作是rear=(rear+1)mod maxsize

6. (单选题)

• A. 5
• B. 6
• C. 16
• D. 17

答案：C

答案分析：

循环队列的长度可以通过下面的公式计算：

队列长度=(rear−front+n)%n

其中，rear 是队尾指针的位置，front 是队头指针的前一个位置，n 是数组的大小。

在这个问题中，rear = 3，front = 8，数组的大小 n = 21。将这些值代入公式中，我们可以计算出队列的长度：

队列长度=(3−8+21)%21

队列长度=(16)%21

队列长度=16

因此，该队列的长度为16。

7. (单选题)

• A. 3和4    
• B. 3和0
• C. 5和0
• D. 5和1

答案：B

答案分析：

在循环队列中，front 指向队列的第一个元素，而 rear 指向队列的最后一个元素的下一个位置。当从队列中删除一个元素时，front 会增加1（因为它指向的是队列的第一个元素的前一个位置）。当加入一个元素时，rear 会增加1。由于这是一个循环队列，所以这些操作都是模数组大小的。

给定的情况下，数组大小为6（A[0…5]），初始时 front=5 和 rear=1。删除一个元素后，front 变为 (5+1) mod 6 = 0。加入两个元素后，rear 变为 (1+2) mod 6 = 3。

因此，删除一个元素并加入两个元素后，rear 和 front 的值分别为3和0。

8. (单选题)

已知循环队列存储在一维数组A[0...n-l]中，且队列非空时front和 rear分别指向队头元素和队尾元素。若初始时队列为空，且要求第一个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是（）。

• A. 0，0
• B. 0，n-1
• C. n-1，0
• D. n-1，n-1

答案：B

答案分析：

第一个进入队列的元素存储在A[0]处,此时front和rear值都为0。入队时因为要执行（rear+1)%n操作，所以若入队后指针指向0，则rear初值为n-1，而因为第一个元素在A[0]中，插入操作只改变rear指针,所以front为0不变。

9. (单选题)

假设一个循环队列Q [MaxSize]的队头指针为front,队尾指针为rear, 队列的最大容量为MaxSize,除此之外，该队列再没有其他数据成员，则判断该队的列满条件是（）。

• A. Q.front==Q.rear
• B. Q.front+Q.rear>=MaxSize
• C. Q.front==(Q.rear+1)%MaxSize
• D. Q.rear==(Q.front+1)%MaxSize

答案：C

答案分析：

规律，记住

10. (单选题)

循环队列放在一维数组A[0...M-l]中，endl指向队头元素，end2指向队尾元素的后一个位置。假设队列两端均可进行入队和出队操作，队列中最多能容纳 M-1个元素，。初始时为空。下列判断队空和队满的条件中，正确的是  （）

• A.队空：endl==end2;   

        队满 endl== (end2 + l) mod M

• B.队空：endl==end2;

        队满：end2== (endl + 1) mod (M-l)

• C.队空：end2= (endl + 1) mod M

        队满：endl= (end2 + l) mod M

• D.队空：endl== (end2 + l) mod M

        队满：end2== (endl + 1) mod (M-l)

答案：A

答案分析：

在循环队列中，endl 指向队头元素，而 end2 指向队尾元素的后一个位置。队列为空的条件是 endl 和 end2 相等。队列满的条件是 end2 指向的位置是 endl 的前一个位置，因为队列最多能容纳 M-1 个元素。因此，我们可以排除掉选项 C 和 D，因为它们的队空条件是错误的。

选项 A 提出队满的条件是 endl == (end2 + 1) mod M。这是正确的，因为如果 end2 指向的位置正好是 endl 的前一个位置，那么队列就是满的。

11. (单选题)

最适合用做队列的链表是()

• A.带队首指针和队尾指针的循环单链表
• B. 带队首指针和队尾指针的非循环单链表
• C. 只带队首指针的非循环单链表
• D. 只带队首指针的循环单链表

答案：B

答案分析：

最适合用来实现队列的链表是带有队首指针和队尾指针的非循环单链表。这是因为队列是一种先进先出（FIFO）的数据结构，我们需要能够快速访问队首和队尾。

• 带队首指针和队尾指针的非循环单链表（选项 B）允许我们快速进行入队和出队操作。入队时，我们在队尾指针指向的节点后面添加新节点，并更新队尾指针。出队时，我们删除队首指针指向的节点，并更新队首指针。
• 带队首指针和队尾指针的循环单链表（选项 A）也可以用来实现队列，但它更适合实现循环队列，其中元素可以循环移动。
• 只带队首指针的非循环单链表（选项 C）和只带队首指针的循环单链表（选项 D）不适合用来实现队列，因为它们不能快速访问队尾，这会使得入队操作变得复杂和耗时。

12. (单选题)

最不适合用做链式队列的链表是（）

• A. 只带队首指针的非循环双链表
• B. 只带队首指针的循环双链表
• C. 只带队尾指针的循环双链表
• D. 只带队尾指针的循环单链表

答案：A

13. (单选题)

用单链表实现队列时，队头设在链表的（  ）位置

• A. 链头
• B. 链尾
• C. 链中
• D. 以上都可以

答案：A

答案分析：

在使用单链表实现队列时，队头通常设在链表的 A. 链头 位置。这是因为在队列中，元素是按照先进先出（FIFO）的原则进行添加和删除的。在链表的头部添加和删除元素的时间复杂度是O(1)，而在链表的尾部删除元素的时间复杂度也是O(1) ，但在尾部添加元素时，如果没有维护指向链尾的指针，那么添加元素的时间复杂度将是O(n) ，因为需要遍历整个链表找到尾部。因此，为了保持队列操作的高效性，队头设置在链表的头部，而队尾则设置在链表的尾部。这样可以快速地进行入队（在链尾添加元素）和出队（在链头删除元素）操作。

14. (单选题)

用链式存储方式的队列进行删除操作时需要（）

• A.仅修改头指针
• B.仅修改尾指针
• C.头尾指针都要修改
• D.头尾指针可能都要修改

答案：D

15. (单选题)

在一个链队列中，假设队头指针为front,队尾指针为rear, x所指向的元素需要入队，则需要执行的操作为（）。

• A.  front=x, front=front->next
• B.  x->next=front->next, front=x
• C. rear->next=x, rear=x
• D.  rear->next=x, x->next=null, rear=x

答案:D

答案分析：

在一个链队列中，如果要将 x 所指向的元素入队，正确的操作是 D. rear->next=x, x->next=null, rear=x。这个操作包含三个步骤：

1. 将 x 节点链接到当前的队尾节点，这是通过 rear->next=x 实现的。
2. 由于 x 节点将成为新的队尾节点，它的 next 指针应该指向 null，表示链表的结束，这是通过 x->next=null 实现的。
3. 更新 rear 指针，使其指向新的队尾节点 x，这是通过 rear=x 实现的。

这样，x 成功地被添加到队列的末尾，同时保持了队列的先进先出（FIFO）特性。

16. (单选题)

假设循环单链表表示的队列长度为n, 队头固定在链表表尾，若只设头指针，则进队操作的时间复杂度为（  ）

• A. O(n)
• B. 0(1)
• C. 0(n2)
• D.  O(nlog2n)

答案:A

17. (单选题)

若以1,2, 3, 4作为双端队列的输入序列，则既不能由输入受限的双端队列得到，又不能 由输出受限的双端队列得到的输出序列是()。

• A.1，2，3，4
• B.4，1，3，2
• C. 4，2，3，1
• D. 4，2，1，3

答案：C

答案分析：

A.1,2,3,4依次左入，依次左出

B.左出，右出，左出，左出

D.左入，左入，右入，左入，依次左出

18. (单选题)

某队列允许在其两端进行入队操作，但仅允许在一端进行出队操作。 若元素abcde 依次入此队列后再进行出队操作，则不可能得到的出队序列是()

• A. b,a,c,d,e
• B. d,b,a,c,e
• C. d,b,c,a,e
• D. e,c,b,a,d

答案：B

答案分析：

输出受限的双端队列。

A操作：a左入（或右入）、6左入、c右入、d右入、e右入。

B操作：a左入（或右入）、6左入、c右入、d左入、e右入。

D操作：a左入（或右入）、b左入、c左入、d右入、e左入。

C操作：a左入（或右入）、6右入、因a未出，此时只能进队，c怎么进都不可能在b和a之间。
【另解】初始时队列为空，第1个元素a左入（或右入）后，第2个元素6无论是左入还是右入都必与a相邻，而选项C中a与b不相邻，不合题意。

19. (单选题)

现有队列Q与栈S,初始时Q中的元素依次是1, 2, 3, 4, 5, 6 ( 1在队头)，S为空。若仅允许下列3种操作：①出队并输出出队元素；②出队并将出队元 素入栈；③出栈并输出出栈元素，则不能得到的输出序列是()。

• A. 1,2, 5, 6, 4, 3 
• B. 2, 3, 4, 5, 6, 1
• C. 3, 4, 5, 6, 1,2
• D. 6, 5, 4, 3, 2,1

答案：C

答案分析：

A:11221133

B:2111113

D:22222133333

C：首先输出3，说明1和2必须先依次入栈，此后2肯定比1先输出