【数据结构c++】（学习笔记）队列（循环队列、链式队列、两个栈实现一个队列、两个队列实现一个栈）

最新推荐文章于 2026-05-08 00:53:35 发布
原创 最新推荐文章于 2026-05-08 00:53:35 发布 · 714 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#数据结构 #c++ #学习

学习笔记，部分内容参考网络教学视频，习题来源Leetcode，侵删

队列

先进先出，后进后出

环形队列

依赖数组实现，但必须实现环形

在这里插入图片描述
两根指针，first指向队首，rear指向队尾，rear指向的是最后一个元素的下一个位置，也表示队内元素个数

使用数组实现线型队列，first以前的数组空间全部浪费，导致数组开多大都不够，所以选择环形

  • 初始化：first = rear = 0;
  • 入队：arr[rear] = 10; rear = (rear + 1) % len); // 不是线型的 rear++;
  • 出队：first++;
  • 判满判空：预留一个空位置给rear，否则rear和first重合时无法分辨是满还是空
    • 空的：first == rear
    • 满的：(rear + 1) / len) == first

代码实现：

#include <iostream>
using namespace std;

class Queue
{
public:
    Queue(int size = 10) : cap_(size),
                           front_(0),
                           back_(0),
                           size_(0)
    {
        pQueue_ = new int[cap_];
    }

    ~Queue()
    {
        delete[] pQueue_;
        pQueue_ = nullptr;
    }

public:
    // 入队
    void push(int val)
    {
        if ((back_ + 1) % cap_ == front_) // 满了扩容
        {
            expand(2 * cap_);
        }

        pQueue_[back_] = val;
        back_ = (back_ + 1) % cap_;
        size_++;
    }

    // 出队
    void pop()
    {
        if (front_ == back_)
        {
            throw "The queue is empty!";
        }
        front_ = (front_ + 1) % cap_;
        size_--;
    }

    // 队首
    int front() const
    {
        if (front_ == back_)
        {
            throw "The queue is empty!";
        }
        return pQueue_[front_];
    }

    // 队尾
    int back() const
    {
        if (front_ == back_)
        {
            throw "The queue is empty!";
        }
        return pQueue_[(back_ - 1 + cap_) % cap_];
    }

    // 队空
    bool empty() const
    {
        return front_ == back_;
    }

    // 队列元素个数
    int size()
    {
        return size_; // O(1)
        /*
        或者 O(n) 遍历
        int size = 0;
        for(int i = front_; i != rear_; i = (i + 1) % cap_)
        {
            size++;
        }
        return size;
        */
    }

private:
    void expand(int size)
    {
        int *p = new int[size];
        // 不能直接操作
        // i遍历新数组，j遍历老数组
        int i = 0;
        int j = front_;
        for (; j != back_; j = (j + 1) % cap_,i++)
        {
            p[i] = pQueue_[j];
        }
        delete[] pQueue_;
        pQueue_ = p;
        // 还有一些属性要修改
        cap_ = size;
        front_ = 0;
        back_ = i;
    }

private:
    int *pQueue_;
    int cap_;   // 空间容量
    int front_; // 队头
    int back_;  // 队尾
    int size_;
};

int main()
{
    try
    {
        // 测试基本功能
        Queue q(3);
        cout << "队列是否为空? " << (q.empty() ? "是" : "否") << endl; // 是

        // 入队测试
        q.push(10);
        q.push(20);
        q.push(30); // 触发扩容到6
        cout << "入队后队列大小: " << q.size() << endl; // 3
        cout << "队首元素: " << q.front() << endl;     // 10
        cout << "队尾元素: " << q.back() << endl;      // 30

        // 出队测试
        q.pop();
        cout << "出队后队首元素: " << q.front() << endl; // 20
        cout << "出队后队尾元素: " << q.back() << endl;  // 30

        // 测试扩容后继续入队
        q.push(40);
        q.push(50);
        q.push(60); // 容量6已满
        q.push(70); // 触发扩容到12
        cout << "扩容后队列大小: " << q.size() << endl; // 6

        // 测试队空异常
        Queue emptyQueue;
        emptyQueue.pop(); // 应抛出异常
    }
    catch (const char* msg)
    {
        cout << "异常: " << msg << endl;
    }

    // 测试边界情况
    try
    {
        Queue q;
        q.push(1);
        cout << "单元素队首: " << q.front() << endl; // 1
        cout << "单元素队尾: " << q.back() << endl;  // 1
        q.pop();
        cout << "队列是否为空? " << (q.empty() ? "是" : "否") << endl; // 是
    }
    catch (const char* msg)
    {
        cout << "异常: " << msg << endl;
    }

    return 0;
}

链式队列

依赖双向循环链表实现

#include <iostream>
using namespace std;

class LinkQueue
{
public:
    LinkQueue() : size_(0)
    {
        head_ = new Node();
        head_->next_ = head_;
        head_->pre_ = head_;
    }

    ~LinkQueue()
    {
        Node *p = head_->next_;
        while (p != head_)
        {
            head_->next_ = p->next_;
            p->next_->pre_ = head_;
            delete p;
            p = head_->next_;
        }
        delete head_;
        head_ = nullptr;
    }

public:
    void push(int val)
    {
        Node *node = new Node(val);
        node->next_ = head_;
        node->pre_ = head_->pre_;
        head_->pre_->next_ = node;
        head_->pre_ = node;
        size_++;
    }

    void pop()
    {
        if (empty()) // 添加边界检查
        {
            throw "The queue is empty!";
        }
        Node *p = head_->next_;
        head_->next_ = p->next_;
        p->next_->pre_ = head_;
        delete p;
        p = head_->next_;
        size_--;
    }

    int front() const
    {
        if (head_->next_ == head_)
        {
            throw "The queue is empty!";
        }
        return head_->next_->data_;
    }

    int back() const
    {
        if (head_->next_ == head_)
        {
            throw "The queue is empty!";
        }
        return head_->pre_->data_;
    }

    bool empty() const
    {
        return head_->next_ == head_;
    }

    int size()
    {
        return size_;
    }

private:
    struct Node
    {
        Node(int data = 0) : data_(data),
                             next_(nullptr),
                             pre_(nullptr)
        {
        }
        int data_;
        Node *next_;
        Node *pre_;
    };

    Node *head_;
    int size_;
};

int main()
{
    try
    {
        // 测试基本功能
        LinkQueue q;
        cout << "队列是否为空? " << (q.empty() ? "是" : "否") << endl; // 是

        // 入队测试
        q.push(10);
        q.push(20);
        q.push(30);                                     // 触发扩容到6
        cout << "入队后队列大小: " << q.size() << endl; // 3
        cout << "队首元素: " << q.front() << endl;      // 10
        cout << "队尾元素: " << q.back() << endl;       // 30

        // 出队测试
        q.pop();
        cout << "出队后队首元素: " << q.front() << endl; // 20
        cout << "出队后队尾元素: " << q.back() << endl;  // 30

        // 测试扩容后继续入队
        q.push(40);
        q.push(50);
        q.push(60);                                     // 容量6已满
        q.push(70);                                     // 触发扩容到12
        cout << "扩容后队列大小: " << q.size() << endl; // 6

        // 测试队空异常
        LinkQueue emptyQueue;
        emptyQueue.pop(); // 应抛出异常
    }
    catch (const char *msg)
    {
        cout << "异常: " << msg << endl;
    }

    // 测试边界情况
    try
    {
        LinkQueue q;
        q.push(1);
        cout << "单元素队首: " << q.front() << endl; // 1
        cout << "单元素队尾: " << q.back() << endl;  // 1
        q.pop();
        cout << "队列是否为空? " << (q.empty() ? "是" : "否") << endl; // 是
    }
    catch (const char *msg)
    {
        cout << "异常: " << msg << endl;
    }

    return 0;
}

用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

  • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

算法

在这里插入图片描述
较为简单地想，拿出最后一个元素只需要把s1元素入栈到s2，s2栈首元素出栈就是队首出栈，剩下的元素再入栈回s1

但是pop,peek（查看队首）操作都会是时间复杂度为O(n)，还可以继续优化

s1负责push，如果做pop和peek都从s2操作（如果s2是空的，就把s1元素都拿过来），判空empty则需要s1,s2均为空。

代码实现

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

class MyQueue
{
public:
    MyQueue()
    {
    }

    void push(int x)
    {
        s1.push(x);
    }

    int pop()
    {
        if (s2.empty())
        {
            while (!s1.empty())
            {
                s2.push(s1.top());
                s1.pop();
            }
        }
        int val = s2.top();
        s2.pop();
        return val;
    }

    int peek()
    {
        if (s2.empty())
        {
            while (!s1.empty())
            {
                s2.push(s1.top());
                s1.pop();
            }
        }
        return s2.top();
    }

    bool empty()
    {
        return s1.empty() && s2.empty();
    }

private:
    stack<int> s1;
    stack<int> s2;
};

用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

**进阶：**你能否仅用一个队列来实现栈。

基础算法

在这里插入图片描述

  1. 两个队列分工：
    • 一个主队列 q1 用于存储栈的元素（非空）。
    • 一个辅助队列 q2 始终为空，仅在出栈时临时使用。
  2. 入栈（push）：
    直接将元素加入主队列 q1（时间复杂度 O (1)）。
  3. 出栈（pop）：
    • 将 q1 中除最后一个元素外的所有元素转移到 q2。
    • 弹出 q1 中剩余的最后一个元素（即栈顶元素）。
    • 交换 q1 和 q2 的角色（q2 变为新的主队列）。
      （时间复杂度 O (n)，n 为当前元素个数）
  4. 取栈顶（top）：
    逻辑与 pop 类似，但转移元素后不弹出最后一个元素，而是记录其值后放回（或直接返回队列尾部元素）。
  5. 判空（empty）：
    主队列 q1 为空时，栈为空。

代码实现

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

class MyStack 
{
private:
    queue<int> q1;  // 主队列（存储元素）
    queue<int> q2;  // 辅助队列（临时使用）

public:
    MyStack() {}
    
    void push(int x) 
    {
        q1.push(x);  // 直接加入主队列
    }
    
    int pop() 
    {
        // 将 q1 中前 n-1 个元素转移到 q2
        while (q1.size() > 1) 
        {
            q2.push(q1.front());
            q1.pop();
        }
        // q1 中剩余的最后一个元素是栈顶
        int topVal = q1.front();
        q1.pop();
        // 交换 q1 和 q2，使 q2 恢复为空
        swap(q1, q2);
        return topVal;
    }
    
    int top() 
    {
        // 复用 pop 的逻辑，但保留最后一个元素
        while (q1.size() > 1) 
        {
            q2.push(q1.front());
            q1.pop();
        }
        int topVal = q1.front();  // 记录栈顶值
        // 将最后一个元素也转移到 q2，保持 q1 为空
        q2.push(q1.front());
        q1.pop();
        swap(q1, q2);  // 恢复 q1 为主队列
        return topVal;
    }
    
    bool empty() 
    {
        return q1.empty();  // 主队列空则栈空
    }
};

进阶算法

在这里插入图片描述
只需一个队列即可实现，核心思路是：入栈后将队列中前 n-1 个元素重新入队，使新入栈的元素位于队首（模拟栈顶）。

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

class MyStack
{
private:
    queue<int> q;

public:
    MyStack() {}

    void push(int x)
    {
        q.push(x);
        // 将前 n-1 个元素重新入队，使 x 位于队首
        for (int i = 0; i < q.size() - 1; ++i)
        {
            q.push(q.front());
            q.pop();
        }
    }

    int pop()
    {
        int topVal = q.front();
        q.pop();
        return topVal;
    }

    int top()
    {
        return q.front();
    }

    bool empty()
    {
        return q.empty();
    }
};
SlashYe
关注
C++实现循环队列（数组模拟）【保姆级讲解】
weixin_55755506的博客
12-10 5158
看起来还不错，但仔细观察出队到队空时，队列里面没有数了，也就是队空了，可以继续加数据，但是，表示队列头尾的变量已经到了数组的最右边的下一个索引，已经没办法再往右了，同时数组还是空的。这里可以将数组的一个格子空出来，当数组还有一个格子的时候，就当作队列已经满了。出队的话，可以利用和入队类似的办法，但数组无法删除元素，但我们可以用一个数组索引的变量表示队头的位置，每次出队只需把这个索引向递增即可。这样看起来可以，但是有一个问题，我们需要时刻记得我们入队了几次，否则就无法根据索引入队了。没有到达数组末尾的时候，
c/c++循环队列（对小白友好）
m0_63112274的博客
01-24 1241
c/c++循环队列（对小白友好）
C++ 循环队列
最新发布
sillyoung的博客
05-08 127
队列实际上就是现实生活中的排队，队头的人先走，新来的人排到队尾。先进先出，后进后出。队列的实现，需要一个队头指针，一个队尾指针，用于入队和出队。对于循环队列，初始化时需将 Q.front = Q.rear = 0，Q.front 指向队头，Q.rear 指向新元素入队的位置。循环队列，物理上仍然是申请一片连续的内存空间，但通过 (Q.rear + 1) % MaxSize == Q.front 的判断条件从逻辑上模拟环状空间，从而实现循环队列。
【C++】【数据结构】循环队列的基本操作（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度）顺序队列的算法实现【附全代码】
是小雷同学的博客
04-21 2万+
C++实现循环队列的算法+步骤（附全代码）： 使用c++完成数据结构循环队列的基本操作，包括（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度等），可直接编译运行。 队列又称为 “先进先出” (FIFO)线性表。限定插入操作只能在队尾进行，而删除操作只能在队首进行。 循环队列——采用顺序存储结构来实现，用一组连续的存储单元依次存放从队首到队尾的元素，附设两个整型变量front和rear分别指向队首元素和队尾元素的位置。 循环队列的定义： #define MAXQSIZE 100 typedef
C/C++数据结构（六） —— 循环队列
Edison's 小宇宙
10-06 2万+
循环队列 是一种线性数据结构，其操作表现基于 先进先出 原则并且 队尾被连接在队首之后以形成一个循环。
C/C++_循环队列(详解)
weifc-wei 的博客
04-24 2万+
循环队列 #include <stdio.h> #include <assert.h> #include <Windows.h> #include <iostream> #include <iomanip> using namespace std; #define MAXSIZE 5 //循环队列的最大容量 typedef int ...
C++ 链表、栈、队列
weixin_40535588的博客
12-05 5014
一、C++ 链表 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 1.1 几种链表的介绍 1.1.1 单向链表 单向链表很容易理解，就说把指针当成一条链一样连接每一个节点，每个节点包含了一个或者多个数据。链表的存储单元不一定是连续的，长度不固定，主要用于方便实现节点的插入和删除操作。官方的话这里就不说了，作为数据结构里最基本的，感兴趣的童鞋自.
【数据结构与算法】设计循环队列
Welcome home | Jian Liao 's blog
03-24 3238
🚩前面我们用队列实现了一个栈用栈实现了一个队列，相信大家随随便便轻松拿捏，而本章将带大家上点难度，我们来设计一个循环队列。🚩对于循环队列，重点就在一个“ 循环 ”，意思也就是该队列首尾相连形成一个环，但其本质还是不变，队列先进先出的性质依旧存在，只不过环的大小有限定（限定放多少数据就只能放多少数据）。🚩那么我们如何来设计这样的一个环，使它既能够像队列一样，又可以体现循环的性质？下面就带大家探讨一波。💝设计一个循环队列还是有些复杂的呢，不过看过本文章，相信大家也可以轻松拿捏。❤️‍🔥。
C++实现数据结构——循环队列和链式队列
m0_37433111的博客
08-10 729
2020年8月10日 周一 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 引言2. 主文件——main.cpp3. 循环队列类 .h文件——circlequeue.h4. 链式队列类 .h文件——linkqueue.h5. 预编译头文件——stdafx.h参考文献 1. 引言 用C++实现了简单的循环队列类和链式队列类，成员函数实现了队列的基础功能：isEmpty()，isFull()，EnQueue()，DeQueue()，GetFront()，GetLength()等，主函数中有三个
【数据结构】队列（循环队列和链队列）详细讲解各种操作
小吉妙妙屋
04-15 6195
详细讲解循环队列和链队列的定义，初始化，入队，出队，遍历等操作
循环队列详解
热门推荐
weixin_55858644的博客
01-04 4万+
简单易懂的循环队列
数据结构——循环队列（C++实现）
qq_67693066的博客
04-22 2407
数据结构——循环队列（C++）
带你一步步用C++实现循环队列
weixin_43744293的博客
05-14 4005
C++实现循环队列前言1.什么时候循环队列为空2.Push()操作(1)何时队列满了?(2)当队列满了，怎样扩大队列？(3)std::copy()的用法3.队列中现有多少个元素怎么算4.其他成员函数5.实例代码及运行结果：思考：总结 前言 有关队列的介绍，如队列的常用操作，循环队列和链式队列的优缺点对比等，可参考队列简介及常用操作 创建一个Queue类，确定成员函数和数据成员 template <typename T> class Queue { Queue(int _capacity = 1
循环队列(C++)
weixin_73567058的博客
05-25 1452
顺序队列的主要瓶颈在于队首的位置不可变，出队后队列内其他元素必须整体向前移动一个位置，若处理大量数据时，则会带来较多时间复杂度为O(n)的操作。_k用于记录队列的最大容量。通常，循环队列使用固定长度的数组来表示队列元素，头和尾指针挂钩形成循环的维度感知队列长度，并提高队列操作效率，因为这种结构需要的内存量比链表数据结构更小。在循环队列中，所有元素都保存在一个连续的数组中，并且队列的两端都连接在数组的两端上。实际上这里使用了数组的一部分来表示队列，为了避免队列在完全满时和空时的判断异常，被留空的一个位置。
C++实现队列（循环队列）
Y~哈哈哈的博客
03-30 4542
一、队列的操作： 、1、入队（从尾入队） 将值存入rear所代表的位置 rear = （rear + 1）% 数组的长度 2、 出队（头部出队） front = (front + 1）% 数组的长度 3、 队列是否为空 front 和 rear的值相等，则该队列就一定为空 4、队列是否已满 在循环队列中“队满”和“队空”的条件有可能是相同的，都是front == rea...
循环队列 C++ 实现
axyzstra 的博客
07-25 3892
因此可以得出结论，入队列时，在队列未满时，元素入队，队尾元素。为解决假溢出问题，采用循环队列，循环队列即一种逻辑上的环状结构，但在物理空间上仍然为顺序存储，即数组。测试方案依次入队列至如下情况，此时将不能入队列，rear=7，front=0；出队列四次，入队列五次，此时队列已满；入队列代码size=MAX时队列已满，不能入队列；出队列四次，入队列两次，此时队头为4，队尾指针为1；表示队列已满，若队列未满，则入队列，入队列后若。表示队列已空，若队列未满，则入队列，出队列后若。...
（一）c++实现共享栈 循环队列 链栈
weixin_45949928的博客
09-29 1181
本文为数据结构课程的第一篇实验报告，主要是用c++实现共享栈、循环队列和链栈，仅供参考学习（也没人看），如有错误望及时提出，我及时改正。 实验一：线性结构的实现 一、实验目的 实验目标： 验证C语言环境下，顺序结构和链式结构的实现。并通过测试数据的运行结果来测试结构的正确性。尝试实现如循环队列、共享栈等在特殊条件下使用的数据结构。 预期效果： 能够成功运行循环队列，共享栈和链栈。 二、实验内容 1、实现顺序循环队列 2、实现链式栈 3、实现共享栈 4、使用数据测试 三、实验过程 实现过程： 1.顺序循环队列
数据结构之链式队列以及C++实现与模板
ck8719的博客
05-26 1431
队列的一些说明 队列的定义 队列，一种特殊的线性表 特点：只允许在一端输入，在另一端输出。输入端称为队尾，输出端称为队头 因此，队列，又称为先进先出表（FIFO），类似于生活中的排队，先来的排在前头，后来的排在后头，一个一个办理业务。 队列有两种，一种叫做循环队列（顺序队列），另一种叫做链式队列。 这一篇讲的是链式队列，循环队列在另外一篇文章中 循环队列讲解与C语言实现 链式队列的实现 链式队列 链式队列与单链表是有些类似的，只是多了一个表头（front）和一个表尾（rear）。 front指向首结点，re
链式队列，队列篇（链式队列的出队入队操作）
qq_46104786的博客
11-06 2万+
数据结构专升本学习，队列篇（链式队列） 前言： 上一篇博主简单讲解了顺序队列和循环队列，今天讲解队列最后一篇链式队，链式队在数据结构中用到比较多，用来做一些排队的算法，还有链式队列是也是和链式栈一样采用链表的方式来表现，链式队列针对数据比较灵活的数据比较方便，因为它不像顺序队列一样需要定义最大值，链式队列只需要建立新结点，比较灵活，没有大小限制，只要内存，并且用完了就释放了，对于变动较大的数据很友好。 每日一遍，防止颓废 1.理解链式队列逻辑，认识核心代码 所谓队列的链式存储结构是用一个线性链表来表示一个
数据结构循环队列C++实现
Brillian123的博客
04-13 3117
1.队列的概念 队列只允许在表的一端插入，另一端删除。允许插入的一端叫做队尾，允许删除的一端叫做对首。队列的特性叫“先进先出”。和栈一样，队列的存储形式也有两种，基于数组的存储表示和基于链表的存储表示。本文先实现基于数组的存储队列，也叫顺序队列。在顺序队列中设置两个指针，front和rear，front指示队头的位置，rear指示队尾的位置（说是指针，实际仍不是c语言的指针*，而是类似下标或索引的作用）。如下图所示： 当队列为空时，front=rear=0； 有新元素入队时，先将新元素添加到rea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值