队列的概念及实现

最新推荐文章于 2021-09-22 18:30:31 发布
最新推荐文章于 2021-09-22 18:30:31 发布
阅读量217 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41936794/article/details/105800993
版权

1 前言

队列也是一种特殊的线性表,队列仅能在线性表的两端进行操作,队头(Front)为取出数据元素的一端,队尾为插入数据元素的一端,队列的特性为先进先出(First In First Out)
在这里插入图片描述
队列的操作包括创建队列,销毁队列,清空队列,进队列,出队列,获取队头元素,获取队列的长度,队列可以包括静态队列和动态队列,我们可以抽象出一个队列父类,静态队列和动态队列都继承于该类,队列的顺序实现如下图所示,我们需要一片连续的存储空间,需要两个标识变量,一个变量指向队头front,一个变量指向队尾rear(队尾指向的地方没有元素)
在这里插入图片描述

2 StaticQueue

设计要点
1.使用原生数组作为队列的存储空间
2.使用模板参数决定队列的最大容量
3.我们要设计成循环队列(循环队列才高效)
4.队空:(m_length == 0) &&(m_frontm_rear)
5.队满:(m_length == N) &&(m_frontm_rear)
抽象父类 Queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include "object.h"
namespace CGSLib
{
  template <typename T>
  class Queue : public Object
  {
      virtual void remove() = 0;
      virtual void clear()  = 0;
      virtual int  length()const = 0;
      virtual void add(const T& e) = 0;
      virtual T front()const       = 0;
  };
}
#endif // QUEUE_H

StaicQueue代码如下

#ifndef STATICQUEUE_H
#define STATICQUEUE_H
#include "Queue.h"
#include "Exception.h"
namespace CGSLib
{
  template <typename T,int N>
  class StaticQueue : public Queue<T>
  {
     protected:
      T m_space[N];
      T m_front;
      T m_rear;
      int m_length;
    public:
      /*队列初始化函数*/
      StaticQueue()
      {
        m_front = 0;
        m_rear  = 0;
        m_length = 0;
      }
      /*队列删除函数,从队头删除*/
       void remove()
       {
           if(m_length>0)
           {
              m_front = (m_front+1)%N;
              m_length--;
           }
           else
           {
               THROW_EXCEPTION(InvalidOperationException,"no element to remove");
           }

       }
       /*队列加入函数,从队尾加入,队尾本身指向一个空位*/
       void add(const T& e)
       {
           if(m_length<N)
           {
               m_space[m_rear] = e;
               m_rear = (m_rear+1)%N;
               m_length++;
           }
           else
           {
               THROW_EXCEPTION(InvalidOperationException,"no memery to add");
           }

      }
      /*获取队头元素的函数*/
      T front()const
      {
          if(m_length>0)
          {
            return m_space[m_front];
          }
          else
          {
              THROW_EXCEPTION(InvalidOperationException,"no element to get");
          }

      }
      /*获取队列长度的函数*/
      int  length()const
      {
         return m_length;
      }
       /*获取队列容量的函数*/
      int capacity()const
      {
         return N;
      }
      /*队列清除函数*/
      void clear()
      {
          m_front = 0;
          m_rear  = 0;
          m_length = 0;
      }
  };

}
#endif // STATICQUEUE_H

测试代码如下

using namespace std;
using namespace CGSLib;
int main()
{
  StaticQueue<int,5> queue;
  for(int i=0;i<5;i++)
  {
    queue.add(i);
  }
  while(queue.length()>0)
  {
    cout<<queue.front()<<endl;
    queue.remove();
  }
}

测试结果,结果无误
在这里插入图片描述
基于之前我们那篇栈的文章提到过静态栈的缺陷,类似的,静态队列也存在同样的缺陷,当数据元素为类类型时,静态队列的对象在创建时,会多次调用元素类型的构造函数,影响效率,所以我们下面就开始打造一个链式队列来提高效率

3 LinkQueue

链式队列本质上还是使用了链表的结构,但这里与链式栈不同的是,我们链式结构来实现队列的时候需要用到两个指针**,front指针**指向队列的首元素,rear指针指向队列的尾元素
在这里插入图片描述

链式队列的设计要点
1.类模板,抽象父类Queue的直接子类
2.在内部使用链表结构实现元素的存储
3.只能在链表的头部和尾部进行操作
LinkQueue代码

#ifndef LINKQUEUE_H
#define LINKQUEUE_H
#include "LinkList.h"
#include "Queue.h"
#include "Exception.h"
namespace CGSLib
{
  template <typename T>
  class LinkQueue : public Queue<T>
  {
    LinkList<T> m_queue;
  public:
    /*链式队列的删除元素,从链式队列的首结点删除也就是队头删除*/
    void remove()//O(1)
    {
        if(m_queue.length()>0)
        {
           m_queue.remove(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException,"no element to remove");
        }

    }
    /*链式队列的删除函数*/
    void clear()//O(n)
    {
        m_queue.clear();
    }
     /*链式队列的获取元素数目函数*/
    int  length()const//O(1)
    {
        return m_queue.length();
    }
    /*链式队列的添加元素函数,也就是从队尾添加*/
    void add(const T& e)//O(n)
    {
       m_queue.instert(e);
    }
    /*获取链式队列队头元素*/
    T front()const//O(1)
    {
        if(m_queue.length()>0)
        {
          return  m_queue.get(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException,"no element to get");
        }

    }

  };

}
#endif // LINKQUEUE_H

测试函数:

#include <iostream>
#include "LinkQueue.h"

using namespace std;
using namespace CGSLib;
int main()
{
  LinkQueue<int> queue;
  for(int i=0;i<5;i++)
  {
    queue.add(i);
  }
  while(queue.length()>0)
  {
    cout<<queue.front()<<endl;
    queue.remove();
  }
}

测试结果:

0
1
2
3
4

可以看出我们的链式队列就成功了,但是对于链表队列的时间复杂度还是不理想,顺序队列的操作函数都是O(1)而我们的链式队列出现了两次O(n),造成低效率的原因是因为我们往链式队列中插入一个元素时需要从队头遍历到队尾才能插入,这是问题根源的所在,我们这里使用带头结点双向循环链表来做链式队列,而linux内核链表就是带头结点的双向循环链表,我们以它为基础来打造我们的链式队列
在这里插入图片描述

基于Linux链表的队列代码如下

#ifndef LINKQUEUE_H
#define LINKQUEUE_H
#include "LinuxList.h"
#include "Queue.h"
#include "Exception.h"
namespace CGSLib
{
  template <typename T>
  class LinkQueue : public Queue<T>
  {
    protected:
    struct Node : public Object
    {
        list_head head;
        T value;
    };
    list_head m_header;
    int m_length;
  public:
    LinkQueue()
    {
      m_length = 0;
      INIT_LIST_HEAD(&m_header);
    }
    void remove()//O(1)
    {
        if(m_length>0)
        {
           list_head* toDel = m_header.next;
           list_del(toDel);
           m_length--;
           delete list_entry(toDel,Node,head);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException,"no element to remove");
        }

    }
    void clear()//O(n)
    {
        while(m_length>0)
        {
           remove();n
        }
    }
    int  length()const//O(1)
    {
        return m_length;
    }
    void add(const T& e)//O(1)
    {
        Node* node = new Node();
        if(node!=NULL)
        {
           node->value = e;
           list_add_tail(&node->head,&m_header);
           m_length++;
        }
        else
        {
           THROW_EXCEPTION(InvalidOperationException,"no element to add");
        }
    }
    T front()const
    {
        if(m_length>0)
        {
            return  list_entry(m_header.next,Node,head)->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException,"no element to get");
        }

    }
    ~LinkQueue()
    {
        clear();
    }

  };

}
#endif // LINKQUEUE_H

可以看出我们基于linux内核链表的队列变得更加高效了,链式队列入队操作和出队操作可以在常量时间内完成,如果对于LINUX那些接口不懂的可以查看LINUX链表大剖析文章

勇士后卫头盔哥
关注
专栏目录
python队列原理及实现方法示例
09-18
队列的概念相对简单，它是按照先进先出（First-In-First-Out，FIFO）原则操作的线性表，这意味着先被插入到队列中的元素会首先被删除。在队列中，有两个重要的端点：队尾（rear），用于添加元素；队头（front），...
四、队列的概念和实现
Willwilling
04-09 200
队列是一种特殊的线性表。队列仅能在线性表的两端进行操作：队头（Front）：取出数据元素的一端；队尾（Rear）：插入数据元素的一端。队列的特性——先进先出（First In First Out）队列的操作：创建、销毁、清空（clear()）、进队列（add()）、出队列（remove()）、获取队头元素（front()）、获取队尾元素（length()）。父类队列的实现:template &lt...
队列的基本概念及实现
weixin_43755584的博客
04-11 308
队列的基本概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性。 队列的实现：队列可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率比较低。 以下是实现队列的基本操作 #pragma once typedef struct Node { int value; struct Node *next...
队列的定义以及实现
Sun.ME的博客
03-05 2800
队列是只允许在一端进行插入操作，而在另外一端进行删除操作的线性表。 队列是一种先进先出的线性表，简称FIFO，允许插入的一端称之为队尾，允许删除的一端称之为队头。 线性表有顺序存储和链式存储，栈是线性表，队列作为一种特殊的线性表，也同样存在顺序存储结构和链式存储结构。 入队：在队列的末尾追加一个元素，不需要移动任何元素，其时间复杂度为O(1); 出队：队列元素的出列是在队头，即下标为0的位...
PHP消息队列实现及应用详解【队列处理订单系统和配送系统】
10-16
【PHP消息队列实现及应用详解】 在高并发的互联网项目中，PHP消息队列扮演着关键角色，它能够帮助开发者解决系统压力、确保数据处理的顺序性、提高系统的扩展性和解耦度。本文将深入探讨PHP消息队列的概念、原理、...
C#消息队列发送及接收
03-25
在IT行业中，消息队列（Message Queue，MQ）是一种常用于分布式系统中解耦组件、提高系统可扩展性和...通过理解和掌握消息队列的概念及其在C#中的实现，可以极大地优化你的应用程序架构，提升系统的稳定性和可扩展性。
队列的定义和实现
chenxina7314的博客
09-04 331
队列的定义和实现 前言 语言：Java 环境：IntelliJ IDEA JDK版本：1.8 源码：GitHub 队列的定义 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进...
队列的定义和算法的实现
进击的Explorer
08-29 791
与栈相反，队列（queue） 是一种先进先出 （first in first out，缩写为FIFO ）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾 （rear），允许删除的一端则称为 队头（front）。 1、链队列–队列的链式表示和实现 用链表表示的队列简称为链队列 ，一个链队列需要两个分别指示队头和队尾的指针（分别称为头指针和尾指针）才能唯一确定。我们给链队列添加一个头结点，并令头指针指向头结点。因此，空的链队列的判决条件为头指针和尾指针均指向头结点。如下
队列的定义和特点
weixin_52634719的博客
09-22 723
他在插入时只能在表尾，在删除时只能在头部进行 只能在表的一端进行插入，在表的另一端进行删除 逻辑结构：一对一 （循环）顺序队或链队 运算规则：只能在队首删除，队尾接入，不能随意访问某个结点 实现方式：具体看什么样的数据结构和存储结构 ...
队列概念理解
guangod的博客
08-13 1673
1.队列的概念 只允许在一端插入数据操作，在另一端进行删除数据操作的特殊线性表；进行插入操作的一端称为队尾（入队列），进行删除操作的一端称为队头（出队列）；队列具有先进先出（FIFO）的特性。可以想像一下排队时的情景 队头移动，出队列时队头向后移动一个位置 如果还有新元素进行入队列容易造成假溢出。 假溢出：顺序队列因多次入队列和出队列操作后出现的尚有存储空间但不能进行入队列操作的溢出。 真溢...
队列（queue）的概念
weixin_57763462的博客
09-03 745
像栈一样，队列（queue）也是一种线性表，它的特性是先进先出，插入在一端，删除在另一端。就像排队一样，刚来的人入队（push）要排在队尾(rear)，每次出队(pop)的都是队首(front)的人。如图1，描述了一个队列模型。 队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点： 队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。 在队尾添加元素，在队头删除元素。 回到顶部 1.2 队列的相关概念 队列的相关概念： 队头与队尾： 允许元素插
数据结构入门----队列的概念及应用
qq1457346557的博客
07-08 660
队列的逻辑结构 队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。 空队列：不含任何数据元素的队列。 允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 队列的操作特性：先进先出FIFO 队列的抽象数据类型定义 InitQueue (&Q) (构造空队列 ) 操作结果：构造一个空队列Q。 DestroyQueue (&Q) (销毁队列结构) ClearQueue (&Q) (队列清空) Queue...
数据结构-队列（Queue）
热门推荐
修心
01-22 2万+
队列（Queue）   队列的基本概念   定义   队列（Queue）。队列简称队。是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。其操作特性为先进后出（First In Last Out，FIFO），并且只允许在队尾进，队头出。   队头（Front）：允许删除的一端，又称队首   队尾（Rear）：允许插入的一端   空队列：不包含任何元素的空表   队列的基本操作   1）InitQueue（&Q）：初始化队
顺序队列--------队头不动
xinger_28的博客
01-27 712
队列概念： 只允许在队尾进行插入操作，在队头进行删除操作，具有先进先出的特性。 队列分为顺序队列以及链表队列，顺序队列分为队头不动与队头移动量种。 今天一篇讨论队头不动的顺序队列。 在图中我们可以看出队头front始终指向0，rear始终指向实际大小的位置，因此在进行队尾插入时较为容易，但在队头删除时需要进行搬移数据，耗费时间。由于队头始终指向0，因此不会出现假溢出现象。  因此，这...
C++实现队列详解及循环队列概念
第2章探讨了队列在C++编程中的实现，这是一种特殊的线性数据结构，遵循先进先出（FIFO）的原则。队列的主要特性是其操作的一致性：数据项仅能在队尾加入（入队），并在队头被删除（出队）。队列的内部管理通常通过两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值