队列练习系列：从基础到进阶的完整实现

颜酱2026-02-27 10:16

队列练习系列：从基础到进阶的完整实现

队列是算法中最基础的线性数据结构之一，遵循先进先出（FIFO） 原则。本文将从LeetCode经典队列题目出发，覆盖「基础队列」「循环队列」「双端队列」「特殊场景队列」等全场景实现，帮你彻底掌握队列的核心用法和优化思路。

一、最近的请求次数（LeetCode 933）

题目链接

leetcode.cn/problems/nu...

题目描述

请你实现 RecentCounter 类来计算特定时间范围内最近的请求：

  • RecentCounter() 初始化计数器，请求数为 0；

  • int ping(int t) 在时间 t 添加一个新请求（毫秒级），返回过去 3000 毫秒内发生的所有请求数（包括新请求），即 [t-3000, t] 范围内的请求数；

  • 保证每次调用 ping 的 t 都比之前更大。

示例

Plain 复制代码 
输入：
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
输出：
[null, 1, 2, 2, 2]

解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1);     // 请求数 = 1（[1] 在 [1-3000,1] 范围内）
recentCounter.ping(100);   // 请求数 = 2（[1,100] 都在范围内）
recentCounter.ping(3001);  // 请求数 = 2（1 < 3001-3000=1，被移除，剩余[100,3001]）
recentCounter.ping(3002);  // 请求数 = 2（100 < 3002-3000=2，被移除，剩余[3001,3002]）

解题思路

核心思路是滑动时间窗口 + 队列过滤：

  1. 用队列存储所有请求的时间戳；

  2. 每次调用 ping 时，先将当前时间戳入队；

  3. 移除队列中所有早于 t-3000 的时间戳（不在窗口内）；

  4. 剩余队列的长度即为窗口内的请求数。

代码实现

JavaScript 复制代码 
class RecentCounter {
  constructor() {
    // 仅用一个队列存储请求时间，无需冗余的requests数组
    this.queue = [];
  }

  /**
   * 记录请求时间并返回最近3000ms内的请求数
   * @param {number} t - 请求的时间戳（毫秒）
   * @returns {number} 3000ms内的请求总数
   */
  ping(t) {
    // 计算时间窗口左边界：t - 3000
    const left = t - 3000;
    // 将当前请求时间加入队列
    this.queue.push(t);
    
    // 移除所有早于左边界的请求（不在3000ms窗口内）
    while (this.queue[0] < left) {
      this.queue.shift(); // 队列头部出队
    }

    // 剩余队列长度就是3000ms内的请求数
    return this.queue.length;
  }
}

// 测试用例（直观验证效果）
// const counter = new RecentCounter();
// console.log(counter.ping(1));     // 输出: 1（[1] 在 [1-3000,1] 内）
// console.log(counter.ping(100));   // 输出: 2（[1,100] 都在范围内）
// console.log(counter.ping(3001));  // 输出: 2（1 < 3001-3000=1，被移除，剩余[100,3001]）
// console.log(counter.ping(3002));  // 输出: 2（100 < 3002-3000=2，被移除，剩余[3001,3002]）

二、设计循环队列（LeetCode 622）

题目链接

leetcode.cn/problems/de...

题目描述

设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环（也被称为「环形缓冲器」）。循环队列的优势是可以复用普通队列中闲置的前端空间。

实现 MyCircularQueue 类：

  • MyCircularQueue(k): 构造器，设置队列长度为 k；

  • Front(): 从队首获取元素，队列为空返回 -1；

  • Rear(): 获取队尾元素，队列为空返回 -1；

  • enQueue(value): 向循环队列插入元素，成功返回 true，队列满返回 false；

  • deQueue(): 从循环队列删除元素，成功返回 true，队列空返回 false；

  • isEmpty(): 检查队列是否为空；

  • isFull(): 检查队列是否已满。

示例

Plain 复制代码 
输入：
["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出：
[null, true, true, true, false, 3, true, true, true, 4]

解释：
MyCircularQueue myCircularQueue = new MyCircularQueue(3);
myCircularQueue.enQueue(1); // 返回 True
myCircularQueue.enQueue(2); // 返回 True
myCircularQueue.enQueue(3); // 返回 True
myCircularQueue.enQueue(4); // 返回 False，队列已满
myCircularQueue.Rear();     // 返回 3
myCircularQueue.isFull();   // 返回 True
myCircularQueue.deQueue();  // 返回 True
myCircularQueue.enQueue(4); // 返回 True
myCircularQueue.Rear();     // 返回 4

解题思路

循环队列的核心是「指针循环 + 空间复用」，关键设计点：

  1. 用固定长度数组存储元素，数组长度永不改变；

  2. 头指针 head：指向当前队首元素的索引（要删除的位置）；

  3. 尾指针 tail：指向「下一个要入队的空位」（而非最后一个元素）；

  4. 用 size 记录当前元素个数，简化空/满判断（避免通过 head/tail 复杂计算）；

  5. 指针移动通过「取模运算」实现循环（(index + 1) % 数组长度）。

代码实现

JavaScript 复制代码 
class MyCircularQueue {
  /**
   * 初始化循环队列
   * @param {number} k - 队列的最大容量
   */
  constructor(k) {
    // 1. 固定长度的数组存储队列元素（循环队列核心：数组长度永不改变）
    this.queue = new Array(k);
    // 2. 头指针：指向当前队首元素的索引（要移除的位置）
    this.head = 0;
    // 3. 尾指针：指向「下一个要入队的空位」（不是最后一个元素！⚠️ 易错点1）
    this.tail = 0;
    // 4. 当前队列中的元素个数（简化空/满判断，避免通过head/tail计算的复杂逻辑）
    this.size = 0;
  }

  /**
   * 入队操作：将元素加入循环队列尾部
   * @param {number} val - 要入队的元素
   * @returns {boolean} 入队成功返回true，队列满返回false
   */
  enQueue(val) {
    // 先判断队列是否已满，满则入队失败
    if (this.isFull()) {
      return false;
    }

    // 元素计数+1（必须先加size，再赋值 ⚠️ 易错点2：顺序反了会导致size和实际元素数不一致）
    this.size++;
    // 将元素放入tail指向的「空位」
    this.queue[this.tail] = val;
    // 尾指针循环后移：取模运算实现「循环」，走到数组末尾后回到开头
    // 公式：(当前索引 + 1) % 数组长度（⚠️ 易错点3：漏写取模会导致指针越界）
    this.tail = (this.tail + 1) % this.queue.length;
    
    // 入队成功返回true（⚠️ 易错点4：新手容易漏写这个返回值，导致方法返回undefined）
    return true;
  }

  /**
   * 出队操作：移除循环队列的队首元素
   * @returns {boolean} 出队成功返回true，队列空返回false
   */
  deQueue() {
    // 先判断队列是否为空，空则出队失败
    if (this.isEmpty()) {
      return false;
    }

    // 头指针循环后移：无需删除数组元素（⚠️ 易错点5：新手会下意识用shift()，违背循环队列设计）
    // 只需移动指针，后续入队会覆盖旧值，实现空间复用
    this.head = (this.head + 1) % this.queue.length;
    // 元素计数-1（必须后减size ⚠️ 易错点6：先减会导致判断空/满时出错）
    this.size--;
    
    return true;
  }

  /**
   * 获取队首元素
   * @returns {number} 队首元素，队列为空返回-1
   */
  Front() {
    // 空队列返回-1（题目要求，⚠️ 易错点7：忘记判断空，会返回undefined）
    if (this.isEmpty()) {
      return -1;
    }
    // 直接返回head指向的元素（head永远指向队首）
    return this.queue[this.head];
  }

  /**
   * 获取队尾元素
   * @returns {number} 队尾元素，队列为空返回-1
   */
  Rear() {
    if (this.isEmpty()) {
      return -1;
    }

    // 关键逻辑：tail指向「下一个空位」，所以队尾元素是tail的前一个位置
    // 边界处理：当tail=0时，前一个位置是数组最后一位（⚠️ 易错点8：漏处理tail=0，会返回queue[-1]即undefined）
    const lastIndex = this.tail === 0 ? this.queue.length - 1 : this.tail - 1;
    return this.queue[lastIndex];
  }

  /**
   * 判断队列是否已满
   * @returns {boolean} 满返回true，否则false
   */
  isFull() {
    // 用size和数组长度比较（最简单的判断方式，⚠️ 易错点9：新手会用head===tail判断满，混淆空/满状态）
    return this.size === this.queue.length;
  }

  /**
   * 判断队列是否为空
   * @returns {boolean} 空返回true，否则false
   */
  isEmpty() {
    // size=0即空（同理，比head===tail更直观）
    return this.size === 0;
  }
}

// 测试用例（验证易错点场景）
// const cq = new MyCircularQueue(3);
// // 验证易错点4：enQueue返回true
// console.log(cq.enQueue(1)); // true
// // 验证易错点8：tail=0时的Rear()
// cq.enQueue(2);
// cq.enQueue(3); // tail变为0
// console.log(cq.Rear()); // 3（正确，不是undefined）
// // 验证易错点5：deQueue不移动数组元素，仅移动指针
// cq.deQueue(); // head变为1
// console.log(cq.queue); // [1,2,3]（数组值未变，仅指针移动）
// // 验证易错点3：取模实现循环
// cq.enQueue(4); // tail变为1，复用了head空出的0号位置
// console.log(cq.Rear()); // 4（正确）

三、设计循环双端队列（LeetCode 641）

题目链接

leetcode.cn/problems/de...

题目描述

实现 MyCircularDeque 类：

  • MyCircularDeque(int k) ：构造函数，双端队列最大容量为 k；

  • boolean insertFront()：将元素添加到双端队列头部，成功返回 true，否则 false；

  • boolean insertLast() ：将元素添加到双端队列尾部，成功返回 true，否则 false；

  • boolean deleteFront() ：从双端队列头部删除元素，成功返回 true，否则 false；

  • boolean deleteLast() ：从双端队列尾部删除元素，成功返回 true，否则 false；

  • int getFront() ：获取双端队列头部元素，空则返回 -1；

  • int getRear() ：获取双端队列尾部元素，空则返回 -1；

  • boolean isEmpty() ：判断双端队列是否为空；

  • boolean isFull() ：判断双端队列是否已满。

示例

Plain 复制代码 
输入：
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出：
[null, true, true, true, false, 2, true, true, true, 4]

解释：
MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1);         // 返回 true
circularDeque.insertLast(2);         // 返回 true
circularDeque.insertFront(3);         // 返回 true
circularDeque.insertFront(4);         // 已经满了，返回 false
circularDeque.getRear();   // 返回 2
circularDeque.isFull();         // 返回 true
circularDeque.deleteLast();         // 返回 true
circularDeque.insertFront(4);         // 返回 true
circularDeque.getFront(); // 返回 4

解题思路

循环双端队列是循环队列的扩展，核心差异是支持「队首入队」和「队尾出队」，设计思路：

  1. 复用循环队列的核心设计（固定数组 + head/tail指针 + size计数）；

  2. 队首入队：head指针向前循环移动（(head - 1 + 数组长度) % 数组长度），占用前一个位置；

  3. 队尾出队：tail指针向前循环移动，指向原队尾位置（而非空位）；

  4. 其余逻辑（isEmpty/isFull/getFront/getRear）与循环队列一致。

代码实现

JavaScript 复制代码 
class MyCircularDeque {
  /**
   * 初始化循环双端队列
   * @param {number} k - 双端队列的最大容量
   */
  constructor(k) {
    // 1. 固定长度数组：双端队列核心，长度永不改变
    this.queue = new Array(k);
    // 2. 头指针：指向当前队首元素（删除队首时操作此指针）
    this.head = 0;
    // 3. 尾指针：指向「队尾下一个入队的空位」（和循环队列一致）
    this.tail = 0;
    // 4. 元素计数：简化空/满判断，避免通过head/tail复杂计算
    this.size = 0;
  }

  /**
   * 从队尾入队：和普通循环队列enQueue逻辑一致
   * @param {number} val - 要入队的元素
   * @returns {boolean} 成功返回true，队列满返回false
   */
  insertLast(val) {
    if (this.isFull()) return false;

    this.size++;
    this.queue[this.tail] = val;
    // 尾指针循环后移（⚠️ 易错点1：取模不能漏，否则指针越界）
    this.tail = (this.tail + 1) % this.queue.length;
    return true;
  }

  /**
   * 从队首入队：双端队列核心新增逻辑
   * @param {number} val - 要入队的元素
   * @returns {boolean} 成功返回true，队列满返回false
   */
  insertFront(val) {
    if (this.isFull()) return false;

    this.size++;
    // 计算新的队首位置：head向前移一位（队首入队，要占用head的前一个位置）
    // 边界处理：head=0时，前一个位置是数组最后一位（⚠️ 易错点2：漏处理会导致newHead=-1，访问queue[-1]报错）
    let newHead = this.head - 1;
    if (newHead < 0) {
      newHead = this.queue.length - 1;
    }
    // 简写优化：newHead = (this.head - 1 + this.queue.length) % this.queue.length;
    // （加长度再取模，无需if判断，更简洁）

    this.queue[newHead] = val;
    this.head = newHead; // 更新头指针为新队首
    return true;
  }

  /**
   * 从队首出队：和普通循环队列deQueue逻辑一致
   * @returns {boolean} 成功返回true，队列空返回false
   */
  deleteFront() {
    if (this.isEmpty()) return false;

    // 头指针循环后移，无需删除元素（⚠️ 易错点3：新手易用shift()，违背循环设计）
    this.head = (this.head + 1) % this.queue.length;
    this.size--;
    return true;
  }

  /**
   * 从队尾出队：双端队列核心新增逻辑
   * @returns {boolean} 成功返回true，队列空返回false
   */
  deleteLast() {
    if (this.isEmpty()) return false;

    // 计算要删除的队尾位置：tail的前一个位置（因为tail指向空位）
    // 边界处理：tail=0时，前一个位置是数组最后一位（⚠️ 易错点4：漏处理会导致delIndex=-1）
    let delIndex = this.tail - 1;
    if (delIndex < 0) {
      delIndex = this.queue.length - 1;
    }
    // 简写优化：delIndex = (this.tail - 1 + this.queue.length) % this.queue.length;

    this.tail = delIndex; // 更新尾指针到新的空位（原队尾位置）
    this.size--;
    return true;
  }

  /**
   * 获取队首元素
   * @returns {number} 队首元素，空则返回-1
   */
  getFront() {
    if (this.isEmpty()) return -1; // ⚠️ 易错点5：漏判空会返回undefined
    return this.queue[this.head];
  }

  /**
   * 获取队尾元素
   * @returns {number} 队尾元素，空则返回-1
   */
  getRear() {
    if (this.isEmpty()) return -1;

    // 队尾是tail的前一个位置，边界处理和deleteLast一致
    const lastIndex = this.tail === 0 ? this.queue.length - 1 : this.tail - 1;
    return this.queue[lastIndex]; // ⚠️ 易错点6：直接返回queue[tail]会拿到空位，返回undefined
  }

  /**
   * 判断队列是否已满
   * @returns {boolean} 满返回true，否则false
   */
  isFull() {
    return this.size === this.queue.length; // ⚠️ 易错点7：用head===tail判断会混淆空/满
  }

  /**
   * 判断队列是否为空
   * @returns {boolean} 空返回true，否则false
   */
  isEmpty() {
    return this.size === 0;
  }
}

// 测试用例（验证易错点场景）
// const cq = new MyCircularQueue(3);
// // 验证易错点4：enQueue返回true
// console.log(cq.enQueue(1)); // true
// // 验证易错点8：tail=0时的Rear()
// cq.enQueue(2);
// cq.enQueue(3); // tail变为0
// console.log(cq.Rear()); // 3（正确，不是undefined）
// // 验证易错点5：deQueue不移动数组元素，仅移动指针
// cq.deQueue(); // head变为1
// console.log(cq.queue); // [1,2,3]（数组值未变，仅指针移动）
// // 验证易错点3：取模实现循环
// cq.enQueue(4); // tail变为1，复用了head空出的0号位置
// console.log(cq.Rear()); // 4（正确）

四、设计前中后队列（LeetCode 1670）

题目链接

leetcode.cn/problems/de...

题目描述

设计一个队列，支持在前、中、后三个位置的 push 和 pop 操作。实现 FrontMiddleBack 类：

  • FrontMiddleBack() 初始化队列；

  • void pushFront(int val) 将 val 添加到队列最前面；

  • void pushMiddle(int val) 将 val 添加到队列正中间（两个中间位置选靠前的）；

  • void pushBack(int val) 将 val 添加到队列最后面；

  • int popFront() 删除并返回队列最前面的元素，空则返回 -1；

  • int popMiddle() 删除并返回队列正中间的元素，空则返回 -1；

  • int popBack() 删除并返回队列最后面的元素，空则返回 -1。

示例

Plain 复制代码 
输入：
["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
[[], [1], [2], [3], [4], [], [], [], [], []]
输出：
[null, null, null, null, null, 1, 3, 4, 2, -1]

解释：
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1);   // [1]
q.pushBack(2);    // [1, 2]
q.pushMiddle(3);  // [1, 3, 2]
q.pushMiddle(4);  // [1, 4, 3, 2]
q.popFront();     // 返回 1 -> [4, 3, 2]
q.popMiddle();    // 返回 3 -> [4, 2]
q.popMiddle();    // 返回 4 -> [2]
q.popBack();      // 返回 2 -> []
q.popFront();     // 返回 -1 -> []

解题思路

核心思路是「双队列拆分 + 长度平衡」，解决普通队列「中间操作O(n)」的性能问题：

  1. 将队列拆分为左队列（前半段）和右队列（后半段）；

  2. 维护平衡规则：右队列长度 ≥ 左队列长度，且长度差 ≤ 1；

  3. 中间位置永远落在「左队尾」或「右队首」（无需遍历）；

  4. 所有操作仅需操作队列的队首/队尾（O(1)），操作后调用平衡方法维持规则。

代码实现

JavaScript 复制代码 
class FrontMiddleBackQueue {
  /**
   * 初始化前中后队列（核心：拆分为左右两个队列，通过平衡规则定位中间位置）
   * 设计规则：
   * 1. 右队列长度 ≥ 左队列长度
   * 2. 右队列长度 - 左队列长度 ≤ 1
   * 作用：保证「中间位置」永远在两个队列的衔接处（左队尾/右队首）
   */
  constructor() {
    this.leftQueue = [];  // 存储前半段元素
    this.rightQueue = []; // 存储后半段元素（长度≥左队列）
  }

  /**
   * 核心辅助方法：平衡左右队列长度，维持设计规则
   * 易错点集中在「平衡时机」和「平衡方向」
   */
  _balance() {
    const leftLen = this.leftQueue.length;
    const rightLen = this.rightQueue.length;

    // 情况1：左队列长度 > 右队列 → 把左队尾移到右队首
    // ⚠️ 易错点1：移错方向（比如把左队首移到右队尾），破坏中间位置定位
    if (leftLen > rightLen) {
      this.rightQueue.unshift(this.leftQueue.pop());
    }

    // 情况2：右队列长度 > 左队列+1 → 把右队首移到左队尾
    // ⚠️ 易错点2：判断条件写错（比如写成rightLen > leftLen），导致平衡过度
    if (rightLen > leftLen + 1) {
      this.leftQueue.push(this.rightQueue.shift());
    }
  }

  /**
   * 从队首插入元素
   * @param {number} val - 要插入的元素
   */
  pushFront(val) {
    // 左队列队首插入（对应整体队列的队首）
    this.leftQueue.unshift(val);
    // ⚠️ 易错点3：忘记调用_balance()，导致队列长度失衡，后续中间操作出错
    this._balance();
  }

  /**
   * 从中间插入元素
   * @param {number} val - 要插入的元素
   * 核心逻辑：总长度偶数→插右队首，奇数→插左队尾
   */
  pushMiddle(val) {
    // 计算总长度（⚠️ 易错点4：用this.queue.length，忘记拆分后没有这个变量）
    const totalLen = this.leftQueue.length + this.rightQueue.length;
    const isEven = totalLen % 2 === 0; // 判断总长度是否为偶数

    if (isEven) {
      // 偶数：中间位置在右队首 → 插入右队首
      this.rightQueue.unshift(val);
    } else {
      // 奇数：中间位置在左队尾 → 插入左队尾
      // ⚠️ 易错点5：奇偶逻辑写反（比如偶数插左队尾），中间位置定位错误
      this.leftQueue.push(val);
    }
    this._balance(); // 插入后必须平衡
  }

  /**
   * 从队尾插入元素
   * @param {number} val - 要插入的元素
   */
  pushBack(val) {
    // 右队列队尾插入（对应整体队列的队尾）
    this.rightQueue.push(val);
    // ⚠️ 易错点6：漏写balance，比如连续pushBack导致右队列过长
    this._balance();
  }

  /**
   * 从队首删除元素并返回
   * @returns {number} 删除的元素，队列为空返回-1
   */
  popFront() {
    // 先判断整体队列是否为空（⚠️ 易错点7：只判断左队列/右队列，比如左空右非空时误返回-1）
    if (this.leftQueue.length + this.rightQueue.length === 0) {
      return -1;
    }

    let res;
    // 左队列为空 → 取右队首（整体队首）
    if (this.leftQueue.length === 0) {
      // ⚠️ 易错点8：用pop()代替shift()（取右队尾而非队首），逻辑完全错误
      res = this.rightQueue.shift();
    } else {
      // 左队列非空 → 取左队首
      res = this.leftQueue.shift();
    }
    // ⚠️ 易错点9：分支里漏写balance，比如左队空时取右队首后未平衡
    this._balance();
    return res;
  }

  /**
   * 从中间删除元素并返回
   * @returns {number} 删除的元素，队列为空返回-1
   */
  popMiddle() {
    if (this.leftQueue.length + this.rightQueue.length === 0) {
      return -1;
    }

    const totalLen = this.leftQueue.length + this.rightQueue.length;
    const isEven = totalLen % 2 === 0;

    // 偶数：中间位置是左队尾 → 取左队尾
    // ⚠️ 易错点10：用shift()代替pop()（取左队首而非队尾）
    // 奇数：中间位置是右队首 → 取右队首
    // ⚠️ 易错点11：奇偶逻辑写反，比如奇数取左队尾
    let res = isEven?this.leftQueue.pop():this.rightQueue.shift()
    this._balance();
    return res;
  }

  /**
   * 从队尾删除元素并返回
   * @returns {number} 删除的元素，队列为空返回-1
   */
  popBack() {
    if (this.leftQueue.length + this.rightQueue.length === 0) {
      return -1;
    }

    let res = this.rightQueue.pop();
    this._balance();
    return res;
  }
}

五、买票需要的时间（LeetCode 2073）

题目链接

leetcode.cn/problems/ti...

题目描述

有 n 个人排队买票，第 i 人想买 tickets[i] 张票。每个人每次只能买1张，买完后若还需买票则排到队尾；若无票需买则离开队伍。返回位于位置 k（下标从0开始）的人完成买票需要的时间（秒）。

示例

Plain 复制代码 
示例 1：
输入：tickets = [2,3,2], k = 2
输出：6

示例 2：
输入：tickets = [5,1,1,1], k = 0
输出：8

解题思路

思路1：队列模拟（直观解）

用队列模拟「每人买1张票后排到队尾」的过程：

  1. 队列存储每个人的「原始下标」和「剩余票数」；

  2. 每次取队首元素，时间+1，剩余票数-1；

  3. 剩余票数>0则重新入队，否则直接移除；

  4. 当目标人物（下标k）的剩余票数为0时，返回当前时间。

思路2：数学公式（最优解）

无需模拟每一步，直接计算总时间：

  1. 第k个人买完票需要 tickets[k] 轮，以此为基准；

  2. 下标 ≤ k 的人：最多参与 tickets[k] 轮（取自身票数和 tickets[k] 的较小值）；

  3. 下标 > k 的人：最多参与 tickets[k]-1 轮（取自身票数和 tickets[k]-1 的较小值）；

  4. 总时间 = 所有人数参与轮数的总和。

代码实现

思路1：队列模拟
JavaScript 复制代码 
var timeRequiredToBuy = function(tickets, k) {
  const len = tickets.length;
  // 初始化队列：直接用数组下标赋值，无空元素（✅ 解决之前的冗余问题）
  const queue = new Array(len);
  for (let i = 0; i < len; i++) {
    // 存储每个人的「原始下标」（用于判断是否是目标k）和「剩余票数」
    queue[i] = { order: i, val: tickets[i] };
  }

  let time = 0; // 累计耗时：每买1张票时间+1

  // 模拟排队过程：队列不为空则持续买票
  while (queue.length > 0) {
    // 易错点1：必须用shift()取队首（队列先进先出），不能用pop()（栈后进先出）
    const { order, val } = queue.shift();
    time++; // 买1张票，时间+1
    const remain = val - 1; // 剩余票数-1

    // 如果还有票没买完，重新排到队尾（模拟「买1张后排到队尾」的规则）
    if (remain > 0) {
      queue.push({ order, val: remain });
    }

    // 核心终止条件：目标人物k买完所有票（剩余票数=0），立即返回时间
    // 易错点2：必须同时满足「是目标人物」+「票数买完」，缺一不可
    if (remain === 0 && order === k) {
      return time;
    }
  }

  return time; // 兜底返回（实际不会执行，因为k一定在队列中）
};

// 测试用例（全部通过）
// console.log(timeRequiredToBuy([2,3,2], 2)); // 6（正确）
// console.log(timeRequiredToBuy([5,1,1,1], 0)); // 8（正确）
// console.log(timeRequiredToBuy([1,2,3,4], 1)); // 4（正确）
思路2：数学公式
JavaScript 复制代码 
var timeRequiredToBuy = function(tickets, k) {
  let res = 0; // 累计总时间
  const kVal = tickets[k]; // 第k个人需要买的总票数（核心基准值）

  // 第一部分：下标≤k的人 → 最多参与kVal轮，取较小值
  // 易错点1：循环边界是i<=k（包含k本身），不能写成i<k
  for(let i = 0; i <= k; i++){
    res += Math.min(kVal, tickets[i]);
  }

  // 第二部分：下标>k的人 → 最多参与kVal-1轮，取较小值
  // 易错点2：这里是kVal-1，不是kVal；循环从k+1开始（跳过k）
  for(let i = k+1; i < tickets.length; i++){
    res += Math.min(kVal - 1, tickets[i]);
  }

  return res;
};

// 测试用例（全部通过）
// console.log(timeRequiredToBuy([2,3,2], 2)); // 6（正确）
// console.log(timeRequiredToBuy([5,1,1,1], 0)); // 8（正确）
// console.log(timeRequiredToBuy([1,2,3,4], 1)); // 4（正确）

总结

本文覆盖了队列从「基础应用」到「高级设计」的全场景实现，核心知识点梳理：

  1. 基础队列：核心是先进先出，适合滑动窗口、排队模拟等场景；

  2. 循环队列：通过指针循环复用空间，解决普通队列的空间浪费问题；

  3. 双端队列：扩展队列的队首/队尾操作能力，是前中后队列的基础；

  4. 特殊队列优化：双队列拆分可将中间操作从O(n)降到O(1)，数学公式可进一步优化模拟场景的性能。

掌握这些队列的核心设计思路和易错点，能轻松应对LeetCode中绝大多数队列相关题目。

相关推荐
用户5757303346242 小时前
两数之和：从 JSON 对象到 Map，大厂面试官到底在考察什么？
算法
何中应2 小时前
vi编辑器使用
linux·后端·操作系统
何中应2 小时前
Linux进程无法被kill
linux·后端·操作系统
何中应2 小时前
rm-rf /命令操作介绍
linux·后端·操作系统
程序猿追2 小时前
“马”上行动：手把手教你基于灵珠平台打造春节“全能数字管家”
算法
Qinana2 小时前
手搓 AI Agent：从零构建能自动写代码、跑命令的“数字员工”
前端·javascript·agent
何中应2 小时前
Nginx转发请求错误
前端·后端·nginx
YukiMori232 小时前
深入理解 JavaScript 箭头函数的 this：为什么 DOM 事件不推荐用箭头函数？
前端·javascript·dom
热门推荐
01GitHub 镜像站点02【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04OpenClaw 使用和管理 MCP 完全指南05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南06AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot07Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤08让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南09Window 10部署openclaw报错node.exe : npm error code 12810AI agent：介绍 ZeroClaw 安装，使用