队列（queue）之基础实现

最新推荐文章于 2022-09-11 12:04:45 发布
最新推荐文章于 2022-09-11 12:04:45 发布
阅读量770 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： delete exception insert null string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenloug/article/details/6907315
本文详细介绍了队列的概念及其两种实现方式：基于指针的队列和基于数组的队列。每种实现方式都提供了队列的基本操作，包括插入、删除、获取队首元素等，并讨论了各自的优缺点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

         队列类似于人员排队。首先加入列队的人最先得到服务，并第一个离队，队列项在队尾（back或rear）加入，从对头（front）离队。队列的操作只发生在两端，这使得队列具有先进后出（first-in first-out简写为FIFO）的特性，相对而言，可认为栈只有一端。因为所有的操作都在栈顶执行。这使得栈具有后进先出的特性。

以下是对的几个实现：

1、queue的异常处理类：

#ifndef QUEUE_EXCEPTION_H_
#define QUEUE_EXCEPTION_H_
#include<stdexcept>
#include<string>
using namespace std;
class queueException:public logic_error
{
	public:
		queueException(const string &message="")
			:logic_error(message.c_str())
		{}
};
#endif

 

2、基于指针的队列的实现：

#ifndef QUEUE_POINTER_H_
#define QUEUE_POINTER_H_
#include<string>
#include"queue_exception.h"
template<class T>
class Queue
{
	public:
		//constructor and destructor
		Queue();
		Queue(const Queue &aqueue);
		~Queue();
		//operation functions
		bool isEmpty()const;
		//Detemines whether a queue is empty
		//precondition :None
		//postcondition :returns true if the queue is 
		//empty otherwise returns false
		void enqueue(T newitem)throw(queueException);
		//insert an item at the back of the queue
		//precondition :newitem is the item to be inserted
		//postcondition :if the insertion was successfull
		//newitem is at the back of the queue
		//Exception :throw queueException if newitem cannot 
		//be placed on the queue

		void dequeue()throw(queueException);
		//delete an item at the first of the queue
		//precondition:none
		//postcondition :if the queue is not empty, the item
		//that was added to the queue earlist is delete
		//exception :throws queueexception if the queue if
		//empty

		void dequeue(T & queueFront)throw(queueException);
		//retrieve and delete the front of a queue
		//precondition :none
		//postcondition :if the queue is not empty
		//queueFront contains the items that was 
		//added first and the is deleted
		//exception:throw queueexception if the queue is empty

		void getFront(T &queueFront)const throw(queueException);
		//retrieve the item at the front of a queue
		//precondition :none
		//postcondition :if the queue is not empty
		//queufront contains the item that was added to the queue
		//earlist Exception:throw queueexception if the queue
		//is empty;
	private:
		//the queue is implemented as a linked list
		//with one external pointer to the front and
		//a second pointer to the back of the queue.
		struct Node
		{
			T  items;
			Node *next;
		};
		Node *frontPtr;
		Node *backPtr;
};
#endif

 

#include"queue_pointer.h"
#include<cstddef>
#include<cassert>
template<class T>
Queue<T>::Queue()
{
}
template<class T>
Queue<T>::Queue(const Queue &aqueue)
{
	if(aqueue.frontPtr==NULL)
		frontPtr=backPtr=NULL;
	else
	{
		Node *newPtr= new Node;
		assert(newPtr!=NULL);
		Node *originPtr=aqueue.frontPtr;
		newPtr->items=originPtr->item;
		newPtr->next=NULL;
		frontPtr=newPtr;
		originPtr=originPtr->next;
		while(originPtr!=aqueue.backPtr)
		{
			newPtr->next=new Node;
			assert(newPtr!=NULL);
			newPtr=newPtr->next;
			newPtr->items=originPtr->items;
			newPtr->next=NULL;
			originPtr=originPtr->next;
		}
		backPtr=new Node;
		assert(backPtr!=NULL);
		backPtr->items=originPtr->items;
		backPtr->next=NULL;
	}
}
template<class T>
Queue<T>::~Queue()
{
	while(frontPtr!=NULL)
		dequeue();
	assert((frontPtr==NULL)&&(backPtr==NULL));
}
template<class T>
bool Queue<T>::isEmpty()const
{
	return backPtr==NULL;
}
template<class T>
void Queue<T>::enqueue(T newitem)throw(queueException)
{
	Node *newPtr=new Node;
	if(newPtr==NULL)
		throw queueException("queueException :insert new item faild !");
	else{
	
		newPtr->items=newitem;
		newPtr->next=NULL;
		backPtr->next=newPtr;
		backPtr=newPtr;
	}
}
template<class T>
void Queue<T>::dequeue()throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :delete the front item failed !");
	else
	{
		Node *temp=frontPtr;
		frontPtr=frontPtr->next;
		temp->next=NULL;
		delete temp;
	}
}
template<class T>
void Queue<T>::dequeue(T &queueFront)throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :delete the front items failed !");
	else
	{
		Node *temp=frontPtr;
		frontPtr=frontPtr->next;
		queueFront=temp->items;
		temp->next=NULL;
		delete temp;
	}
}
template<class T>
void Queue<T>::getFront(T &queueFront)const throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :get front items failed !");
	else
	{
		queueFront=frontPtr->items;
	}
}


3、基于数组的队列的实现：

将数组看作为一个环形空间，通过在数组中顺时针移动front 和back 前移队列索引front（删除数据项）和back（插入数据项）。当front或back前移超过MAX-QUEUE-1 时，将返回0，从而消除了前面的实现中的右移的问题，因为循环数组不存在终点。在这种方案中唯一的困难是检测对空和队满的条件，似乎将“front 比back超前一个空间”作为对空的条件，这似乎说明：当队列变空时，front将超前back。只不过这个条件也可能指示一个队列已满。为此这里用了三种方法已标记队列的状态。

为初始化队列，将front设置为0，将back设置为MAX-QUEUE-1，在增加back和front时使用模运算（back=(back+1)%MAX-QUEUE）,即可取得循环队列的返回效果。

1）设置一个int 成员变量count ，用于指示队列的项数。

#ifndef QUEUE_ARRAY1_H_
#define QUEUE_ARRAY1_H_
#include"queue_exception.h"
const int MAX=20;
template<class T>
class Queue
{
	public:
		//constructor
		Queue();
		//operation functions
		bool isEmpty()const;
		//detemines whether the queue is empty
		void enqueue(T newitem)throw(queueException);
		//insert an item in the back of the queue if the
		//queue is not full
		void dequeue()throw(queueException);
		//delete an item in the front of the queue if
		//queue is not empty
		void dequeue(T &queueFront)throw(queueException);
		//delete an item in the front of the queue if the 
		//queue is not empty and queueFront contains the value
		//that was being delete
		void getFront(T &queueFront)const throw(queueException);
		//retrieve the queue and queueFront contains the 
		//value of the front items;
	private:
		T items[MAX];
		int size;
		int front;
		int back;

};
#endif

 

#include"queue_array1.h"
template<class T>
Queue<T>::Queue()
{
	size=0;
	front=0;
	back=MAX-1;
}
template<class T>
bool Queue<T>::isEmpty()const
{
	return size==0;
}
template<class T>
void Queue<T>::enqueue(T newitem)throw(queueException)
{
	if(size==MAX)
		throw queueException("queueException :insert new itesm failed !");
	else{
	back=(back+1)%MAX;
	items[back]=newitem;
	size++;
	}
}
template<class T>
void Queue<T>::dequeue()throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :delete the froont  item failed !");
	else
	{
		front=(front+1)%MAX;
		size--;
	}
}
template<class T>
void Queue<T>::dequeue(T &queueFront)throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :delete the front item failed !");
	else
	{
		queueFront=items[front];
		front=(front+1)%MAX;
		size--;
	}
}
template<class T>
void Queue<T>::getFront(T &queueFront)const throw(queueException)
{
	if(isEmpty())
		throw queueException("queueException :get the front item failed !");
	else
	{
		queueFront=items[front];
	}
}


2）设置一个bool 类型的变量isFull，当未满时为false，否则为true

 

#ifndef QUEUE_ARRAY2_H_
#define QUEUE_ARRAY2_H_
#include"queue_exception.h"
const int MAX=20;
template<class T>
class Queue
{
	public:
		Queue();

		bool isEmpty()const;
		void enqueue(T newitem)throw(queueException);
		void dequeue()throw(queueException);
		void dequeue(T &queueFront)throw(queueException);
		void getFront(T &queueFront)const throw(queueException);
	private:
		T items[MAX];
		int back;
		int front;
		bool isFull;
};
#endif

 

#include"queue_array2.h"
template<class T>
Queue<T>::Queue()
{
	isFull=false;
	front=0;
	back=MAX-1;
}
template<class T>
bool Queue<T>::isEmpty()const
{
	return ((front==(back+1)%MAX)&&!isFull);
}
template<class T>
void Queue<T>::enqueue(T newitem)throw(queueException)
{
	if(isFull)
		throw queueException("insert new item in the queue failed !");
	else
	{
		back=(back+1)%MAX;
		items[back]=newitem;
		if(front==(back+1)%MAX)
			isFull=true;
	}
}
template<class T>
void Queue<T>::dequeue( )throw(queueException)
{
	if((front==(back+1)%MAX)&&!isFull)
		throw queueException("delete  item in the queue failed !");
	else
	{
		if(isFull)
         		isFull=false;
		front=(front+1)%MAX;
	
	}
}
template<class T>
void Queue<T>::dequeue(T &queueFront)throw(queueException)
{
	if((front==(back+1)%MAX)&&!isFull)
		throw queueException("delete item in the queue failed !");
	else
	{
		if(isFull)
			isFull=false;
		queueFront=items[front];
		front=(front+1)%MAX;
	}
}
template<class T>
void Queue<T>::getFront(T & queueFront)const throw(queueException)
{
	if((front==(back+1)%MAX)&&!isFull)
		throw queueException("get front item failed !");
	else
	{
		queueFront=items[front];
	}
}


3）为数组声明MAX-QUEUE+1个位置，但只使用其中的MAX-QUEUE个位置，剩下的一个数组位置，使front成为对头之前位置的索引。

#ifndef QUEUE_ARRAY3_H_
#define QUEUE_ARRAY3_H_
#include"queue_exception.h"
const int MAX=21;
template<class T>
class Queue
{
	public:
		Queue();
		bool isEmpty()const;
		void enqueue(T newitem)throw(queueException);
		void dequeue()throw(queueException);
		void dequeue(T &queueFront)throw(queueException);
		void getFront(T &queueFront)const throw(queueException);
	private:
		T items[MAX];
		int front;
		int back;
};
#endif


 

#include"queue_array3.h"
template<class T>
Queue<T>::Queue()
{
	front=0;
	back=MAX-1;
}
template<class T>
bool Queue<T>::isEmpty()const
{
	return front==((back+1)%MAX);
}
template<class T>
void Queue<T>::enqueue(T newitem)throw(queueException)
{
	if(front==back)
		throw queueException("queueException :insert new item failed !");
	else
	{
		back=(back+1)%MAX;
		items[back]=newitem;

	}
}
template<class T>
void Queue<T>::dequeue( )throw(queueException)
{
	if(front==(back+1)%MAX)
		throw queueException("queueException :delete the item failed !");
	else
	{
		front=(front+1)%MAX;
	}
}
template<class T>
void Queue<T>::dequeue(T &queueFront)throw(queueException)
{
	if(front==(back+1)%MAX)
		throw queueException("queueException :delete the item failed !");
	else
	{
		front=(front+1)%MAX;
		queueFront=items[(front+1)%MAX];
	}
}
template<class T>
void Queue<T>::getFront(T &queueFront)const throw(queueException)
{
	if(front==(back+1)%MAX)
		throw queueException("queueException :get front item failed!");
	else
	{
		queueFront=items[(front+1)%MAX];
	}
}

这个实现没有维护计数器和标志的开销，但运行的时间更少，对于标准数据类型，该实现所需的空间与需要维护计算器或标志的实现相同，但对于比较复杂的数据，在额外数组位置上浪费的内存会非常大。


3、基于ADT的队列的实现：

#ifndef QUEUE_ADT_H_
#define QUEUE_ADT_H_
#include<list>
#include"queue_exception.h"
using namespace std;
template<class T>
class Queue
{
	public:
		Queue();
		bool isEmpty()const;
		void enqueue(T newitem)throw(queueException);
		void dequeue()throw(queueException);
		void dequeue(T &queueFront)throw(queueException);
		void getFront(T &queueFront)const throw(queueException);
	private:
		list<T> alist;
};
#endif

 

#include"queue_adt.h"
template<class T>
Queue<T>::Queue()
{
}
template<class T>
bool Queue<T>::isEmpty()const
{
	return (alist.empty());
}
template<class T>
void Queue<T>::enqueue(T newitem)throw(queueException)
{
	try{
		alist.insert(alist.size()+1,newitem);
	}
	catch(...)
	{
		throw queueException("queueException :insert new item failed !");
	}
}
template<class T>
void Queue<T>::dequeue()throw(queueException)
{
	try{
		alist.remove(1);
	}catch(...)
	{
		throw queueException("queueException :delete the front item failed !");
	}
}
template<class T>
void Queue<T>::dequeue(T &queueFront) throw(queueException)
{
	try{
		queueFront=alist.retrieve(1);
		alist.remove(1);
	}catch(...)
	{
		throw queueException("queueException :delete the item failed !");
	}
}
template<class T>
void Queue<T>::getFront(T &queueFront)const throw(queueException)
{
	try{
		queueFront=alist.retrieve(1);
	}catch(...)
	{
		throw queueException("queueException : get the front item failed !");
	}
}




 

chenloug
关注
实现队列的入队和出队操作
Simpthan的博客
04-26 5069
1）顺序队#include &lt;iostream&gt;  using namespace std; const int MAX=10;  class Queue{  private:     int front;     int rear;     int data[MAX];  public:     Queue(){front=rear=MAX-1;}      ~Queue(...
E0864 queue 不是模板
u012719076的博客
04-29 2198
c++中 在添加#include 后，弹出 E0864 queue 不是模板 是因为queue 在命名空间std里，还需要添加声明 #include #include <iostream> using namespace std; #include <queue>
计蒜客 数据结构 Queue
vvickey11的博客
08-11 450
//数据结构--C++--队列 //队列的定义、插入、删除 #include using namespace std; class Queue{ private: int* data; int head, tail, length; public: Queue(int length_input){ //开辟
Queue——队列
如风暖阳的博客
07-09 2929
Queue——队列
Java 数据结构之队列(Queue)详解
swadian2008的博客
09-11 3万+
但需要注意的是，由于数组的容量是固定的，当队列已满时，无法再添加新的元素，除非进行元素的出队操作。通过enqueue()方法将元素入队，dequeue()方法将元素出队，peek()方法返回队列头部元素，size()方法返回队列当前元素个数，isEmpty()方法和isFull()方法检查队列是否为空或已满。Deque接口还提供了一些其他方法，如size()用于返回双端队列中的元素个数，isEmpty()用于判断双端队列是否为空，clear()用于清空双端队列中的所有元素等。
队列queue的实现
05-15
`std::queue`是一个基本的FIFO队列，而`std::priority_queue`则是一个最小堆实现的优先级队列。我们将主要关注`std::queue`的实现。 ### `std::queue`基础 `std::queue`是一个容器适配器，它使用其他容器（通常是`...
python队列Queue的详解
09-19
`Queue.Queue(maxsize=0)`是基础的FIFO队列实现。`maxsize`参数用于指定队列的最大容量。如果设置为非零整数，当队列满时，`put()`操作会被阻塞，直到队列中有元素被消费。如果`maxsize`小于或等于0，则队列大小...
C++基础：STL之队列queue
知行合一 止于至善
10-25 1489
这篇文章介绍一下STL中队列queue的基本使用方法。
基于python的数据结构代码实现-队列Queue
06-25
本教程将深入探讨如何在Python中实现队列Queue的数据结构。 首先，Python标准库提供了`queue`模块，该模块已经包含了队列的实现，如`Queue`、`LifoQueue`和`PriorityQueue`。但为了理解其工作原理和自定义功能，...
Standard Template Library (STL) - std::queue::pop
程永强
02-29 753
Standard Template Library (STL) - std::queue::pop public member function - 公开成员函数 1. std::queue::pop void pop(); removes the first element - 删除队列的第一个元素。 Remove next element 删除 queue 中前端的元素。 Removes the next element in the queue, effectively reducing its s
队列的基本原理及实现
BUPT-WT的博客
08-15 1万+
基本原理： 队列是有序集合，新添加的一端为队尾，另一端为队头，当一个元素从队尾进入队列时，一直向队首移动，直到它成为移除的元素为止。这种排序是先进先出FIFO，生活中常见的例子就是去学校食堂打饭，人多时候需要排队，排队在前面的同学先打饭，新来的同学在后面排队，知道前面同学都打完饭，才轮到它 代码实现： 1、小游戏：小时候大家玩过一个游戏，大家围成一个圈，从某一个人开始报数，知道某个人报数...
进程间通信-Queue(python版）
人饭子的博客
10-25 736
进程间通信-Queue Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。 1. Queue的使用 可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：#coding=utf-8 from multiprocessing import Queue q=Queu
C++实现普通队列，循环队列的基本操作（初始化，入队，出队，获取队列首元素等）
多反思，多回顾，要坚持。
02-26 3万+
队列是一种先进先出（FIFO，First-In-First-Out）的线性表，通常用链表或者数组来实现。队列只能在队尾插入元素，只能在队首删除元素。 队列的一些性质： 1.出队方案唯一 2.队首元素先出 3.新元素插入队尾 线性队列的初始化： #include using namespace std; class Queue{ private: int *data;
队列（Queue）——先进先出（FIFO）的数据结构（Data Structures）
853的博客
09-24 2万+
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 ----------摘自百度百科 在日常生活中，排队是司空见惯的。我们去食堂打饭需要排队，买票需要排队，上下飞机也需要排队. 其实，生活中到处都是队列形式，从抽象层面上看，凡是两头
Python中的四种队列（queue）、堆（heap）
白马负金羁
01-29 7170
Python中提供了四种内置的队列实现，特别地其中的优先级队列可以用来实现堆。此外，在Python中我们也直接使用堆。熟练掌握这些数据结构，在问题求解时可以大大简化代码的实现。文末将结合一道Leetcode题目来作为演示
第十章第十题（Queue类）（Queue class）
jxh1025_的博客
10-26 3472
第十章第十题（Queue类）（Queue class） *10.10（Queue类）10.6节给出了一个Stack类。设计一个名为Queue的类用于存储整数。像栈一样，队列保存元素。在栈中，元素以“后进先出”的方式获取。在队列中，元素以“先进先出”的方式 获取。该类包含： 一个名为element的int[]类型的数据域，保存队列中的int值。 一个名为size的数据域，保存队列中的元素个数。 一个构造方法，以默认容量为8来创建一个Queue对象。 方法enqueue(int v),用于将v加入队列中。
链式队列实现完整版
舒哥的blog
07-12 480
SeqQueue: [cpp] view plain copy print? /*============================================================================= # #      Author: liangshu - cbam  # #      QQ : 756029571  # #   
C语言队列Queue的实现与使用示例
### 标题：“C语言实现的队列Queue” 在C语言中实现队列，通常会涉及到对C语言基础知识点的应用，例如指针、结构体、动态内存分配、条件判断等。队列的实现可以用数组或者链表来完成。使用数组实现队列时，需要注意...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值