数据结构——队列（顺序、链式、循环）

最新推荐文章于 2025-01-02 21:42:39 发布
最新推荐文章于 2025-01-02 21:42:39 发布
阅读量235 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39661206/article/details/89036694

 队列是一种操作受限的线性表数据结构。对于它的操作需要遵守的规则是“先进者先出，后进者后出”，就像我们排队买票一样，排在队伍前边的先买到票先离开，排在队伍后边后买到票后离开，因此队列只支持两种操作，即入队和出队，其中入队是从队列的尾部插入新的元素，而出队则是在队列的头部弹出元素。由于该数据结构的特性，使其在实际中有很多的应用，比如消息队列、阻塞队列、并发队列等。

本文根据队列的基本特性实现了三种基本队列，分别是顺序队列，链式队列和循环队列。

完整实现详见于https://github.com/hitskyer/course/tree/master/dataAlgorithm/liuyanfu/Queue

1 、顺序队列

1.1、接口定义

#ifndef _ARR_QUEUE_H
#define _ARR_QUEUE_H

typedef unsigned int UINT;
template<typename T>
class ArrQueue
{
public:
	ArrQueue(void);
	ArrQueue(const UINT& InitSize);       //初始化队列的总长度
	~ArrQueue(void);
	bool enqueue(const T& data);         //入队
	bool dequeue();                      //出队
	UINT getlength() const;              //获取队列中已使用的长度
	bool empty() const;                  //判断队列是否为空队列
	void erase();                        //清除队列中所有的数据
	void print() const;                  //打印队列中的数据（该接口仅用来测试而已）
private:
	T* m_pQueue;                    
	UINT m_nHead;                        //记录队列头的位置
	UINT m_nTail;                        //记录队列尾的位置
	UINT m_nQueueLen;                    //队列已使用的长度
	UINT m_nQueueSize;                   //队列总的长度
};

#endif //_ARR_QUEUE_H

1.2、实现方式 

#include "ArrQueue.h"
#include <string.h>
#define INITQUEUELEN 5  //默认队列的长度

template<typename T>
ArrQueue<T>::ArrQueue(void)
{
	m_nQueueSize = INITQUEUELEN;
	m_pQueue = new T[m_nQueueSize];
	m_nHead =  0;
	m_nTail = 0;
	m_nQueueLen = 0;
	
}

template<typename T>
ArrQueue<T>::ArrQueue(const UINT& InitSize):m_nQueueSize(InitSize)
{
	m_pQueue = new T[m_nQueueSize];
	m_nHead  = 0;
	m_nTail = 0;
	m_nQueueLen = 0;
}

template<typename T>
ArrQueue<T>::~ArrQueue(void)
{
	delete [] m_pQueue;
	m_pQueue = NULL;
}

/****************************************!
*@brief  入队
*@author lyf
*@date   2019年4月1日	21:12
*@param[out] 
*@param[in]  const T & data  
*@return     bool  
****************************************/
template<typename T>
bool ArrQueue<T>::enqueue(const T& data)
{
	if(!m_pQueue || (m_nTail == m_nQueueSize && m_nHead == 0)) //如果队列满了或者空间的地址无效
		return false;
	else if(m_nTail <  m_nQueueSize)
	{
		m_pQueue[m_nTail++] = data;
		++m_nQueueLen;
		return true;
	}
	else
	{
		//memcpy(m_pQueue, &m_pQueue[m_nHead], sizeof(T) * m_nQueueLen);//目标位置与源位置存在重叠
		for(UINT i = 0; i < m_nQueueLen; ++i)
		{
			m_pQueue[i] = m_pQueue[m_nHead++];
		}
		m_nHead = 0;
		m_pQueue[m_nQueueLen++] = data;
		m_nTail = m_nQueueLen;
		return true;
	}
}

/****************************************!
*@brief  出队
*@author lyf
*@date   2019年4月1日	21:17
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool ArrQueue<T>::dequeue()
{
	if(m_nQueueLen == 0) //队列为空时
		return false;
	else
	{
		m_nHead += 1;
		--m_nQueueLen;
		return true;
	}
}

/****************************************!
*@brief  获取队列有效长度
*@author lyf
*@date   2019年4月1日	21:31
*@param[out] 
*@return     UINT  
****************************************/
template<typename T>
UINT ArrQueue<T>::getlength() const
{
	return m_nQueueLen;
}

/****************************************!
*@brief  判断队列是否为空
*@author lyf
*@date   2019年4月1日	21:32
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool ArrQueue<T>::empty() const
{
	return m_nQueueLen == 0;
}

/****************************************!
*@brief  清空队列
*@author lyf
*@date   2019年4月1日	21:32
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void ArrQueue<T>::erase()
{
	m_nHead = 0;
	m_nTail = 0;
	m_nQueueLen = 0;
}

/****************************************!
*@brief  打印队列中的数据
*@author lyf
*@date   2019年4月1日	21:48
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void ArrQueue<T>::print() const
{
	if(empty())
		std::cout << "Current queue is empty!" << std::endl;
	else
	{
		int index = m_nHead;
		int i = 1;
		while(index != m_nTail)
		{
			std::cout << "The " << i << "th element data is " << m_pQueue[index++] << std::endl;
		}

		std::cout << "All elements are printed." << std::endl;
	}
}

2、链式队列 

由于接口定义与顺序队列类似就不在此赘述，下面直接给出实现方式。

2.1、实现方式

#include "ListQueue.h"

template<typename T>
ListQueue<T>::ListQueue(void)
{
	m_pHead = m_pTail = NULL;
	m_QueueLen = 0;
}

template<typename T>
ListQueue<T>::~ListQueue(void)
{
	erase();
}

/****************************************!
*@brief  入队(入队更新尾)
*@author lyf
*@date   2019年3月31日	23:06
*@param[out] 
*@param[in]  const T & data  
*@return     bool  
****************************************/
template<typename T>
bool ListQueue<T>::enqueue(const T& data)
{
	QueueNode pNewNode = new SNode<T>;
	if(pNewNode == NULL)
		return false;
	else
	{
		pNewNode->data = data;
		pNewNode->pNext = NULL;
		if(m_pHead == NULL)
		{
			m_pHead = pNewNode;
			m_pTail = pNewNode;
		}
		else
		{
			m_pTail->pNext = pNewNode;
			m_pTail = pNewNode;
		}
		
		++m_QueueLen;
		return true;
	}
}


/****************************************!
*@brief  出队(出队更新头)
*@author lyf
*@date   2019年3月31日	23:06
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool ListQueue<T>::dequeue()
{
	if(m_QueueLen == 0)
		return false;
	else
	{
		QueueNode TempNode = m_pHead->pNext;
		delete m_pHead;
		m_pHead = TempNode;
		--m_QueueLen;
		return true;
	}
}

/****************************************!
*@brief  
*@author lyf
*@date   2019年3月31日	22:47
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void ListQueue<T>::print() const
{
	if(m_QueueLen == 0)
		std::cout << "Current queue is empty!" << std::endl;
	else
	{
		QueueNode TempNode = m_pHead;
		UINT i = 1;
		while(TempNode)
		{
			std::cout << "The " << i << "th element data is " << TempNode->data << std::endl;
			++i;
			TempNode = TempNode->pNext;
		}
		std::cout << "All elements are printed." << std::endl;
	}
}

/****************************************!
*@brief  
*@author lyf
*@date   2019年3月31日	22:47
*@param[out] 
*@return     UINT  
****************************************/
template<typename T>
UINT ListQueue<T>::getlength() const
{
	return m_QueueLen;
}

/****************************************!
*@brief  
*@author lyf
*@date   2019年3月31日	22:47
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool ListQueue<T>::empty() const
{
	return m_QueueLen == 0;
}

/****************************************!
*@brief  
*@author lyf
*@date   2019年3月31日	22:47
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void ListQueue<T>::erase()
{
	while(!empty())
	{
		dequeue();
	}
	m_pHead = m_pTail = NULL;
}

3、循环队列 

同样接口定义与顺序队列类似，因此不过多赘述。

3.1、实现方式

#include "CircleQueue.h"
#define INITQUEUELEN 5

template<typename T>
CircleQueue<T>::CircleQueue(void)
{
	m_nQueueSize = INITQUEUELEN;
	m_pQueue = new T[m_nQueueSize];
	m_nHead = 0;
	m_nTail = 0;
	m_nQueueLen = 0;
}

template<typename T>
CircleQueue<T>::~CircleQueue(void)
{
	delete []m_pQueue;
	m_pQueue = NULL;
}

template<typename T>
CircleQueue<T>::CircleQueue(const UINT &InitSize):m_nQueueSize(InitSize)
{
	m_pQueue = new T[m_nQueueSize];
	m_nHead = 0;
	m_nTail = 0;
	m_nQueueLen = 0;
}

/****************************************!
*@brief  入队
*@author lyf
*@date   2019年4月2日	23:49
*@param[out] 
*@param[in]  const T & data  
*@return     bool  
****************************************/
template<typename T>
bool CircleQueue<T>::enqueue(const T& data)
{
	if((m_nTail + 1) % m_nQueueSize == m_nHead) //判断队列是否已满
		return false;
	else
	{
		m_pQueue[m_nTail] = data;
		m_nTail = (m_nTail + 1) % m_nQueueSize; //注意队列尾位置的更新方式
		++m_nQueueLen;
		return true;
	}
}

/****************************************!
*@brief  出队
*@author lyf
*@date   2019年4月2日	23:53
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool CircleQueue<T>::dequeue()
{
	if(m_nHead == m_nTail) //判断队列是否为空
		return false;
	else
	{
		m_nHead = (m_nHead + 1) / m_nQueueSize; //注意队列头位置的更新方式
		--m_nQueueLen;
		return true;
	}
}

/****************************************!
*@brief  获取队列中有效数据的长度
*@author lyf
*@date   2019年4月2日	23:54
*@param[out] 
*@return     UINT  
****************************************/
template<typename T>
UINT CircleQueue<T>::getlength() const
{
	return m_nQueueLen;
}

/****************************************!
*@brief  
*@author lyf
*@date   2019年4月2日	23:54
*@param[out] 
*@return     bool  
****************************************/
template<typename T>
bool CircleQueue<T>::empty() const
{
	return m_nHead == m_nTail; //m_nQueueLen == 0;
}

/****************************************!
*@brief  清空队列
*@author lyf
*@date   2019年4月2日	23:55
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void CircleQueue<T>::erase()
{
	m_nHead = 0;
	m_nTail = 0;
	m_nQueueLen = 0;
}

/****************************************!
*@brief  打印队列中的有效数据
*@author lyf
*@date   2019年4月2日	23:56
*@param[out] 
*@return     void  
****************************************/
template<typename T>
void CircleQueue<T>::print() const
{
	if(empty())
		std::cout << "Current queue is empty!" << std::endl;
	else
	{
		UINT index = m_nHead;
		int i = 1;
		while(index != m_nTail) 
		{
			std::cout << "The " << i << "th element data is " << m_pQueue[index] << std::endl;
			index = (index + 1) / m_nQueueSize; //索引需要通过对模取余的方式确定
			++i;
		}

		std::cout << "All elements are printed." << std::endl;
	}
}

 

数据结构——队列
weixin_47924016的博客
06-08 809
队列的基本概念顺序队列链式队列循环队列队列操作核心语句总结rear++;a[rear]=x;或 a[++rear]=x;front++;x=[front];或 x=[++front];Qs[rear]=x;或Qs[++rear%M]=x;或 x=Qs[++front%M];
数据结构与算法——循环队列链式队列
moyu的博客
03-20 5901
队列 1、也是一种操作受限的线性表，规定只能在一端插入，一端删除，有先进先出的特点。 2、顺序队列，队首指针指向队首元素，队尾指针指向队尾元素的前一个元素，此时队列为空的判定条件是 Q.front == Q.rear == 0; 2、顺序队列会有假溢出的现象，为此设计了循环队列。 1）为了区分队满和队空的条件，循环队列往往采用少用一个单元进行入队 队满判定条件：（Q.rear+...
数据结构之队列
猎户星座
02-24 841
1、队列的基本概念 队列（queue）是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 　　队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—firs
【数据结构初阶】顺序循环队列和链式循环队列
每天都要坚持刷题的博客
08-07 1427
【数据结构初阶】顺序循环和链式循环队列
队列的顺序实现和链式实现
ysg.name
09-25 572
队列的顺序实现和链式实现
数据结构——队列（循环队列）的基本操作（实现链队列逐一取出c语言代码）
軒轅劍的博客
06-26 4433
队列队列是一种重要的线性结构，与栈相同也需要顺序表或者链表作为基础。队列是先进先出（first in first out）FIFO的线性表。所有数据从队列的一端进入，从另一端离开。队列中允许插入数据一端称队尾（rear），允许数据离开的一端称队头（front）既可以是顺序表也可以是链表创建一个空队列入队列操作出队列操作实例分析/***********************************...
顺序队列与链式队列
Nessie_zhao的博客
04-12 3748
队列首先介绍一下什么是队列：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另
数据结构——队列的链式存储（优缺点及代码实现:C语言）
fuckfunk的博客
04-26 1259
详细介绍数据结构中队列的链式存储结构 并通过C语言实现基本操作，最后附有完整示例
数据结构——队列（链式结构）
鲸落博客
07-22 757
队列的链式存储结构是一种用链表实现的队列，它不像顺序存储结构那样需要预先分配固定大小的空间。链式存储结构的队列由节点组成，每个节点包括数据和指向下一个节点的指针。队列的链式存储结构可以动态地分配内存，更灵活地处理数据。在链式存储结构中，入队和出队操作会改变节点之间的指针关系，而不需要像顺序存储结构那样频繁地移动数据。这使得链式存储结构适用于需要频繁插入和删除操作的场景。空队列时，front和rear都指向头结点。
数据结构——队列的顺序存储实现(循环队列)
最新发布
xb1132的博客
01-02 923
如果我们一开始将几个元素入队(入队在队尾入)，然后再出队(出队是在队头出)那么front就会++，不会再指向0，然后再往队列里面插入元素，当rear=maxsize时如果还有元素要插入的话就会造成数组越界(从下标为0开始，最大下标为maxsize-1)，但是front(front不为0)之前还有位置是空的还可以再插入数据，此时怎么将数据插入到下标为0的位置呢？动态扩容方便：在链式存储队列中，当需要增加新的元素时，只需动态地分配新的节点即可，无需进行大量数据的移动。，所以顺序存储结构还存储了队列的。
数据结构——队列（顺序结构）
鲸落博客
07-22 590
入队在队列的末尾插入新元素，出队则是从队列的头部移除元素。循环队列是一种特殊的队列数据结构，它允许在队列头尾相接的情况下进行元素的入队和出队操作。
数据结构-----循环队列 链式队列
FDk_LCL的博客
04-02 2808
目录 队列的定义 顺序队列 循环队列 循环队列的实现 链式队列 链式队列的实现 队列的定义 队列是一种只允许一端进行插入操作，一端只允许进行删除操作的线性表。 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入和在表的另一端删除元素。在队列中，允许插入的一段叫做队尾（rear），允许删除的一端叫做队头（front）。假设队列为q = (a...
Python实现--队列的顺序存储和链式存储
嗨皮lemon的博客
05-09 1071
队列：允许插入的一端为队头front，允许删除的一端为队尾rear，先进先出的原则。 顺序队列：sequential queue 队尾指针指示队尾元素在一维数组中的当前位置，队头指针指示队头元素在一维数组中当前位置的前一个位置，空队列self.front= self.rear = 0 链式队列：linked queue 一个同时带有头指针和尾指针的单链表，头指针指向头结点，尾指针指向尾结点 cla...
顺序队列/链式队列
sandmm112的博客
04-09 2388
        队列是另一种限定性的线性表，他只允许在表的一端插入元素，而在表的另一端删除元素，具有“先进先出”的特点。在队列中，允许插入的一端称为队尾，允许删除的一端称为队首。        与线性表相似，队列也有两种存储结构：顺序队列和链式队列。一，顺序队列        顺序队列使用顺序表来实现的，即队列中的元素均存放在一片连续的内存空间中。通过该片内存的地址对队列中元素进行访问。之前是用数...
数据结构（三）顺序队列，链式队列与循环队列
kuimzzs的博客
08-09 1781
顺序队列，就是数组，不多赘述 链式队列就是用链表来实现队列，像链表一样，在头部增加头部指针指向头结点，在尾部增加尾部指针指向队尾节点。 代码如下： /* 链式队列，也就是用链表实现的对列，用指针指向头结点做front,尾部也来一个指针指向rear，而当front和rear相等时，队列为空 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&...
数据结构之python实现队列的链式存储
不服输的南瓜的博客
02-26 2116
定义： 链式队列在创建一个队列时，队头指针front和队尾指针rear指向结点的data域和next域均为空。 python实现： class QueueNode(): def __init__(self): self.data = None self.next = None class LinkQueue(): def __init__(self)...
顺序队列和链式队列的python实现
weixin_41789943的博客
04-03 762
队列: 是一种受限的线性数据结构,先进先出,尾端插入头端出列 顺序队列 数组实现的队列: 1.在出队的时候整个队列的数据都往头迁移,这样的话时间复杂度就是O(n),入队的时间复杂度为O(1) 2.出队的时候直接从队头弹出一个数据,然后头指针往后迁移​一步,这中出队操作的时间复杂度是O(1),但是入队就需要判定下是否队列满了,假如满了但是头指针在队头就扩充,假如头指针在队尾就做数据迁移 但是这...
队列 （顺序循环队列和链式队列）
指弹键盘哼民谣
04-12 1112
循环队列 #include<iostream> #define MAXIMUN 1000 using namespace std; typedef struct queue_node //循环队列 { int* data; //记录队列的元素个数 int front,rear,count; //记录队头和队尾元素下标 }queue; void init_queue(...
队列的基本操作（顺序队列、循环队列、链式队列）
热门推荐
Keep Fighting All The Time
05-23 5万+
&amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 队列也是一种线性表，是一种先进先出的线性结构。队列只允许在表的一端进行插入（入队）、删除（出队）操作。允许插入的一端称为队尾，允许删除的一端称为队头。 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp;队列的基本操作包括： 初始化队列：InitQueue（Q） &amp;nbsp; &
深入浅出队列算法——数据结构与天大作业实践
### 数据结构中的队列算法知识点 #### 1. 队列的基本概念 队列是一种先进先出（First In First Out, FIFO）的数据结构，它有两个主要操作：入队（enqueue）和出队（dequeue）。入队操作将一个数据元素添加到队列的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值