跳转至

408 高频考点精讲:队列(Queue (Circular Queue, Linked Queue, Deque, Multi-track Permutation))

模块归属:数据结构 · 栈、队列及数组
考点层级:微观细分考点(近十年考查 \(\ge 3\) 次)
适用对象:408 计算机考研备考学生


一、 考情档案

  • 近十年考查频次:3 次(2016~2025 年:2016#3、2019#42 大题、2021#2)
  • 历年总考查频次:6 次(含 2010#2、2011#3、2014#3)
  • 出题形式:单项选择题(分值 2 分)与综合设计大题(2019 年第 42 题,分值 10 分)
  • 命题特点:
  • 结构实现深度:既考查循环队列的模运算代数机理、二义性消歧判定策略(牺牲单元、计数器、状态标志),又在综合设计大题中重点考查单向循环链表队列的动态无感知扩容与结点复用;
  • 拓扑受限演化:深入考查双端队列(Deque)的输入受限与输出受限变体,要求考生精确分析操作序列生成的代数置换约束;
  • 跨学科调度建模:将队列先进先出(FIFO)模型与铁路多轨列车调度结合,考查偏序集 Dilworth 定理与最长下降子序列(LDS)极值计算。
近十年考查年份分布:
2016   2017   2018   2019   2020   2021   2022   2023   2024   2025
 √      -      -      √      -      √      -      -      -      -
(#3)                (#42)          (#2)

二、 具体考察内容

1. 队列抽象数据类型(ADT)与数学特性

  • 形式化定义:队列(Queue)是一种操作受限的线性表,限定仅允许在表的一端进行插入(Enqueue / 入队),在表的另一端进行删除(Dequeue / 出队)。
  • 操作端点术语:
  • 允许插入的一端称为队尾(Rear)。
  • 允许删除的一端称为队头(Front)。
  • 先进先出(FIFO, First In First Out)操作特性: 设元素入队序列为 \(S = \langle a_1, a_2, \dots, a_n \rangle\)$ \text{,则在标准单向队列中,元素出队次序在时间轴上具有严格的一维全序单调性,其合法出队序列全射且唯一,必然为} $\(\langle a_1, a_2, \dots, a_n \rangle\)。
  • 时序守恒代数约束: 设在离散操作时间轴上,入队操作记为 \(+1\)$ \text{,出队操作记为} $\(-1\)$ \text{。在任意离散时刻} $\(t\)$ \text{,出队操作的总次数不得大于截至该时刻的累计入队总次数;队内驻留元素个数在任何时刻均满足} $\(N(t) \ge 0\)。

2. 顺序队列与循环队列(Circular Queue)

(1) 静态顺序实现的“假溢出”机理剖析

采用连续一维数组 data[MaxSize] 存储队列元素,定义两个整型游标: * 队头指针 front:指示当前队头元素的位置; * 队尾指针 rear:指示当前队尾元素的下一个可用存储位置。

初始化时 front = 0, rear = 0。随着元素持续入队与出队: * 入队操作推进队尾指针:rear = rear + 1; * 出队操作推进队头指针:front = front + 1。

指针单调向高地址滑动。当 rear == MaxSize 时,若继续入队,按线性边界判定将引发数组下标越界异常。然而,若此前已发生多次出队操作,使得 front > 0,则数组低地址区间 \([0, front - 1]\) 实际上均处于闲置状态。这种物理存储空间未耗尽却因指针越界而无法继续插入的现象,称为假溢出(False Overflow)。其本质是线性地址空间单向递增性与队列动态滑动性之间的几何矛盾。

假溢出状态示意图:
下标:    0       1       2      ...     MaxSize-1   MaxSize
存储:  [空闲]  [空闲]  [a_2]   ...     [a_{k}]     | (越界触发假溢出)
                       ^                           ^
                     front                        rear

(2) 模运算同余映射与环形逻辑空间建立

解决假溢出的根本手段是建立循环队列(Circular Queue / Ring Buffer),利用模运算(Modulo Operation)的同余周期性,将离散线性地址区间 \([0, MaxSize-1]\) 映射为逻辑闭合圆环: * 入队队尾指针步进:rear = (rear + 1) % MaxSize * 出队队头指针步进:front = (front + 1) % MaxSize

(3) 状态二义性冲突根源剖析(数学本质)

循环队列所占用的物理存储单元总数为 \(MaxSize\)$ \text{。队列内部容纳的实际元素个数可能为} $\(0, 1, 2, \dots, MaxSize\)$ \text{,共计} $\(MaxSize + 1\) 种离散容量状态。
然而,仅凭指针 front 与 rear 在模 \(MaxSize\)$ \text{环上的相对下标差值,至多只能提供} $\(MaxSize\)$ \text{种不同的离散偏移状态(} $\(rear - front \equiv 0, 1, \dots, MaxSize - 1 \pmod{MaxSize}\))。
根据抽屉原理(Pigeonhole Principle),必有两种状态映射到完全相同的指针代数关系: * 队列为空时:front == rear; * 队列全满(存储了 \(MaxSize\) 个元素)时:rear 绕环一周再次追及 front,同样满足 front == rear。
若不引入辅助判决机制,系统无法通过指针相对位置区分“队空”与“队满”。

(4) 三种经典消歧判定方案

方案一:牺牲一个存储单元(408 统考基准方案)
  • 设计策略:约定队列最大有效存储容量为 \(MaxSize - 1\)。当环中仅剩余最后一个物理存储单元未用时,即强制判定为“队满”。
  • 队空判定条件: $\(front == rear\)$
  • 队满判定条件: $\((rear + 1) \pmod{MaxSize} == front\)$
  • 队列当前有效元素个数公式: $\(\text{Length} = (rear - front + MaxSize) \pmod{MaxSize}\)$ 推导证明:指针差值 $rear

  • front$$ \text{属于连续区间} $$[-(MaxSize

  • 1), MaxSize

  • 1]$$ \text{。若} $\(rear \ge front\)$ \text{,差值即为长度;若} $\(rear < front\)$ \text{(队尾已回绕至低地址,队头位于高地址),差值为负数,其实际物理跨度为} $$(MaxSize

  • front) + rear = rear

  • front + MaxSize$$ \text{。引入模操作统一表达式:加上基数} $\(MaxSize\)$ \text{消除负数偏移,再执行模} $\(MaxSize\)$ \text{运算,可将负余数严格折算到} $$[0, MaxSize

  • 1]$ 之间。

方案一:牺牲一个单元判满示意图 (MaxSize = 8)
              0 [E_0] (front)
           /     \
    7 [空]         1 [E_1]
      ^ 
    (rear)
      |            |
    6 [E_5]        2 [E_2]
           \     /
        5 [E_4] - 4 [E_3]
   此时 (rear + 1) % 8 == front,判为队满,实际容纳 7 个元素
方案二:设置计数变量 size
  • 设计策略:结构体中显式引入整型变量 size 记录队列中当前实际驻留的元素个数。
  • 存储容量:可完全利用全部 \(MaxSize\) 个物理存储单元。
  • 队空判定条件: $\(size == 0\)$
  • 队满判定条件: $\(size == MaxSize\)$
  • 指针与计数值同步更新:
  • 入队:data[rear] = x; rear = (rear + 1) % MaxSize; size++;
  • 出队:x = data[front]; front = (front + 1) % MaxSize; size--;
  • 队列当前有效元素个数:直接由 size 变量给出。
方案三:设置状态翻转标记位 tag
  • 设计策略:设置标志位 tag(取值 \(0\)$ \text{或} $\(1\)),用于记录最近一次引起指针移动的操作属性:
  • 最近一次操作为“入队”(可能引发队满),置 tag = 1;
  • 最近一次操作为“出队”(可能引发队空),置 tag = 0。
  • 队空判定条件: $\(front == rear \land tag == 0\)$
  • 队满判定条件: $\(front == rear \land tag == 1\)$
  • 队列当前有效元素个数公式: $\(\text{Length} = \begin{cases} 0, & front == rear \land tag == 0 \\ MaxSize, & front == rear \land tag == 1 \\ (rear - front + MaxSize) \pmod{MaxSize}, & front \ne rear \end{cases}\)$

(5) 队尾指针语义变体对比(命题核心细节点)

408 考题中存在两种不同的队尾指针定义体例,直接决定初始化数值与操作先后次序:

维度对比 变体 A:指向队尾元素的下一个位置(主流标答) 变体 B:指向队尾元素本身(常见考查陷阱)
指针含义 rear 指向待插入空闲单元 rear 指向当前最新存入的数据单元
初始状态(空队) front = 0; rear = 0; front = 0; rear = MaxSize - 1;
入队操作序列 data[rear] = x; rear = (rear + 1) % MaxSize; rear = (rear + 1) % MaxSize; data[rear] = x;
出队操作序列 x = data[front]; front = (front + 1) % MaxSize; x = data[front]; front = (front + 1) % MaxSize;
队满条件(牺牲单元) (rear + 1) % MaxSize == front (rear + 1) % MaxSize == front(此时空满判定需结合变体初值)

3. 链式队列(Linked Queue)与空间复用机制

(1) 基本单链表队列

链式队列使用单链表实现,配置队头指针 front 与队尾指针 rear: * 带头结点结构:front 始终指向头结点,front->next 指向实际队头元素结点;rear 指向当前队尾元素结点。 * 基本操作流程: * 队空判定:front == rear(或 front->next == NULL); * 入队操作:创建新结点 s,执行 rear->next = s; rear = s;,时间复杂度 \(O(1)\); * 出队操作:取出 p = front->next;,执行 front->next = p->next;,若出队结点恰好为尾结点(rear == p),则需将尾指针回指头结点 rear = front;,最后执行 free(p);,时间复杂度 \(O(1)\)。

(2) 单向循环链表队列的动态无损复用架构(2019 年 408 大题模型)

传统链式队列频繁调用 malloc() 与 free(),存在系统调用开销与内存碎片问题。综合设计题所考查的高性能循环链式队列,其核心思想是将单向循环链表作为动态可自增的环形缓冲区: 1. 空间只增不减原则:元素出队时,不调用 free() 归还操作系统内存,仅移动 front 游标,使该结点自然留在环中充当预备闲置结点,供后续入队操作复用; 2. 常数阶扩容原则:当且仅当环中全部已分配结点均被数据填满(即触发队满判定 rear->next == front)且又有新元素入队时,调用单次 malloc() 分配一个新结点就地插入到 rear 之后;该单次插入扩容消耗 \(O(1)\)$ \text{时间,彻底消除了顺序存储数组整体重新分配与数据搬移导致的} $\(O(n)\) 最坏时间复杂度波动。


4. 双端队列(Deque, Double-Ended Queue)受限变体与输出序列置换

(1) 拓扑结构分类

双端队列允许在序列的两端分别执行插入和删除操作。其受限演化结构构成了 408 考研的重要逻辑推断题型:

1. 通用双端队列:
   入队/出队 <====== [ 端点 A  ...  端点 B ] ======> 入队/出队

2. 输入受限双端队列 (Input-Restricted Deque):
   仅入队   ======> [ 端点 A  ...  端点 B ] <====== 入队
                                            ======> 出队 (唯一出口)

3. 输出受限双端队列 (Output-Restricted Deque):
   唯一入口 ======> [ 端点 A  ...  端点 B ] ======> 出队
   出队     <======                         ======> 出队

(2) 输入受限双端队列的阻隔效应与置换定理

以 2021 年统考真题为例,设定双端队列端点 A 仅能入队,端点 B 既能入队又能出队(所有出队均从端点 B 弹出): * 代数性质分析: * 若新元素 \(x\) 从端点 B 入队,它直接位于出队口的最外层,优先被弹出,该操作等价于栈顶压入(Push); * 若新元素 \(x\) 从端点 A 入队,它位于队列最深处,远离出队口,该操作等价于队尾追加(Enqueue); * 出队操作均发生在端点 B,等价于从左向右读取端点 B 的最顶层元素。 * 拓扑阻隔定理(Blocking Theorem): * 设有两个元素 \(u, v\)$ \text{,输入流中} $\(u\)$ \text{先于} $\(v\)$ \text{到达(} $\(u\)$ \text{的时间戳早于} $\(v\))。 * 若 \(u\)$ \text{与} $\(v\)$ \text{均选择从端点 A 入队,则在队列物理链条中,} $\(u\)$ \text{必然比} $\(v\) 更靠近端点 B。 * 当它们从端点 B 出队时,\(u\)$ \text{必须早于} $\(v\) 出队。 * 推论:所有从端点 A 入队的元素子序列,其在出队序列中的相对次序必须与输入序列中的相对次序严格保持一致(即服从严格 FIFO 次序)。任何企图颠倒两同端入队元素先后顺序的输出排列均为非法置换。


5. 多轨列车调度模型与组合极值定理(Dilworth 定理)

(1) 列车轨道调度的物理模型抽象

设火车从入口行进至出口,中间设置 \(n\) 条平行的调度轨道。所有列车行进方向单向固定(从左向右)。 * 每条平行轨道在逻辑上等价于一个无超车能力的单向管道(先进先出 FIFO 缓冲区)。 * 设输入序列为列车驶入编号流 \(\pi = \langle a_1, a_2, \dots, a_m \rangle\)。 * 期望在出口处按严格递增序列 \(\langle 1, 2, \dots, m \rangle\) 驶出。

入口流 ==========\                     /===========> 出口流 (递增 1..m)
                  +--- 轨道 1 (FIFO) ---+
                  +--- 轨道 2 (FIFO) ---+
                  +--- ......        ---+
                  +--- 轨道 n (FIFO) ---+
                 /                       \

(2) 轨道内序列单调性充要条件推导

设列车 \(x\)$ \text{与列车} $\(y\)$ \text{进入同一条调度轨道,且在时间上} $\(x\)$ \text{先进,} $\(y\) 后进。 * 在物理结构上,列车无法跨越或穿透前车,故在出口端必为 \(x\)$ \text{先驶出、} $\(y\) 后驶出; * 为保证全局输出序列为递增序列,先驶出的列车编号必须小于后驶出的列车编号,即必然有: $\(x < y\)$ * 定理:驶入同一条轨道的列车编号子序列,必须严格单调递增。

(3) 偏序集划分与 Dilworth 定理形式化证明

  • 偏序集构造:定义集合 \(S = \{a_1, a_2, \dots, a_m\}\)$ \text{,在} $\(S\)$ \text{上建立二元偏序关系} $\(\prec\): $\(a_i \prec a_j \iff i < j \land a_i < a_j\)$ 该偏序关系表示元素 \(a_i\)$ \text{既在到达时间上早于} $\(a_j\)$ \text{,且在数值大小上严格小于} $\(a_j\)。
  • 链与反链概念:
  • 链(Chain):\(S\)$ \text{的子集} $\(C \subseteq S\)$ \text{,其中任意两元素均可比。由定义,} $\(C\) 对应输入序列的一个严格单调递增子序列。一整条链上的所有列车可被指派调度至同一条轨道;
  • 反链(Antichain):\(S\)$ \text{的子集} $\(A \subseteq S\)$ \text{,其中任意两不同元素均不可比。即对任意} $\(a_i, a_j \in A\)$ \text{(设} $\(i < j\)$ \text{),不可能满足} $\(a_i < a_j\)$ \text{,因此必有} $\(a_i > a_j\)。反链严格对应输入序列的一个严格单调下降子序列(Decreasing Subsequence)。
  • Dilworth 定理(极小极大定理): 有限偏序集划分为互不相交的链的最小链划分数,严格等于该偏序集的最大反链元素数目。
  • 调度轨道数极小值结论: 满足完全递增输出调度所需的最少平行轨道数 \(n_{\min}\),严格等于列车输入序列中最长下降子序列(Longest Decreasing Subsequence, LDS)的长度: $\(n_{\min} = \text{Length of LDS}(\pi)\)$ 直观物理释义:若输入序列中存在一个长度为 \(k\)$ \text{的单调下降子序列} $\(\langle d_1, d_2, \dots, d_k \rangle\)$ \text{(满足} $\(d_1 > d_2 > \dots > d_k\)$ \text{),根据轨道内序递增定理,这} $\(k\)$ \text{列列车中任意两列均不可同轨,否则后进的较小编号列车将堵塞先进的较大编号列车,导致出站逆序。因此系统至少需要开辟} $\(k\) 条不同的物理轨道。

(4) 在线贪心调度算法(Patience Sorting 贪心法则)

  • 维护各轨道当前最末尾列车的编号集合 \(\{T_1, T_2, \dots, T_k\}\)。
  • 当新列车 \(x\) 到达时:
  • 检索所有满足 \(T_r < x\)$ \text{的轨道(即接纳} $\(x\) 后仍满足单调递增要求的可用轨道);
  • 若存在多条可用轨道,选用其中 \(T_r\)$ \text{最大(即数值最接近} $\(x\)$ \text{、空间贴合最紧凑)的轨道驶入,并更新该轨道的末尾值为} $\(T_r = x\);
  • 若不存在满足 \(T_r < x\)$ \text{的轨道,则必须新建一条轨道,并将其末尾值初始化为} $\(x\)。
  • 该贪心策略保证动态构建出的总轨道数达到理论下界 \(n_{\min}\)。

6. 队列在计算机系统中的核心应用

(1) 操作系统资源调度与并发缓冲

  • 脱机并发与缓冲池(Spooling 技术):在高速处理机(CPU)与低速外部设备(如网络打印机)之间建立环形 FIFO 缓冲队列,将独占设备改造为逻辑共享设备,削峰填谷平抑速率失配;
  • 进程调度就绪队列:
  • 先来先服务(FCFS)调度算法维护纯时间序 FIFO 队列;
  • 时间片轮转(Round-Robin)调度算法在时间片到期后将进程移出队头并插入队尾;
  • 多级反馈队列(MLFQ)由多个不同时间片权重的 FIFO 优先级队列级联构成;
  • 进程间通信(IPC)机制:管道(Pipe)在内核层采用固定容量的环形缓冲区(Ring Buffer)实现生产者-消费者数据流动。

(2) 状态空间图与树的高效遍历

  • 树的层序遍历:按深度递增顺序访问二叉树各层结点,借助队列维持“同层从左向右、按层先后推进”的时序性质;
  • 广度优先搜索(BFS):求解图结构无权单源最短路径(SSSP)的核心驱动引擎,队列内部维护已发现但尚未扩展的前沿顶点集合。

三、 近十年真题精讲(2016~2025)


【真题 1】2021 年 408 第 2 题 · 输入受限双端队列合法出队序列判定

题目
已知初始为空的队列 Q 的一端仅能进行入队操作,另外一端既能进行入队操作又能进行出队操作。若 Q 的入队序列是 1, 2, 3, 4, 5,则不能得到的出队序列是( )。
A. 5, 4, 3, 1, 2          B. 5, 3, 1, 2, 4          C. 4, 2, 1, 3, 5          D. 4, 1, 3, 2, 5

【解析】

  1. 拓扑建模: 设端点 A 仅能入队,端点 B 既能入队又能出队。全部元素最终均必须由端点 B 出队。
  2. 从端点 B 入队:新元素直接占据端点 B 的最前沿,形成栈顶压入效应;
  3. 从端点 A 入队:新元素被置于队列深处,形成队尾追加效应。
  4. 逐项推演检验:
  5. A 项检验(5, 4, 3, 1, 2):
    • 元素 1 从端点 A 入队,队列状态:\([1]\)(左为 A,右为 B);
    • 元素 2 从端点 A 入队,队列状态:\([2, 1]\);
    • 元素 3 从端点 B 入队,队列状态:\([2, 1, 3]\);
    • 元素 4 从端点 B 入队,队列状态:\([2, 1, 3, 4]\);
    • 元素 5 从端点 B 入队,队列状态:\([2, 1, 3, 4, 5]\);
    • 从端点 B 连续出队三个元素:输出 5, 4, 3,队列剩余 \([2, 1]\);
    • 此时端点 B 处元素为 1,出队 1,队列剩余 \([2]\);出队 2,输出序列为 5, 4, 3, 1, 2。合法。
  6. B 项检验(5, 3, 1, 2, 4):
    • 元素 1 从端点 A 入队,队列:\([1]\);
    • 元素 2 从端点 A 入队,队列:\([2, 1]\);
    • 元素 3 从端点 B 入队,队列:\([2, 1, 3]\);
    • 元素 4 从端点 A 入队,队列:\([4, 2, 1, 3]\);
    • 元素 5 从端点 B 入队,队列:\([4, 2, 1, 3, 5]\);
    • 从端点 B 出队 5,出队 3,队列剩余 \([4, 2, 1]\);出队 1,出队 2,出队 4。输出序列为 5, 3, 1, 2, 4。合法。
  7. C 项检验(4, 2, 1, 3, 5):
    • 元素 1 从端点 A 入队:\([1]\);
    • 元素 2 从端点 B 入队:\([1, 2]\);
    • 出队 2,队列剩余 \([1]\);
    • 元素 3 从端点 A 入队:\([3, 1]\);
    • 元素 4 从端点 B 入队:\([3, 1, 4]\);
    • 出队 4,队列剩余 \([3, 1]\);出队 1,出队 3;
    • 元素 5 从端点 B 入队后立即出队 5。输出序列为 4, 2, 1, 3, 5。合法。
  8. D 项检验(4, 1, 3, 2, 5):
    • 观察出队前缀 \(\langle 4, 1, 3, 2 \rangle\)。
    • 首个出队元素为 4,说明在 4 出队之前,元素 1, 2, 3, 4 均已完成入队。
    • 4 既为输入流的第 4 个元素且首个出队,其必然是从端点 B 入队并立即出队。
    • 4 弹出后,紧接着要求出队元素 1。此时尚未处理元素 5,队列中仅包含已入队的集合 \(\{1, 2, 3\}\)。
    • 为使元素 1 在 4 离开后能够从端点 B 出队,元素 1 必须位于当前驻留队列的最靠近端点 B 的位置。
    • 元素 1 是最先到达的输入元素。若 1 位于端点 B,则后续进入的元素 2 与元素 3 绝对不可从端点 B 入队(否则 2 或 3 会覆盖在 1 的右侧阻止 1 出队)。
    • 因此,元素 2 与元素 3 必须全部选择从端点 A 入队。
    • 追踪从端点 A 入队的物理链条:
    • 1 无论从何端进入,此时位于右侧端点 B 附近;
    • 2 从端点 A 入队,被置于队列左端:\([2, 1]\);
    • 3 从端点 A 入队,被置于更新的队列左端:\([3, 2, 1]\)。
    • 此时端点 B 弹出元素 1 后,最靠近端点 B 的下一个元素必然是 2!队列内部拓扑关系为 \([3, 2]\)。
    • 在元素 2 出队之前,元素 3 被 2 物理阻隔在深处,绝无可能先于 2 从端点 B 出队!
    • 选项 D 的输出序列在 1 之后紧随 3,强行要求 3 先于 2 出队,违背了端点 A 入队的 FIFO 保序约束,产生逻辑矛盾。

正确答案:D


【真题 2】2019 年 408 第 42 题 · 循环复用队列结构与算法设计(综合题,10分)

题目
请设计一个队列,要求满足:
① 初始时队列为空;
② 入队时,允许动态增加队列占用空间;
③ 出队后,出队元素所占用的空间可重复使用,即整个队列所占用的空间只增不减;
④ 入队操作和出队操作的时间复杂度始终保持为 \(O(1)\)。
请回答下列问题:
(1) 该队列是应选择链式存储结构,还是应选择顺序存储结构?
(2) 画出队列的初始状态,并给出判断队空和队满的条件。
(3) 画出第一个元素入队后的队列状态。
(4) 给出入队操作和出队操作的基本过程。

【解析】

(1) 存储结构选型与理论证明

应选择链式存储结构(具体为单向循环链表)。
证明:若选用顺序存储结构(基于数组),数组的连续物理空间必须一次性分配。当容量不足需增加队列空间(满足要求②)时,系统必须申请一块更大的连续内存区并将原有数组中的全部数据拷贝搬移至新空间,这会导致单次扩容时的最坏时间复杂度跃升至 \(O(n)\)$ \text{,即使均摊复杂度为} $\(O(1)\)$ \text{,亦无法满足要求④中“始终保持为} $\(O(1)\)”的严苛约束。
而选用单向循环链表,在需要扩容时仅需申请单个独立结点插入环中,单次操作耗时严格为常数阶 \(O(1)\);出队时不调用 free() 释放物理内存,仅移动指针保留空闲结点,天然满足要求③中空间重复使用且只增不减的特性。

(2) 队列初始状态与空满判定条件

采用带头结点的单向循环链表构建环形队列。设置队头指针 front 和队尾指针 rear: * 牺牲一个单元判满策略:为消除指针相等的二义性,环中必须始终保留一个空闲结点不存储数据。 * 初始状态:创建仅包含一个结点的单向循环空链表(该结点即为牺牲的空闲结点),使其 next 指向自身。队头指针 front 和队尾指针 rear 均指向该结点。 * 队空判定条件: $\(front == rear\)$ * 队满判定条件(已有空间全满需触发扩容): $\(front == rear\text{->next}\)$

初始状态(队空):
+-------------+
|    front    |---+
+-------------+   |
                  v
+-------------+  +-------------+
|    rear     |->| 空闲结点    |---+
+-------------+  +-------------+   |
                       ^           |
                       +-----------+
此时 front == rear,队列为空。
(3) 第一个元素入队后的队列状态

向初始空队列插入第一个数据元素 \(x\): 1. 检查队满条件:初始状态下满足 \(front == rear\text{->next}\),表明无空闲可用单元,必须动态申请新结点; 2. 动态分配一个新结点,插入在 rear 所指结点之后; 3. 将数据写入原 rear 所指结点,并将 rear 指向新插入的空闲结点;front 保持不动。

第一个元素入队后的状态:
+-------------+
|    front    |------------------+
+-------------+                  |
                                 v
+-------------+           +--------------+
|    rear     |---+       | 数据结点 (x) |---+
+-------------+   |       +--------------+   |
                  v              ^           |
           +--------------+      |           |
           | 新空闲结点   |------+           |
           +--------------+                  |
                  ^                          |
                  +--------------------------+
数据存入 front 所指结点,rear 指向新的空闲结点。
(4) 入队与出队算法基本过程与 C 语言实现

入队操作核心流程: 1. 检测是否触发空间占满条件 front == rear->next; 2. 若为真,调用 malloc() 动态申请一个新结点,将其插入至 rear 结点的后继位置(s->next = rear->next; rear->next = s;); 3. 将待入队元素存入当前 rear 所指结点的 data 域; 4. 将队尾指针后移:rear = rear->next;。

出队操作核心流程: 1. 检测是否队空 front == rear;若为真,报告下溢并退出; 2. 提取 front 所指结点的元素值:x = front->data;; 3. 将队头指针后移:front = front->next;(原出队结点留在环中作为闲置备用空间,严禁释放); 4. 返回元素值 x。

typedef struct Node {
    ElemType data;
    struct Node *next;
} Node;

typedef struct {
    Node *front;
    Node *rear;
} LinkedQueue;

// 1. 初始化队列
void InitQueue(LinkedQueue *Q) {
    Node *s = (Node *)malloc(sizeof(Node));
    s->next = s;
    Q->front = s;
    Q->rear = s;
}

// 2. 入队操作:始终保持 O(1)
void EnQueue(LinkedQueue *Q, ElemType x) {
    // 若当前已分配空间均已占满,需扩充一个结点
    if (Q->front == Q->rear->next) {
        Node *s = (Node *)malloc(sizeof(Node));
        s->next = Q->rear->next;
        Q->rear->next = s;
    }
    Q->rear->data = x;
    Q->rear = Q->rear->next;
}

// 3. 出队操作:始终保持 O(1)
bool DeQueue(LinkedQueue *Q, ElemType *x) {
    if (Q->front == Q->rear) {
        return false; // 队空
    }
    *x = Q->front->data;
    Q->front = Q->front->next; // 仅移动指针,不释放物理内存
    return true;
}

【真题 3】2016 年 408 第 3 题 · 多轨列车调度最少轨道数与 Dilworth 定理

题目
设有火车调度车轨,入口到出口之间有 \(n\)$ \text{条平行轨道,列车的行进方向均为从左至右,列车可驶入任意一条轨道。现有编号为 1~9 的 9 列列车,驶入的次序依次是 8, 4, 2, 5, 3, 9, 1, 6, 7。若期望驶出的次序依次为 1~9,则} $\(n\) 至少是( )。
A. 2          B. 3          C. 4          D. 5

【解析】

1. 理论映射推导
  • 平行轨道为单向无超车通道,每条轨道呈现严格先进先出属性。
  • 欲使最终出轨次序为全局递增序列 \(1, 2, \dots, 9\),分配至同一轨道内部的列车编号流必须严格单调递增。
  • 根据 Dilworth 定理,将离散偏序序列划分为单调递增链的最小链划分数,严格等于该序列中最长下降子序列(LDS)的长度。
2. 寻找最长下降子序列(LDS)

给定输入序列:\(\pi = \langle 8, 4, 2, 5, 3, 9, 1, 6, 7 \rangle\)。 寻找其中的单调递减子序列: * 子序列 \(8 \to 4 \to 2 \to 1\):长度为 4; * 子序列 \(8 \to 5 \to 3 \to 1\):长度为 4。

在该序列中,子集 \(\{8, 4, 2, 1\}\) 构成长度为 4 的反链。
这 4 列列车在时间上先后到达(8 先于 4,4 先于 2,2 先于 1),但在编号上后到达者均严格小于先到达者。
若其中任意两辆列车被调度驶入同一条轨道,后到达的较小列车必将滞留在较先到达的较大列车后方,无法先于较大列车出站,从而破坏最终按 1~9 升序驶出的要求。
因此,这 4 辆列车彼此之间两两互斥,绝不能共用同一轨道,系统至少必须拥有 4 条物理轨道(\(n \ge 4\))。

3. 在线贪心调度验证(Patience Sorting 模拟执行)

按紧凑贪心准则动态分配 9 列列车: * 车 8 到达:开辟【轨道 1】,末尾为 8; * 车 4 到达:\(4 < 8\),无法进轨 1,开辟【轨道 2】,末尾为 4; * 车 2 到达:\(2 < 4 < 8\),无法进现有轨道,开辟【轨道 3】,末尾为 2; * 车 5 到达:可进轨 2(\(4 < 5\)$ \text{)或轨 3(} $\(2 < 5\))。选择末尾较大且最贴近者(轨 2),【轨道 2】末尾更新为 5; * 车 3 到达:\(3 > 2\),驶入【轨道 3】,【轨道 3】末尾更新为 3; * 车 9 到达:\(9 > 8\),驶入【轨道 1】,【轨道 1】末尾更新为 9; * 车 1 到达:此时各轨道末尾依次为:轨 1 (9)、轨 2 (5)、轨 3 (3)。车 1 的编号小于所有现有轨道末尾,无法驶入任何现有轨道,必须开辟【轨道 4】,末尾为 1; * 车 6 到达:\(6 > 5\),驶入【轨道 2】,【轨道 2】末尾更新为 6; * 车 7 到达:\(7 > 6\),驶入【轨道 2】,【轨道 2】末尾更新为 7。

最终分配格局: * 轨道 1:\(\langle 8, 9 \rangle\) * 轨道 2:\(\langle 4, 5, 6, 7 \rangle\) * 轨道 3:\(\langle 2, 3 \rangle\) * 轨道 4:\(\langle 1 \rangle\)

全部列车驶入后,出口依次从轨 4 弹出 1,从轨 3 弹出 2, 3,从轨 2 弹出 4, 5, 6, 7,从轨 1 弹出 8, 9,完美合成递增序列 \(1 \dots 9\)。
使用的轨道总数恰为 4 条。

正确答案:C


【真题拓展 1】2014 年 408 第 3 题 · 循环队列基本操作与队满队空条件

题目
循环队列放在一维数组 \(A[0..M-1]\)$ \text{中,end1 指向队头元素,end2 指向队尾元素的后一个位置。假设队列两端均可进行入队和出队操作,队列中最多能容纳} $\(M-1\) 个元素。初始时为空。下列判断队空和队满的条件中,正确的是( )。
A. 队空:end1 == end2;队满:end1 == (end2 + 1) mod M
B. 队空:end1 == end2;队满:end2 == (end1 + 1) mod (M - 1)
C. 队空:end1 == (end1 + 1) mod M;队满:end1 == (end2 + 1) mod M
D. 队空:end1 == (end2 + 1) mod M;队满:end2 == (end1 + 1) mod (M - 1)

【解析】

  • 指针语义审定:end1 对应队头指针 front,指示当前队头元素;end2 对应队尾指针 rear,指示队尾元素之后的一个空闲存储单元。
  • 初始空队状态:两指针重合指向同一位置,即 end1 == end2。
  • 队满状态分析:题目明确限定最多容纳 \(M-1\) 个元素,采用的是典型的“牺牲一个单元”消歧机制。当 end2 顺时针步进 1 个单元后与 end1 发生重合时,表明有效存储已达上限,判定为队满: $\(end1 == (end2 + 1) \pmod M\)$
  • 选项 B、D 中模数错误采用 \(M-1\)$ \text{,违背了物理数组总长度为} $\(M\) 的环绕周期。

正确答案:A


【真题拓展 2】2011 年 408 第 3 题 · 循环队列指针语义变体初值推导

题目
已知循环队列存储在一维数组 \(A[0..n-1]\)$ \text{中,且队列非空时 front 和 rear 分别指向队头元素和队尾元素。若初始时队列空,且要求第一个进入队列的元素存储在} $\(A[0]\) 处,则初始时 front 和 rear 的值分别是( )。
A. \(0, 0\)          B. \(0, n-1\)          C. \(n-1, 0\)          D. \(n-1, n-1\)

【解析】

  • 核心指针语义审定:题目明确指出 rear 指向队尾元素本身(属于变体 B,而非指向队尾后一位置)。
  • 动作逆向追踪:
  • 第一个元素入队后存放在 \(A[0]\),此时队中仅有这一个元素。
  • 队头元素为 \(A[0]\),故操作完成后必有 front == 0;
  • 队尾元素亦为 \(A[0]\),故操作完成后必有 rear == 0。
  • 入队流程反推:
  • 因为 rear 指向当前队尾元素,因此执行入队操作时,必须先将队尾游标顺时针推进 1 位,随后再写入数据: $\(rear_{\text{new}} = (rear_{\text{init}} + 1) \pmod n\)$
  • 为使更新后的 \(rear_{\text{new}} = 0\)$ \text{,初始值必须满足} $\((rear_{\text{init}} + 1) \equiv 0 \pmod n\)$ \text{,解得} $\(rear_{\text{init}} = n - 1\);
  • 对于首次入队,队头指针 front 无需位移,保持初值 front = 0。

正确答案:B


四、 核心解题套路与易错陷阱

1. 核心解题套路

套路 1:双端队列输出合法性的“端点因果反推法”

面对双端队列出队序列辨析题,无需盲目穷举全局操作,采用因果反推法则: 1. 抓输出首元素:确定该元素弹出时刻,前序所有元素在队列中的分布位置; 2. 定同侧相对序:明确受限端点(例如输入受限端点 A)。所有被判定由该端点入队的元素集合,在其出队流中必须严格服从单调先来先出次序; 3. 查交叉逆序矛盾:若输出序列中出现属于同端入队的元素发生了后入队者先出队、且其间无合法分支路径插入的情况,即可迅速排查并锁定错误选项。

套路 2:多轨列车调度极速判定法则

遇到列车调度、轨道调度或偏序排队模型,直接套用极值公式: * 若要求按递增序列出站:最少平行轨道数严格等于输入序列的最长下降子序列(LDS)长度; * 若要求按递减序列出站:最少平行轨道数严格等于输入序列的最长递增子序列(LIS)长度。 在考场草稿纸上,直接圈画单调下降(或递增)的最长子序列,数出其所含元素个数,即为最终答案。


2. 易错陷阱防范

陷阱 1:循环队列下标逆向移动与负数模运算陷阱

在双端循环队列中,若从队头逆向插入元素,指针需逆时针回退 1 位。在高级语言(如 C/C++)中,负数取模结果可能为负数(例如 -1 % 8 == -1,而非数学上的 \(7\))。
防御准则:向前移动指针时,严禁直接书写 front = (front - 1) % MaxSize,必须显式加上模数基数以修正负数偏移: $\(front = (front - 1 + MaxSize) \pmod{MaxSize}\)$

陷阱 2:单链表队列出队清空时队尾指针悬挂(Dangling Pointer)

在编写单链表队列出队算法时,若出队前队内仅剩最后一个数据结点(此时 front->next == rear),执行出队释放后,若未同步修改 rear 指针,rear 将继续指向已释放的非法内存地址,形成悬挂野指针。
防御准则:当出队导致队列变为空队时,必须执行重置逻辑:if (rear == p) rear = front;。

陷阱 3:列车调度模型的物理通道混淆

部分题目将列车调度背景由“两端通行的轨道(队列 FIFO)”更换为“一端封闭的调车死胡同(栈 LIFO)”: * 若调车线为单端开闭的存车线(栈道),则列车满足后进先出(LIFO),合法调度序列服从卡特兰数判定规则,不可盲目套用 Dilworth 定理的 LDS 轨道划分。


五、 考点速记清单

1. 循环队列三种消歧方案横向对比表

方案类别 额外空间开销 队空判断条件 队满判断条件 有效元素个数公式
方案一:牺牲一个存储单元 浪费 1 个物理单元 front == rear (rear + 1) % M == front (rear - front + M) % M
方案二:设置计数器 size 增加 1 个 int 变量 size == 0 size == M size
方案三:设置操作标记 tag 增加 1 个状态位 front == rear && tag == 0 front == rear && tag == 1 分支判定(见正文公式)

2. 关键核心公式与极值口诀

  • 环形距离模运算公式: $\(\text{Length} = (rear - front + MaxSize) \pmod{MaxSize}\)$
  • Dilworth 列车调度定理: $$ \text{FIFO 轨道递增出站最少轨道数} = \text{输入序列 LDS 长度} $$
  • 考场极速避坑准则:
  • 审题必先看指针定义:指向“当前尾”还是指向“下一空”;
  • 指针前移防负模:一律加上 + MaxSize;
  • 链队判空查头指:尾指针删除需防悬挂。