设计前中后队列 : 图解极简队列解法 [Deque + 纯数组]（含进阶链表）

宫水三叶的刷题日记2023-11-28 10:25

题目描述

这是 LeetCode 上的 1670. 设计前中后队列 ，难度为 中等。

Tag : 「数据结构」、「双端队列」、「队列」、「链表」

请你设计一个队列，支持在前，中，后三个位置的 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。

请注意当有 两个 中间位置的时候，选择靠前面的位置进行操作。比方说：

  • 将 6 添加到 [1, 2, 3, 4, 5] 的中间位置，结果数组为 [1, 2, 6, 3, 4, 5]。
  • 从 [1, 2, 3, 4, 5, 6] 的中间位置弹出元素，返回 3，数组变为 [1, 2, 4, 5, 6]。

示例 1：

scss 复制代码 
输入：
["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 -> [] （队列为空）

提示：

  • <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 < = v a l < = 1 0 9 1 <= val <= 10^9 </math>1<=val<=109
  • 最多调用 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1000 1000 </math>1000 次 pushFront， pushMiddle， pushBack， popFront， popMiddle 和 popBack。

双端队列

只要求在头部或尾部高效插入/弹出元素的话，容易联想到双端队列。

还需要考虑往中间插入/弹出元素的话，会想到使用两个双端队列。

将两个双端队列分别称为 l 和 r，把 l 和 r 拼接起来就是完整元素列表：

由于双端队列本身支持 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 首尾操作，问题的关键在于如何确保涉及 Middle 操作的高效性。

我们可以设计一个 update 方法，用于确保两队列的相对平衡：

  • 当元素总个数为偶数时，确保两队列元素相等
  • 当元素总个数为奇数时，确保 r 队列比 l 队列元素多一个

如此一来，当我们需要往 Middle 插入元素时，始终往 l 的尾部插入即可；而当需要读取 Middle 位置元素时，根据两队列的元素个数关系决定是从 l 的尾部还是从 r 的头部取元素。

以下是对上述代码中几个操作的简短实现说明：

  • pushFront：将元素添加到 l 队列的头部，调用 update 保持队列平衡
  • pushMiddle：将元素添加到 l 队列的尾部，调用 update 保持队列平衡
  • pushBack：将元素添加到 r 队列的尾部，调用 update 保持队列平衡
  • popFront：若 l 队列不为空，从 l 队列的头部弹出一个元素；否则，从 r 队列的头部弹出一个元素（当且仅当元素个数为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1 时，队列 l 为空，唯一元素在队列 r 中），调用 update 保持队列平衡
  • popMiddle：若 l 队列和 r 队列的大小相等，则从 l 队列的尾部弹出一个元素；否则，从 r 队列的头部弹出一个元素。调用 update 保持队列平衡
  • popBack：从 r 队列的尾部弹出一个元素，调用 update 保持队列平衡

双端队列的实现，可通过「数组 + 首尾坐标指针」来实现。为方便大家理清脉络，先使用语言自带的 Deque 实现一版。

Java 代码（Deque 版）：

Java 复制代码 
class FrontMiddleBackQueue {
    Deque<Integer> l = new ArrayDeque<>(1010), r = new ArrayDeque<>(1010);
    public void pushFront(int val) {
        l.addFirst(val);
        update();
    }
    public void pushMiddle(int val) {
        l.addLast(val);
        update();
    }
    public void pushBack(int val) {
        r.addLast(val);
        update();
    }
    public int popFront() {
        if (l.size() + r.size() == 0) return -1;
        int ans = l.size() != 0 ? l.pollFirst() : r.pollFirst();
        update();
        return ans;
    }
    public int popMiddle() {
        if (l.size() + r.size() == 0) return -1;
        int ans = l.size() == r.size() ? l.pollLast() : r.pollFirst();
        update();
        return ans;
    }
    public int popBack() {
        if (l.size() + r.size() == 0) return -1;
        int ans = r.pollLast();
        update();
        return ans;
    }
    void update() {
        while (l.size() > r.size()) r.addFirst(l.pollLast());
        while (r.size() - l.size() > 1) l.addLast(r.pollFirst());
    }
}

看过 Deque 实现版本，考虑如何使用数组实现。

各类操作的总调用次数最多为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1000 1000 </math>1000 次，我们可创建大小为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2010 2010 </math>2010 的数组，并从下标 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1010 1010 </math>1010（接近中间位置）开始进行存储，这样无论是从前还是往后存数都不会越界。

使用 lhe 和 lta 代表队列 l 的头部和尾部坐标，使用 rhe 和 rta 代表队列 r 的头部和尾部坐标，所有坐标初始值均为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1100 1100 </math>1100。

需要注意的是，ta（无论是 lta 还是 rta）是严格指向尾部，因此如果要往尾部插数的话，需要先对指针自增（移到下一个空闲位置），再赋值；而 he（无论是 lhe 还是 rhe）是指向实际队列头部的前一位置，需要先赋值再前移。当 he = ta 代表队列为空。

Java 代码（纯数组版）：

Java 复制代码 
class FrontMiddleBackQueue {
    int[] l = new int[2010], r = new int[2010];
    int lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;
    public void pushFront(int val) {
        l[lhe--] = val;
        update();
    }
    public void pushMiddle(int val) {
        l[++lta] = val;
        update();
    }
    public void pushBack(int val) {
        r[++rta] = val;
        update();
    }
    public int popFront() {
        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
        int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];
        update();
        return ans;
    }
    public int popMiddle() {
        if (getSize(lhe, lta) + getSize(rhe, rta) == 0) return -1;
        int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];
        update();
        return ans;
    }
    public int popBack() {
        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
        int ans = r[rta--];
        update();
        return ans;
    }
    int getSize(int he, int ta) {
        return ta - he;
    }
    void update() {
        while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];
        while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];
    }
}

C++ 代码：

C++ 复制代码 
class FrontMiddleBackQueue {
public:
    int l[2010], r[2010], lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;
    void pushFront(int val) {
        l[lhe--] = val;
        update();
    }
    void pushMiddle(int val) {
        l[++lta] = val;
        update();
    }
    void pushBack(int val) {
        r[++rta] = val;
        update();
    }
    int popFront() {
        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
        int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];
        update();
        return ans;
    }
    int popMiddle() {
        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
        int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];
        update();
        return ans;
    }
    int popBack() {
        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
        int ans = r[rta--];
        update();
        return ans;
    }
    int getSize(int he, int ta) {
        return ta - he;
    }
    void update() {
        while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];
        while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];
    }
};

Python 代码：

Python 复制代码 
class FrontMiddleBackQueue:
    def __init__(self):
        self.l, self.r = [0] * 2010, [0] * 2010
        self.r = [0] * 2010
        self.lhe, self.lta, self.rhe, self.rta = 1010, 1010, 1010, 1010

    def pushFront(self, val: int) -> None:
        self.l[self.lhe] = val
        self.lhe -= 1
        self.update()

    def pushMiddle(self, val: int) -> None:
        self.lta += 1
        self.l[self.lta] = val
        self.update()

    def pushBack(self, val: int) -> None:
        self.rta += 1
        self.r[self.rta] = val
        self.update()

    def popFront(self) -> int:
        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
            return -1
        if self.getSize(self.lhe, self.lta) != 0:
            self.lhe += 1
            ans = self.l[self.lhe]
        else:
            self.rhe += 1
            ans = self.r[self.rhe]
        self.update()
        return ans

    def popMiddle(self) -> int:
        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
            return -1
        if self.getSize(self.lhe, self.lta) == self.getSize(self.rhe, self.rta):
            ans = self.l[self.lta]
            self.lta -= 1
        else:
            self.rhe += 1
            ans = self.r[self.rhe]
        self.update()
        return ans

    def popBack(self) -> int:
        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
            return -1
        ans = self.r[self.rta]
        self.rta -= 1
        self.update()
        return ans

    def getSize(self, he: int, ta: int) -> int:
        return ta - he

    def update(self) -> None:
        while self.getSize(self.lhe, self.lta) > self.getSize(self.rhe, self.rta):
            self.r[self.rhe] = self.l[self.lta]
            self.rhe -= 1
            self.lta -= 1
        while self.getSize(self.rhe, self.rta) - self.getSize(self.lhe, self.lta) > 1:
            self.lta += 1
            self.rhe += 1
            self.l[self.lta] = self.r[self.rhe]

TypeScript 代码：

TypeScript 复制代码 
class FrontMiddleBackQueue {
    private l: number[];
    private r: number[];
    private lhe: number;
    private lta: number;
    private rhe: number;
    private rta: number;
    constructor() {
        this.l = Array(2010).fill(0), this.r = Array(2010).fill(0);
        this.lhe = 1010, this.lta = 1010, this.rhe = 1010, this.rta = 1010;
    }
    pushFront(val: number): void {
        this.l[this.lhe--] = val;
        this.update();
    }
    pushMiddle(val: number): void {
        this.l[++this.lta] = val;
        this.update();
    }
    pushBack(val: number): void {
        this.r[++this.rta] = val;
        this.update();
    }
    popFront(): number {
        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
        const ans = this.getSize(this.lhe, this.lta) != 0 ? this.l[++this.lhe] : this.r[++this.rhe];
        this.update();
        return ans;
    }
    popMiddle(): number {
        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
        const ans = this.getSize(this.lhe, this.lta) == this.getSize(this.rhe, this.rta) ? this.l[this.lta--] : this.r[++this.rhe];
        this.update();
        return ans;
    }
    popBack(): number {
        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
        const ans = this.r[this.rta--];
        this.update();
        return ans;
    }
    private getSize(he: number, ta: number): number {
        return ta - he;
    }
    private update(): void {
        while (this.getSize(this.lhe, this.lta) > this.getSize(this.rhe, this.rta)) this.r[this.rhe--] = this.l[this.lta--];
        while (this.getSize(this.rhe, this.rta) - this.getSize(this.lhe, this.lta) > 1) this.l[++this.lta] = this.r[++this.rhe];
    }
}
  • 时间复杂度：所有操作复杂度均为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1)
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n)

进阶

更进一步，使用双向链表并与实现 update 类似效果，维护 Middle 位置的元素节点，同样可实现 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 各项操作，你能完成吗？

与纯数组版相比，使用链表好处在于可严格按需创建。

Java 复制代码 
class Node {
    Node prev, next;
    int val;
    Node (int _val) {
        val = _val;
    }
}
class FrontMiddleBackQueue {
    Node he, ta, mid;
    int lsz, rsz;
    public FrontMiddleBackQueue() {
        he = new Node(-1); ta = new Node(-1);
        he.next = ta; ta.prev = he;
        mid = ta;
        lsz = rsz = 0;
    }
    public void pushFront(int val) {
        Node cur = new Node(val);
        cur.next = he.next;
        cur.prev = he;
        he.next.prev = cur;
        he.next = cur;
        lsz++;
        update();
    }
    public void pushMiddle(int val) {
        Node cur = new Node(val);
        cur.next = mid;
        cur.prev = mid.prev;
        mid.prev.next = cur;
        mid.prev = cur;
        lsz++;
        update();
    }
    public void pushBack(int val) {
        Node cur = new Node(val);
        cur.next = ta;
        cur.prev = ta.prev;
        ta.prev.next = cur;
        ta.prev = cur;
        rsz++;
        update();
    }
    public int popFront() {
        if (lsz + rsz == 0) return -1;
        int ans = he.next.val;
        he.next.next.prev = he;
        he.next = he.next.next;
        lsz--;
        update();
        return ans;
    }
    public int popMiddle() {
        if (lsz + rsz == 0) return -1;
        Node realMid = null;
        if (lsz == rsz) {
            realMid = mid.prev;
            lsz--;
        } else {
            realMid = mid;
            mid = mid.next;
            rsz--;
        }
        int ans = realMid.val;
        realMid.prev.next = realMid.next;
        realMid.next.prev = realMid.prev;
        realMid = realMid.next;
        update();
        return ans;
    }
    public int popBack() {
        if (lsz + rsz == 0) return -1;
        int ans = ta.prev.val;
        ta.prev.prev.next = ta;
        ta.prev = ta.prev.prev;
        rsz--;
        update();
        return ans;
    }
    void update() {
        while (lsz > rsz) {
            mid = mid.prev;
            lsz--; rsz++;
        }
        while (rsz - lsz > 1) {
            mid = mid.next;
            lsz++; rsz--;
        }
        if (lsz + rsz == 1) mid = ta.prev;
        if (lsz + rsz == 0) mid = ta;
    }
}

最后

这是我们「刷穿 LeetCode」系列文章的第 No.1670 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：github.com/SharingSour... 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉

相关推荐
吃杠碰小鸡8 分钟前
commitlint校验git提交信息
前端
monkey_meng27 分钟前
【遵守孤儿规则的External trait pattern】
开发语言·后端·rust
虾球xz39 分钟前
游戏引擎学习第20天
前端·学习·游戏引擎
Estar.Lee42 分钟前
时间操作[计算时间差]免费API接口教程
android·网络·后端·网络协议·tcp/ip
我爱李星璇44 分钟前
HTML常用表格与标签
前端·html
疯狂的沙粒1 小时前
如何在Vue项目中应用TypeScript？应该注意那些点？
前端·vue.js·typescript
小镇程序员1 小时前
vue2 src_Todolist全局总线事件版本
前端·javascript·vue.js
野槐1 小时前
前端图像处理(一)
前端
程序猿阿伟1 小时前
《智能指针频繁创建销毁：程序性能的“隐形杀手”》
java·开发语言·前端
疯狂的沙粒1 小时前
对 TypeScript 中函数如何更好的理解及使用？与 JavaScript 函数有哪些区别？
前端·javascript·typescript
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿