数据结构（四）、C++数组实现队列

已于 2022-12-02 15:00:33 修改
阅读量194 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++ 开发语言
于 2022-11-21 10:09:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weijianjain/article/details/127958858
版权

数组实现队列

1、实现原理

通过操作数组的下标来实现队列结构。
栈数组结构体定义：

    const int queue_size = 10;
    template<class T>
    class Queue
    {
    public:
        std::array<T, queue_size> m_que{}; // 队列
        int m_fornt{ -1 };                 // 头标识
        int m_fear{ -1 };                  // 尾标识
    }

（1）、入队实操说明

  • 插入元素（1）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   0   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |-1   |-1
          m_fornt  m_fear
                                             ||
                                             ||  m_fornt = m_fear = 0
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0    |0
          m_fornt  m_fear
        */
  • 插入元素（2）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0   |0
          m_fornt  m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0         |1
          m_fornt       m_fear
        */
  • 插入元素（3）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0         |1
          m_fornt       m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                |2
          m_fornt              m_fear
        */
  • 插入元素（4）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                |2
          m_fornt              m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear
        */

（2）、出队实操说明

  • 移除首元素（1）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                          |1             |3
                     m_fornt           m_fear
        */
  • 移除首元素（2）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                          |1             |3
                     m_fornt           m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                 |2     |3
                            m_fornt   m_fear
        */
  • 移除首元素（3）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                 |2     |3
                            m_fornt   m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                      |3    |3
                                 m_fornt  m_fear
        */
  • 移除首元素（4）
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                      |3    |3
                                 m_fornt  m_fear
                                             ||
                                             ||   m_fornt = m_fear = -1
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |-1  |-1
          m_fornt  m_fear
        */

（3）、打印实操说明

遍历从m_fornt位置开始到m_fear位置结束，依次输出数组

        /*
                队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear

          遍历从m_fornt位置开始到m_fear位置结束，依次输出数组
        */

（4）、整体代码

#include <iostream>
#include <array>

namespace queue_array
{
    const int queue_size = 10;
    template<class T>
    class Queue
    {
    public:
        std::array<T, queue_size> m_que{}; // 队列
        int m_fornt{ -1 };                 // 头标识
        int m_fear{ -1 };                  // 尾标识

        /**
         * @brief 插入
         */
        void push(T m_pData)
        {
            if(m_fear == m_que.size() - 1)
            {
                std::cout << "queue 已满." << std::endl;
            }
            else if (m_fornt == -1 && m_fear == -1)
            {
                m_fornt = m_fear = 0;
                m_que.at(m_fear) = m_pData;
            }
            else if (m_fear < m_que.size())
            {
                m_fear++;
                m_que.at(m_fear) = m_pData;
            }
        }

        /**
         * @brief 删除
         */
        void pop()
        {
            if (isEmpty())
            {
                std::cout << "queue isempty()" << std::endl;
            }
            if (m_fornt == m_fear)
            {
                m_fornt = m_fear = -1;
            }
            else
            {
                m_fornt++;
            }
        }

        /**
         * @brief 打印
         */
        void print_queue()
        {
            if (isEmpty())
            {
                std::cout << "queue isempty()" << std::endl;
                return;
            }
            for (int i = m_fornt; i < m_fear; ++i)
            {
                std::cout << m_que[i] << " ";
            }
            std::cout << std::endl;
        }

        /**
         * @brief 判空
         */
        bool isEmpty() { return (m_fornt == -1); }

        /**
         * @brief 大小
         */
        int size() { return (m_fear - m_fornt); }
    };

    void test_queue_array()
    {
        queue_array::Queue<int> m_queue;
        m_queue.push(1);
        /*
               队列数组arr
               --------------------------------------------------------------
               |   0   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |-1   |-1
          m_fornt  m_fear
                                             ||
                                             ||  m_fornt = m_fear = 0
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0    |0
          m_fornt  m_fear
        */

        m_queue.push(2);
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   0  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0   |0
          m_fornt  m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0         |1
          m_fornt       m_fear
        */

        m_queue.push(3);
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   0  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0         |1
          m_fornt       m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                |2
          m_fornt              m_fear
        */

        m_queue.push(4);
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   0   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                |2
          m_fornt              m_fear
                                             ||
                                             ||   m_fear++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear
        */

        m_queue.print_queue();
        /*
                队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear

          遍历从m_fornt位置开始到m_fear位置结束，依次输出数组
        */

        cout << "queue.size()=" << m_queue.size() << endl;

        m_queue.pop();
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |0                        |3
          m_fornt                      m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                          |1             |3
                     m_fornt           m_fear
        */

        m_queue.print_queue();
        cout << "queue.size()=" << m_queue.size() << endl;

        m_queue.pop();
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                          |1             |3
                     m_fornt           m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                 |2     |3
                            m_fornt   m_fear
        */

        m_queue.print_queue();
        cout << "queue.size()=" << m_queue.size() << endl;

        m_queue.pop();
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                 |2     |3
                            m_fornt   m_fear
                                             ||
                                             ||   m_fornt++
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                      |3    |3
                                 m_fornt  m_fear
        */

        m_queue.print_queue();
        cout << "queue.size()=" << m_queue.size() << endl;

        m_queue.pop();
        /*
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
                                      |3    |3
                                 m_fornt  m_fear
                                             ||
                                             ||   m_fornt = m_fear = -1
                                            \\//
               队列数组arr
               --------------------------------------------------------------
               |   1   |   2  |   3  |   4   |   0   |   0   |  ...  |   0  |
               --------------------------------------------------------------
               |-1  |-1
          m_fornt  m_fear
        */

        m_queue.print_queue();
        cout << "queue.size()=" << m_queue.size() << endl;

        m_queue.pop();
        m_queue.print_queue();
        cout << "queue.size()=" << m_queue.size() << endl;
    }

}// namespace queue_array

int main()
{
    queue_array::test_queue_array();
    return 0;
}
牛马不分
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之环形队列实现 (C++/数组)
07-02 1287
数据结构之环形队列实现 (C++/数组) 1.概念示意图 内存中不存在环形数据结构，均由基础结构实现逻辑上的闭环效果 2.环形队列与普通队列的区别 1.front头部指针 一般队列：front头部指针初始值为-1，从队列取数据时，该值依次递增，指向的元素即待取出的数据，而队列的头部数据所在的指针位置为front+1。当front=maxSize-1时，队列最后一个数据取出，此时队列为空。 环形队列：front头部指针初始值为0，指向的元素既是队列的头部数据也是待取出的数据。从队列取数据时..
数据结构（c++、c#）---栈，队列
Tang_AHMET的博客
08-11 325
数据结构（c++）–栈 引用命名空间 #include<stack> 实例 stack<int> s; for(inti i
【队列】c++使用数组实现队列
yizhizainulii的博客
04-11 3827
数组队列 基本概念 代码实现 1 数组队列的类 2 判断队列是否满 3 判断队列是否为空 4 向队列中添加元素 5 从队列中取出元素 6 获取队列元素个数 7 显示队列所有元素 8 显示队列头元素 9 数组队列全部代码 10 测试代码 结果与分析 1 操作结果 2 分析与待改进 基本概念 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 使用数组来实现队列的示意图 .
C++实现循环队列（数组模拟）【保姆级讲解】
weixin_55755506的博客
12-10 3610
看起来还不错，但仔细观察出队到队空时，队列里面没有数了，也就是队空了，可以继续加数据，但是，表示队列头尾的变量已经到了数组的最右边的下一个索引，已经没办法再往右了，同时数组还是空的。这里可以将数组的一个格子空出来，当数组还有一个格子的时候，就当作队列已经满了。出队的话，可以利用和入队类似的办法，但数组无法删除元素，但我们可以用一个数组索引的变量表示队头的位置，每次出队只需把这个索引向递增即可。这样看起来可以，但是有一个问题，我们需要时刻记得我们入队了几次，否则就无法根据索引入队了。没有到达数组末尾的时候，
使用数组实现队列C++
weixin_43010548的博客
10-15 1016
要求 \quad使用数组实现队列，需要能够实现插入、删除元素，输出当前队列长度，当元素插入大于队列当前设定长度时实现自动扩容（但是小于设定的最大队列长度）等操作. 分析 使用数组作为连续存储空间，插入元素只需要按顺序插入即可，当删除元素时需要涉及数组元素的移动。为实现以上操作需要定义两个坐标变量，QueueHead指向数组的第一个元素，QueueTail指向当前需要插入的元素。 在队列（其实就是数组）扩展时，需要原数组空间的释放和新空间的开辟 ArrayQueue 结构体 class ArrayQueu
C++中的数据结构-队列(数组实现)
m0_56741902的博客
09-07 430
队列 队列是一种受限的线性表(Queue),它是一种运算受限的线性表,先进先出 特点: -1先进先出,一种受限的线性表 -2它只允许在表的前端(front)进行删除操作,在表的后端(rear)进行插入操作 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑
C++数据结构之数组队列模版实现
09-20
队列是一种先入先出的数据结构（FIFO），只允许在前端(front)删除，在后端(rear)插入。容量为capacity大小的内存，只能存capacity-1的元素，其中rear的位置始终为空。 本文实现的队列，功能如下： 1 获取元素内容 ...
简单介绍所有的数据结构，包括数组、队列、二叉树等C、C++
02-12
下面将对数组、队列和二叉树这三种基本的数据结构进行详细解释。 **一、数组** 数组是最基础的数据结构，它是一系列相同类型元素的集合，这些元素在内存中以连续的方式存储。通过索引（通常从0开始）可以访问数组中...
数组实现队列
09-13
由数组实现队列，包括队列的创建、入队和出队。通过打印显示出队的结果。正在学习数据结构的童鞋可以参考。
用数组实现队列的基本功能
09-05
通过不断地修改命名规范、程序逻辑等毛病 ，终于算完成了。这算是我第一个比较认真的小程序吧！仍需努力啊。
队列数组实现
11-26
c++ 队列数组实现，这个简单的东西。队列的数组实现
C++数据结构之实现循环顺序队列
12-31
数据结构–用C++实现循环顺序队列 队列的操作特性：先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头、队尾两个指针，以改进出队的时间性能 约定：队头指针front指向队头元素的前一个位置...
c++ 邻接数组实现四种图类
01-16
在IT领域，图是一种重要的数据结构，用于表示对象之间的关系。在这个C++的三级项目中，我们将使用邻接数组来实现四种不同的图类...通过阅读和理解这些代码，可以深入学习C++中如何使用邻接数组实现图数据结构及其操作。
C++数组实现队列
uxlike的博客
11-05 1061
队列是一种先进先出的数据结构，队列元素从队头出队，从队尾入队，如一组数入队顺序为：5 4 3 2 1，则出队顺序也为：5 4 3 2 1。 这里使用动态数组实现一个简易队列。
C++ STL之 queue和deque用法详解
zdlzf的博客
05-25 7771
C++ queue和deque用法详解 deque可以队首和队尾插入，也可以队首和队尾弹出，支持随机访问，即可以直接用下标来访问元素。它和vector有点像，因为它可以index索引和at()函数索引，当然，也可以迭代器索引。此外，它可以进行指定尺寸的构造-queue就不可以指定尺寸构造。
c++用数组实现队列
qq_45227330的博客
03-23 1735
队列(queue) 的特点： 先进先出 数组实现： array： 存放元素 i： 下一个入队存放元素位置的下标 j： 下一个出队删除元素位置的下表 size： 队列的最大长度 num： 队列中当前元素个数 #include <iostream> using namespace std; template<typename T> class queue{ public...
C++ STL之queue详解
热门推荐
行码棋
01-04 2万+
本文介绍C++STL之queue的讲解，会介绍queue的常用操作以及数组模拟方法
数据结构之队列(数组形式)——C++具体实现
weixin_45338443的博客
06-08 261
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间（类似于数组），并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置。另一个要素为队列最大容量（MaxSize）。
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1464
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
C++数组实现栈与队列操作详解
总结：这两个文件展示了如何使用C++编程实现基本的数据结构栈和队列，涉及到数组作为底层存储，以及常见的操作如入栈、出栈、入队、出队和查询。这对于理解和实践基础数据结构理论，以及在实际编程中高效地处理问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值