chapter_stack_and_queue/deque/

[giscus[bot]]

chapter_stack_and_queue/deque/

一本动画图解、能运行、可提问的数据结构与算法入门书

https://www.hello-algo.com/chapter_stack_and_queue/deque/

[13422703801]

hi

[rookiexxj]

大佬，我看你在很多地方用了： 在python里是指解释说明吗，就是不影响实际程序运行。
如 self.next: ListNode | None = None

[krahets]

@rookiexxj 是的，可以把它理解为注释，增强可读性的，实际上无法限制变量的类型

[Teamsaa]

我想问一下K神，双向队列的具体操作体现在哪呢，我看大话数据结构中没有讲到这个，有点好奇它的实际应用，因为我细看了这一章节，更像是两个栈拼接在了一起

[krahets]

好问题，的确双向队列就像是栈和队列的组合，或者是两个栈拼在了一起；它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。

示例请见更新的 5.3.3. 双向队列应用

[deeprado]

撤销，如何实现呢，是通过移动指针吗？ 那部分软件支持ctrl+z 和 ctrl+y (比如idea)，具体要如何实现呢

[krahets]

@deeprado 使用两个堆栈，栈 A 用于撤销，栈 B 用于反撤销。

1. 每当用户执行一个操作，将这个操作压入栈 A ，并清空栈 B 。
2. 当用户执行“撤销”时，从栈 A 中弹出最近的操作，并将其压入栈 B 。
3. 当用户执行“反撤销”时，从栈 B 中弹出最近的操作，并将其压入栈 A 。

[PPcattt]

// 当 i 越过数组头部后，回到尾部
return (i + capacity()) % capacity();
怎样算越过头部？直接用i对capacity()取余不可以吗？

[krahets]

当进行头部插入时，有可能会越过数组头部，此时 i = -1 ，直接对 capacity() 取余结果不对，需要先加 capacity() 。详见负数取余定义。

[Eyrum]

array_deque 队尾出队 popLast 方法不需要重设 rear 指针吗？

[Eyrum]

哦，环形数组队列不需要尾指针

[krahets]

确实，用 front 和 size 来维护首尾～

[highlineee]

k神，基于双向链表的实现的图里，step4的popLast应该pop掉5吧？

[krahets]

Hi～ pop 掉的是节点 4 ，也就是上一张图中那个蓝绿色的节点。

[highlineee]

看岔了，感谢K大佬~

[lavamooncake-816]

def pop(self, is_front: bool) -> int:
"""出队操作"""
# 若队列为空，直接返回 None
if self.is_empty():
return None
# 队首出队操作
if is_front:
val: int = self.front.val # 暂存头节点值
# 删除头节点
fnext: ListNode | None = self.front.next
if fnext != None:
fnext.prev = None
self.front.next = None
self.front = fnext # 更新头节点 我想请问一下，这里的第二个if可以换成elif吗

[krahets]

Hi 可以的。因为第一个 if 执行的是 return 操作，所以第二个分支通常写 if ，这样逻辑更清晰，代表第一个分支进行了“提前返回”

[lavamooncake-816]

啊原来是这样，非常感谢快速回复！

[lavamooncake-816]

我想请问一下这部分代码：
fnext: ListNode | None = self.front.next
if fnext != None:
fnext.prev = None
self.front.next = None
self.front = fnext
我理解是，如果 fnext 为空，照样更新 front node 为 None（通过移动指针pop掉front node）。如果 fnext 不为空，通过 ‘fnext.prev = None’ pop 掉 front node，但为什么还要 ‘self.front.next = None’ 呢，这不是将两个元素 pop 掉了嘛，而且也没有更新节点？以及我还想再请问一下，这里为什么不像之前“基于链表实现的队列”中那样，仅通过移动指针 pop 元素，为什么还需要设 None 呢？

[krahets]

这里想要做的是将 front 指向 fnext ，而当 fnext != None 时，我们需要手动断开 front 和 fnext 的双向链接。只移动的话，被删除的节点仍然是可达的，因为这是一条双向链表。

[lavamooncake-816]

啊明白了，非常感谢！

[xiaobao1231]

补充回复None在Python中是没有Next的，也就是没有指针，空指针的意思

[xiaobao1231]

另外原来的self.front一定要指向非空元素吗，感觉直接把下一个节点指向空，self.front为下一个节点就行了吧

[krahets]

@xiaobao1231 Hi，self.front 也可以不指向非空元素，因为已经无法访问到它，在逻辑上它已经不在链表中了。但是可能会导致一些少见的内存回收 Bug ，详见断开连接对内存回收的影响。

[learntochangecode]

感觉这个地方会出bug啊
if (isFront) {
val = front.val; // 暂存头节点值
// 删除头节点
ListNode fNext = front.next;
if (fNext != null) {
fNext.prev = null;
front.next = null;
}
front = fNext; // 更新头节点
如果说这个队列只有一个节点的时候，代码只将front指针移动了，rear指针没有移动，还是指向原来的front。而进行出队操作后，正确的情况是front=rear=null，这段代码的运行结果是front=null，rear指向原来的front，不等于null。
不知道我想的对不对，请大佬指教。

[krahets]

你说的没错，rear 的指向没有被改变。但对于用户而言，访问尾节点需要调用以下函数，而非直接访问变量 rear 。在队列为空时，该函数返回 None ，没有问题。

    def peek_last(self) -> int:
        """访问队尾元素"""
        return None if self.is_empty() else self.rear.val

[learntochangecode]

好的，原来是这样，谢谢解答

[ShcRes]

这种情况下，如果 rear 的指向没有改变，对于内存自动回收是否有影响

[krahets]

@ShcRes 会影响 rear 指向的节点的回收。不过在一个动态的链表中，rear 的指向也在动态变化，所以我感觉可以忽略不计

[CarberryChai]

/* 双向链表节点 */
class ListNode {
    var val: Int // 节点值
    var next: ListNode? // 后继节点引用（指针）
    weak var prev: ListNode? // 前驱节点引用（指针）

    init(val: Int) {
        self.val = val
    }
}

在Swift中为了避免循环引用，是不是加个weak比较好🥹

[nuomi1]

#666 已提交 PR，感谢提醒。

[zhuasdfg]

return (i + capacity()) % capacity();这段代码我看了好久没明白，结果看到了front = index(front - 1);是这个原因吧

[is-liu]

这段代码的作用是实现循环索引。它返回的是 i 与 capacity() 的和模 capacity() 的结果。

具体来说，i 是要计算的索引，capacity() 是容器的容量。将 i 与 capacity() 相加后对 capacity() 取模，相当于将 i 的索引值循环滚动到下一个位置。

例如，如果 i 是 0，capacity() 是 5，那么 (i + capacity()) % capacity() 的结果就是 0。如果 i 是 4，capacity() 还是 5，那么 (i + capacity()) % capacity() 的结果就是 1。这样，无论索引值在哪个位置，都可以循环滚动到下一个位置。

这种循环索引的作用通常是为了在固定大小的容器中实现索引访问，避免出现越界问题。

[xtlxblk]

i是4，capacity()是5，那么(i + capacity()) % capacity()结果不该是4吗？为什么是1？

[SummerBlue-code]

先说结论：这段代码是为了让返回的值能够在 [ 0 , capacity ) 的区间内进行循环
首先我们先理解这个函数的 i 它的取值范围是应该是[ -capacity , capacity ]
然后我们把函数拆开来看，先不看括号里面的 capacity( )。
当代码为：i % capacity( ) 时
这段代码能够让 i 的自增永远不会超出capacity的大小，值域为(-∞ , capacity )。
当 i 为负数时，实际的返回值会小于 0 不满足我们的最终目的。
所以我们将代码改为下面这样
当代码为：（ i + capacity( ) ) % capacity( ) 时
我们分类讨论
当 i 为正数时，代码可以化简为：i % capacity( )
当 i 为负数时，代码为 （ capacity( ) + i ) % capacity( ) ,
capacity( ) + i 可以表示为 capacity( ) - | i |
当 0 > i >= -capacity 时, capacity( ) - | i | 永远不会大于capacity( )
最终化简为 capacity( ) - | i | ,
最后因为 capacity > i > - capacity 所以该函数值域为 [ 0 , capacity )

此处有图文讲解：https://zhuanlan.zhihu.com/p/398066452（很通俗易懂，我就是看这个学会的）

[xtlxblk]

我明白了，如果是这个逻辑的话，之前一个回复应该是笔误将负4写成了正4引起了误解

[Dunker-tap]

原来如此啊，撤销功能用的竟然是双栈队列

[muzishuiji]

+1，之前以为是用了两个队列～

[muzishuiji]

感觉理论上【双向队列」也是可以实现撤销重做和浏览器的前进后退的能力的。

[SummerBlue-code]

// 队首出队操作
if (isFront) {
val = front.val; // 暂存头节点值
// 删除头节点
ListNode fNext = front.next;
if (fNext != null) {
fNext.prev = null;
front.next = null;
}
front = fNext; // 更新头节点
}

大佬，我想请问下这段代码能不能替换成下面这样。

// 队首出队操作
if (isFront) {
val = front.val; // 暂存头节点值
// 删除头节点
front = front.next; // 更新头节点
if (front != null) {
front.pre = null; //删除头节点前的节点
}
}

[krahets]

最好将双向的连接都断开，添加 front.prev.next = null 。

[SummerBlue-code]

好的，感谢回答

[5710xIa]

关于最后撤销的实现，那么恢复（CTRL + Y）操作是怎么实现的？

[krahets]

可以看一下“小结”的Q&A，里面有

[samabl]

if (isFront) {
    val = front->val; // 暂存头节点值
     // 删除头节点
    DoublyListNode *fNext = front->next;
    if (fNext != nullptr) {
        fNext->prev = nullptr;
        front->next = nullptr;
        delete front;
    }
    front = fNext; // 更新头节点
    // 队尾出队操作
} else {
    val = rear->val; // 暂存尾节点值
     // 删除尾节点
    DoublyListNode *rPrev = rear->prev;
    if (rPrev != nullptr) {
    rPrev->next = nullptr;
    rear->prev = nullptr;
    delete rear;
    }
    rear = rPrev; // 更新尾节点
}

关于这段代码中删除节点的部分，为什么删除节点前需要手动断开连接，而单链表删除节点前不需要手动断开，不手动断开的话会有什么影响？

[krahets]

从数据结构与算法（做题）的角度看，不断开没有关系，只要保证程序的逻辑是正确的就行。从标准库的角度看，手动断开更加安全、逻辑更加清晰。如果不手动断开，可能会影响当前节点的内存回收，因为有一个指针仍然在指向它。

[orangegei]

在双向队列的pop函数中用if (fNext != null) {
fNext.prev = null;
front.next = null;
}是为了只有一个节点的情况吧，这种情况是不是应该rear也设为null

[krahets]

可以的，设置一下可读性更好。但原文代码的正确性也没问题

[Allen-Scai]

Hi，作者你好，在阅读本节“双向链表实现双向队列”部分代码的时候，发现出队列的部分操作应该是有些问题的，如下代码中注释说明，如果确实有问题的话我后面commit一下代码：

/*下面是本节用双向链表实现双向队列的出队操作，部分地方存在问题已经在注释中指出*/
    /* 出队操作 */
    int pop(bool isFront) {
        if (isEmpty())
            throw out_of_range("队列为空");
        int val;
        // 队首出队操作
        if (isFront) {
            val = front->val; // 暂存头节点值
            // 删除头节点
            DoublyListNode *fNext = front->next;
            if (fNext != nullptr) {
                fNext->prev = nullptr;
                front->next = nullptr;
                /*
                 * 下面这个地方delete的位置是不对的
                 * 假设只有一个节点，这个节点永远也不能被delete，应该放在if之外
                 */
                //delete front;
            }
            delete front;
            front = fNext; // 更新头节点
        // 队尾出队操作
        } else {
            val = rear->val; // 暂存尾节点值
            // 删除尾节点
            DoublyListNode *rPrev = rear->prev;
            if (rPrev != nullptr) {
                rPrev->next = nullptr;
                rear->prev = nullptr;
                /*原因同上*/
                //delete rear;
            }
            delete rear;
            rear = rPrev; // 更新尾节点
        }
        queSize--; // 更新队列长度
        return val;
    }

[Gonglja]

@Allen-Scai 是的，欢迎 pr

[NicholasGGW]

请问c语言中队首与队尾出列是否也需要如同楼主的理由需要放至if之外呢

if (fNext) 
{
         fNext->prev = NULL;
         deque->front->next = NULL;//断连的好习惯
         //delDoublyListNode(deque->front);
         //若队列只有一个节点，则fNext==NULL，那deque的原front则不会被free掉
         //因此delDoublyListNode(deque->front);要拿出来
}
         delDoublyListNode(deque->front);
         deque->front = fNext; // 更新头节点

[SimoralX]

大佬，请问《5.3.2 双向队列实现*》中《1. 基于双向链表实现》js代码中有一行起到了什么作用？

/* 队尾出队操作 */
popLast() {
    if (this.#queSize === 0) {
        return null;
    }
    const value = this.#rear.val; // 存储尾节点值
    // 删除尾节点
    let temp = this.#rear.prev;
    if (temp !== null) {
        temp.next = null;
        this.#rear.prev = null; // ❓❓❓这一行作用是什么❓❓❓下面不是重新赋值更新尾节点了吗
    }
    this.#rear = temp; // 更新尾节点
    this.#queSize--;
    return value;
}

[Allen-Scai]

/* 你有疑问的一行，这是将双向链表的前一个结点设置为null */
this.#rear.prev = null;

/* 这一行是更新当前节点的下一个结点，不是上一个结点 */
this.#rear = temp; // 更新尾节点

[SimoralX]

谢谢，意思是代码作用是直接斩断 尾节点 和 尾节点的前一个节点 之间的双向联系

[Allen-Scai]

是的，实际上 this.#rear.prev = null;不设置也可以，不会有问题，但是设置一下代码更加标准美观。

[YuanYongRun]

#include<iostream>
#include<vector>
using namespace std;

/*双向链表节点*/
struct DoubleListNode
{
    int val;  //节点值
    DoubleListNode *next;  //后继节点指针
    DoubleListNode *prev;  //前驱节点指针
    DoubleListNode(int val_):val(val_),prev(nullptr),next(nullptr){}
};

/*基于双向链表实现的双向队列*/

class linklistDeque
{
private:
        DoubleListNode *front,*rear;
        int dequesize = 0;
public:
        linklistDeque():front(nullptr),rear(nullptr){}
        ~linklistDeque()
        {
            cout<<"析构函数调用"<<endl;
            /*遍历链表删除节点，释放内存*/
            DoubleListNode *pre,*cur = front;
            while(cur!=nullptr)
            {
                pre = cur;
                cur = cur->next;
                delete pre;
            }
        }
        /*获取双向队列长度*/
        int size()
        {
            return dequesize;
        }
        /*判断双向队列是否为空*/
        bool isEmpty()
        {
            return size()==0;
        }
        /*入队操作*/
        void push(int num,bool isfront)
        {
            DoubleListNode * node = new DoubleListNode(num);
            /*若链表为空，则令front和rear都指向node*/
            if(isEmpty())
            {
                front = rear=node;
            }
            else if(isfront)
            {
                /*将node添加至链表头部*/
                front->prev = node;
                node->next = front;
                front = node;
            }
            else
            {
                /*将node添加至链表尾部*/
                rear->next = node;
                node->prev = rear;
                rear = node;
            }
            dequesize++;
        }
        /*队首入队*/
        void push_head(int num)
        {
            push(num,true);
        }
        /*队尾入队*/
        void push_tail(int num)
        {
            push(num,false);
        }
        /*出队操作*/
        int pop(bool isfoot)
        {
            int val = 0;
            if(isEmpty())
            {
                throw out_of_range("队列为空");
            }
            /*队首出队操作*/
            if(isfoot)
            {
                val = front->val;
                /*删除头结点*/
                DoubleListNode * fnext = front->next;
                if(fnext!=nullptr)
                {
                    fnext->prev = nullptr;
                    front->next = nullptr;
                }
                delete front;
                front = fnext;
            }
            /*队尾出队*/
            else
            {
                val = rear->val;
                /*删除尾节点*/
                DoubleListNode *rPrev = rear->prev;
                if(rPrev!=nullptr)
                {
                    rPrev->next = nullptr;
                    rear->prev = nullptr;
                }
                delete rear;
                rear = rPrev; // 更新尾节点
            }
                dequesize--;
                return val;
        }
        /*队首出队*/
        int popfirst()
        {
            return pop(true);
        }
        /*队尾出队*/
        int poplast()
        {
            return pop(false);
        }
        /*访问队首元素*/
        int peekfirst()
        {
            if(isEmpty())
            {
                throw out_of_range("双向队列为空");
            }
            return front->val;
        }
        /*访问队尾元素*/
        int peeklast()
        {
            if(isEmpty())
            {
                throw out_of_range("双向队列为空");
            }
            return rear->val;
        }
        /* 访问数组并打印*/
        vector<int> tovector()
        {
            DoubleListNode *node = front;
            vector<int> res(size());
            for(int i = 0;i<res.size();i++)
            {
                res[i]=node->val;
                node=node->next;
            }
            return res;
        }

};

上述队头队尾元素出队的那儿修改指针有部分问题，上述是修改好的代码

[cipual]

linkedlist_deque.cpp

[cipual]

调用popLast（）貌似会重复释放内存

int main()
{
LinkedListDeque q;
q.pushLast(1);
q.pushLast(2);
q.pushLast(3);
cout << q.popLast();
cout << q.popLast();
cout << q.popLast();

system("pause");
return 0;

}

~LinkedListDeque()
{
    // 遍历链表删除节点，释放内存
    DoublyListNode *pre, *cur = front;
    while (cur != nullptr)
    {
        pre = cur;
        cur = cur->next;
        delete pre; //这里error
    }
}

[ShiinaMahiru-repo]

抱歉看错了，看到了数组那了

[ShiinaMahiru-repo]

嗯，对的，他没把首指针指向null

[ShiinaMahiru-repo]

重复是指？？ 感觉这个没问题呀 这个每次都释放得很好呀也没特殊情况的限制&nbsp;&nbsp; ?倚???窗听雨?? ***@***.*** &nbsp;

…

------------------&nbsp;原始邮件&nbsp;------------------ 发件人: ***@***.***&gt;; 发送时间: 2024年3月2日(星期六) 中午11:03 收件人: ***@***.***&gt;; 抄送: ***@***.***&gt;; ***@***.***&gt;; 主题: Re: [krahets/hello-algo] chapter_stack_and_queue/deque/ (Discussion #140) 调用popLast（）貌似会重复释放内存 int main() { LinkedListDeque q; q.pushLast(1); q.pushLast(2); q.pushLast(3); cout << q.popLast(); cout << q.popLast(); cout << q.popLast(); system("pause"); return 0; } ~LinkedListDeque() { // 遍历链表删除节点，释放内存 DoublyListNode *pre, *cur = front; while (cur != nullptr) { pre = cur; cur = cur-&gt;next; delete pre; //这里error } } — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: ***@***.***&gt;

[cipual]

我调试的时候发现，只剩一个结点的时候执行完popLast（）后this->front不等于nullprt，所以析构的时候还会再释放一次。

[ShiinaMahiru-repo]

他这个C++的peekpop实现都没释放内存 只用了一个局部变量返回了值 然后改了记录队列长度的变量queSize 到了析构函数才释放 所以也没重复 不知我理解的对不对 还是说我和你说的不是一个东西

[ShiinaMahiru-repo]

找到下一个节点 删除上一个节点没问题呀 直到下一个节点到NULL 此时删除完毕&nbsp;

…

调用popLast（）貌似会重复释放内存

[kang-int]

java中基于双向链表的双向队列的pop操作，如果只有一个元素，front = fNext; // 更新头节点，此时front指向null，rear没有更新为null，而是仍旧指向pop出去的元素。

[huiyichanmian]

基于队列实现中，array_deque.go

// 计算队尾指针，指向队尾索引 + 1
rear := q.index(q.front + q.queSize)
// 将 num 添加至队首
q.nums[rear] = num
q.queSize++

将num添加至队首，这块应该有误，应该是队尾

[krahets]

谢谢指正！

[jy6888]

from collections import deque

# 初始化双向队列
deque: deque[int] = deque()

# 元素入队
deque.append(2)      # 添加至队尾
deque.append(5)
deque.append(4)
deque.appendleft(3)  # 添加至队首
deque.appendleft(1)

# 访问元素
front: int = deque[0]  # 队首元素
rear: int = deque[-1]  # 队尾元素

# 元素出队
pop_front: int = deque.popleft()  # 队首元素出队
pop_rear: int = deque.pop()       # 队尾元素出队

# 获取双向队列的长度
size: int = len(deque)

# 判断双向队列是否为空
is_empty: bool = len(deque) == 0

这段代码在vscode上跑不动，问题好像在于双向队列实例的名字跟类名是一样的，vscode无法识别，把实例名字改为deque—example就能运行了

[WatLem]

对的，我也遇到了相同的问题，改了名字就可以了

[krahets]

谢谢，已修复～建议前往 https://github.com/krahets/hello-algo 下载配套代码，其是经过完整测试的，不用 copy 代码啦

[MrJavaLiY]

基于环形数组实现的双向队列，nums内部实际上所有数据都存在，并未直接删除，而是通过两个指针来限制其有效区间，使得有效区间外的数据为“失效数据”，这个是否可以添加注释以便更加通俗的理解？

[KLYkl]

array_deque.cpp里的
/* 计算环形数组索引 */
int index(int i) {
// 通过取余操作实现数组首尾相连
// 当 i 越过数组尾部后，回到头部
// 当 i 越过数组头部后，回到尾部
return (i + capacity()) % capacity();
}

用return (i + capacity()) % capacity();和用return i % capacity(); 没有区别的吧？

[hpstory]

Hi @KLYkl , i有可能是负数，导致索引越界

[KLYkl]

谢谢，这样的话，设防的范围和capacity()有比较大的关系吧？虽然有点钻牛角尖了。哈哈哈

[hpstory]

是的，如果i是负数的话，需要保证capacity() >= -i。

[ruomu007]

判断是不是空队列，能不能用 if（queSize==0）来判断。书上都是 if (isEmpty())。 这有什么利弊吗？

[zxbdzh]

判断队列是否为空可以用 if (queSize == 0) 或是 if (isEmpty())。两种方法表面上看起来都能达到相同的目的，但它们各有优劣。

使用 if (queSize == 0) 的优点：

简单直接： 如果你已经有队列大小的信息（queSize），直接判断是否为0是非常直观和简单的。
性能： 这种方法通常只涉及到一个简单的整数比较操作，执行起来可能会略快一些。
使用 if (queSize == 0) 的缺点：

易读性： queSize == 0 可能不如 isEmpty() 直观，后者明确表达了意图——检查队列是否为空。
封装性： 如果你直接访问队列大小变量，会暴露队列的内部实现细节，不符合面向对象编程的封装原则。
维护性： 如果队列的实现发生变化，例如queSize的计算方式改变，所有使用queSize == 0判断的地方都需要修改。
同步问题： 如果队列为多线程环境设计，直接访问 queSize 可能会导致线程安全问题，而调用isEmpty() 则可以在内部处理同步。
使用 if (isEmpty()) 的优点：

易读性： isEmpty() 方法名明确表达了其用途，代码更加直观和可读。
封装性： 使用 isEmpty() 能隐藏队列内部实现细节，符合封装原则，使队列类的实现和接口分离。
维护性： 如果队列的实现发生变化，只需修改 isEmpty() 方法，不需要修改所有判断队列是否为空的地方。
同步问题： 能在 isEmpty() 方法内部处理同步问题，确保线程安全。
使用 if (isEmpty()) 的缺点：

可能略微复杂： 需要调用一个方法，可能涉及额外的函数调用开销，不过通常开销很小，可以忽略不计。
总的来说，推荐使用 isEmpty() 方法来判断队列是否为空，因为它在代码可读性、封装性和维护性方面具有更明显的优势，特别是在面对复杂系统或未来可能变化的实现时。

[ruomu007]

真棒！谢谢大佬。

[krahets]

简单来说，isEmpty() 是我们定义的方法，它会处理好我们想要的一切，因此我们倾向于用它。

在这里，queSize == 0 也足够直接，不影响可读性。但是在比较复杂的逻辑下，两种选择的差距就会被体现出来

[ayu255]

双向队列只要维护好一个头结点一个尾节点，就不是一定要用双向链表实现。

[ayu255]

说错了，hhh

[nfrjyrymccan]

环形数组真的太秒啦!!!

[ruomu007]

有个问题：刚开始是空队列，然后入队1个元素，入队的时候c++代码只对front进行了维护，但是正因为只入队了一个元素，该元素即是队首也是队尾，是不是也应该对 rear 进行维护。

[ruomu007]

增加提问：正因为是环形数组，双向都可以出队入队，出队入队操作后，如果全部出队，变成空队列后，front 和rear是不一定 指向0索引的。

[hpstory]

Hi @ruomu007 , 1. rear可以通过front和队列长度计算出来，不需要单独维护。2. 是的，不一定会在0