C++队列

最新推荐文章于 2024-06-08 18:30:35 发布
最新推荐文章于 2024-06-08 18:30:35 发布
阅读量5.9k 收藏 8
点赞数 2
文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1291714103/article/details/126070680
版权

文章目录

前言

队列的存储结构有链式和数组两种形式，链式队列较为简单，可以直接通过链表获得，而用数组实现队列则有很多细节，后文中会给出来，本文默认大家已经了解队列的先入先出的特点，重点在于代码实现，如果读者对队列还不熟悉建议先看看书或者视频再来看本文。

数组队列

类的定义

由于我们队列的两种形式都要实现，而两种队列的基本操作其实都是一样的，只不过是函数的实现不同，所以我们定义了抽象类

template<class Type>
 class queueADT
 {
 public:
	 virtual bool isEmpty()const = 0;
	 virtual bool isFull()const = 0;
	 virtual void initializeQueue() = 0;
	 virtual Type front()const = 0;
	 virtual Type back()const = 0;
	 virtual void addElem(const Type&) = 0;
	 virtual void deleteElem() = 0;
	 virtual int queueLen()const = 0;
 };

然后通过类的继承来构造数组队列类,我们将数组的最大容量作为成员变量方便初始化。

template<class Type>
class queueArr :public queueADT<Type>
{
public:
	const queueArr<Type>& operator=(const queueArr<Type>&);
	bool isEmpty()const;
	bool isFull()const;
	void initializeQueue();
	Type front()const;
	Type back()const;
	int queueLen()const;
	void addElem(const Type&);
	void deleteElem();
	queueArr(int size = 100);  //设置默认最大数组长度
	queueArr(const queueArr<Type>&);
	~queueArr();
	void printQueue()const;
private:
	int maxSize;
	int head;
	int tail;
	Type* headPtr;
};

成员函数的实现

  • isEmpty:判断队列是否为空
template<class Type>
bool queueArr<Type>::isEmpty()const
{
	return tail == head;
}

注意:我们这里采用的区别队列满和空的手段是在数组中空一个位置，和王卓老师视频里用的方法一样，实际上比较简单的是将当前的元素数目作为成员变量,tail指针指向的是空置的位置。

  • isFull:判断队列是否已满
template<class Type>
bool queueArr<Type>::isFull()const
{
	return (tail+1)%maxSize == head; 
}
  • initializeQueue:初始化队列，这里的操作就是将头指针和尾指针都指向第一个元素
template<class Type>
void queueArr<Type>::initializeQueue()
{
	head = 0;
	tail = 0;
}
  • front:获得队首元素
template<class Type>
Type queueArr<Type>::front()const
{
	assert(!isEmpty());  //防止队列为空返回错误值
	return headPtr[head];
}
  • back:返回队尾元素
template<class Type>
Type queueArr<Type>::back()const
{
	assert(!isEmpty());
	return headPtr[(tail-1+maxSize)%maxSize]; 
	//注意tail如果为0那么减去1就会是负数，因此要加上数组容量，同时为了防止加了之后的
	//索引值超过了数组最大容量，所以要对maxSize取余
}
  • queueLen:返回当前队列长度
template<class Type>
int queueArr<Type>::queueLen()const
{
	return (tail - head + maxSize) % maxSize;
}

注意:在数组队列中凡是涉及到指针的加减，通通要取余数，如果经过加减后可能出现负数，那么在取余前还要加上数组最大长度。循环计数的精髓就是要取余。

  • addElem:向队列中添加元素(添加到队尾)
template<class Type>
void queueArr<Type>::addElem(const Type& elem)
{
	if (!isFull())
	{
		headPtr[tail] = elem;
		tail = (tail + 1) % maxSize;
	}
	else
		cout << "The queue is full,can not add an element in it" << endl;
}
  • deleteElem:删除队首元素
template<class Type>
void queueArr<Type>::deleteElem()
{
	if (!isEmpty())
		head = (head + 1) % maxSize;
	else
		cout << "can not remove an element from the queue" << endl;
}
  • 构造函数
template<class Type>
queueArr<Type>::queueArr(int size)
{
	if (size <= 0)
	{
		cout << "Size of the array to hold the queue must "
			<< "be positive." << endl;
		cout << "Creating an array of size 100." << endl;
		maxSize = 100;
		headPtr = new Type[maxSize];
		assert(headPtr != nullptr);
	}
	else
	{
		maxSize = size;
		head = 0;
		tail = 0;
		headPtr = new Type[maxSize];
		assert(headPtr != nullptr); //记得判断内存是否分配成功
	}
}
  • 拷贝构造
template<class Type>
queueArr<Type>::queueArr(const queueArr<Type>& otherQueue)
{
	head = otherQueue.head;
	tail = otherQueue.tail;
	maxSize = otherQueue.maxSize;
	headPtr = new Type[maxSize];
	assert(headPtr != nullptr);
	for (int i = 0; i < otherQueue.queueLen(); i++)
		headPtr[(head + i) % maxSize] = otherQueue.headPtr[(head + i) % maxSize];//特别注意，拷贝必须从队头开始拷贝(即从head处开始)，一直拷贝到队尾，拷贝长度就是队列的长度
}
  • 析构函数
template<class Type>
queueArr<Type>::~queueArr()
{
	delete[]headPtr;
}
  • =运算符重载
template<class Type>
const queueArr<Type>& queueArr<Type>::operator=(const queueArr<Type>& otherQueue)
{
	if (this != &otherQueue)
	{
		head = otherQueue.head;
		tail = otherQueue.tail;
		if (maxSize != otherQueue.maxSize)
		{
			delete[]headPtr;
			headPtr = new Type[otherQueue.maxSize];
			assert(headPtr != nullptr);
		}
		maxSize = otherQueue.maxSize;
		if (!otherQueue.isEmpty())
		{
			for (int i = 0; i < otherQueue.queueLen(); i++)
				headPtr[(head+i)%maxSize] = otherQueue.headPtr[(head + i) % maxSize];  //神来之笔，不然因为空了一个元素，而且元素位置不确定，一旦赋值就会出现问题
		}
	}
	else
	{
		cout << "cannot self assignment" << endl;
	}
	return *this;
}
  • printQueue:打印队列的信息
template<class Type>
void queueArr<Type>::printQueue()const
{
	if (!isEmpty())
	{
		cout << "The queue:";
		for (int i = 0; i < queueLen(); i++)
		{
			cout << headPtr[(head + i) % maxSize] << " ";
		}
		cout << endl;
	}
}

全部代码

链式队列很多操作和链表类似，也可以直接从链表获得，这里就不详细介绍了，不过还是给出代码以供参考。

queueADT.h

#pragma once
#include<iostream>
using namespace std;
 template<class Type>
 class queueADT
 {
 public:
	 virtual bool isEmpty()const = 0;
	 virtual bool isFull()const = 0;
	 virtual void initializeQueue() = 0;
	 virtual Type front()const = 0;
	 virtual Type back()const = 0;
	 virtual void addElem(const Type&) = 0;
	 virtual void deleteElem() = 0;
	 virtual int queueLen()const = 0;
 };

queueArr.h

#pragma once
#include<iostream>
#include<assert.h>
#include "queueADT.h"
template<class Type>
class queueArr :public queueADT<Type>
{
public:
	const queueArr<Type>& operator=(const queueArr<Type>&);
	bool isEmpty()const;
	bool isFull()const;
	void initializeQueue();
	Type front()const;
	Type back()const;
	int queueLen()const;
	void addElem(const Type&);
	void deleteElem();
	queueArr(int size = 100);
	queueArr(const queueArr<Type>&);
	~queueArr();
	void printQueue()const;
private:
	int maxSize;
	int head;
	int tail;
	Type* headPtr;
};

template<class Type>
bool queueArr<Type>::isEmpty()const
{
	return tail == head;
}

template<class Type>
bool queueArr<Type>::isFull()const
{
	return (tail+1)%maxSize == head;
}

template<class Type>
void queueArr<Type>::initializeQueue()
{
	head = 0;
	tail = 0;
}

template<class Type>
Type queueArr<Type>::front()const
{
	assert(!isEmpty());
	return headPtr[head];
}

template<class Type>
Type queueArr<Type>::back()const
{
	assert(!isEmpty());
	return headPtr[(tail-1+maxSize)%maxSize];
}

template<class Type>
int queueArr<Type>::queueLen()const
{
	return (tail - head + maxSize) % maxSize;
}

template<class Type>
void queueArr<Type>::addElem(const Type& elem)
{
	if (!isFull())
	{
		headPtr[tail] = elem;
		tail = (tail + 1) % maxSize;
	}
	else
		cout << "The queue is full,can not add an element in it" << endl;
}

template<class Type>
void queueArr<Type>::deleteElem()
{
	if (!isEmpty())
		head = (head + 1) % maxSize;
	else
		cout << "can not remove an element from the queue" << endl;
}

template<class Type>
queueArr<Type>::queueArr(int size)
{
	if (size <= 0)
	{
		cout << "Size of the array to hold the queue must "
			<< "be positive." << endl;
		cout << "Creating an array of size 100." << endl;
		maxSize = 100;
		headPtr = new Type[maxSize];
		assert(headPtr != nullptr);
	}
	else
	{
		maxSize = size;
		head = 0;
		tail = 0;
		headPtr = new Type[maxSize];
		assert(headPtr != nullptr); //记得判断内存是否分配成功
	}
}

template<class Type>
queueArr<Type>::queueArr(const queueArr<Type>& otherQueue)
{
	head = otherQueue.head;
	tail = otherQueue.tail;
	maxSize = otherQueue.maxSize;
	headPtr = new Type[maxSize];
	assert(headPtr != nullptr);
	for (int i = 0; i < otherQueue.queueLen(); i++)
		headPtr[(head + i) % maxSize] = otherQueue.headPtr[(head + i) % maxSize];
}

template<class Type>
queueArr<Type>::~queueArr()
{
	delete[]headPtr;
}

template<class Type>
const queueArr<Type>& queueArr<Type>::operator=(const queueArr<Type>& otherQueue)
{
	if (this != &otherQueue)
	{
		head = otherQueue.head;
		tail = otherQueue.tail;
		if (maxSize != otherQueue.maxSize)
		{
			delete[]headPtr;
			headPtr = new Type[otherQueue.maxSize];
			assert(headPtr != nullptr);
		}
		maxSize = otherQueue.maxSize;
		if (!otherQueue.isEmpty())
		{
			for (int i = 0; i < otherQueue.queueLen(); i++)
				headPtr[(head+i)%maxSize] = otherQueue.headPtr[(head + i) % maxSize];  //神来之笔，不然因为空了一个元素，而且元素位置不确定，一旦赋值就会出现问题
		}
	}
	else
	{
		cout << "cannot self assignment" << endl;
	}
	return *this;
}

template<class Type>
void queueArr<Type>::printQueue()const
{
	if (!isEmpty())
	{
		cout << "The queue:";
		for (int i = 0; i < queueLen(); i++)
		{
			cout << headPtr[(head + i) % maxSize] << " ";
		}
		cout << endl;
	}
}

queueLink.h

#pragma once
#include<iostream>
#include<assert.h>
#include "queueADT.h"
using namespace std;
template<class Type>
struct node
{
	Type elem;
	node<Type>* next;
};

template<class Type>
class queueLink:public queueADT<Type>
{
public:
	 bool isEmpty()const ;
	 bool isFull()const ;
	 void initializeQueue() ;
	 Type front()const ;
	 Type back()const ;
	 void addElem(const Type&) ;
	 void deleteElem() ;
	 int queueLen()const ;
	 queueLink();
	 queueLink(const queueLink<Type>&);
	 ~queueLink();
	 const queueLink<Type>& operator=(const queueLink<Type>&);
private:
	node<Type>* head;
	node<Type>* tail;
	int length;
	void copyQueue(const queueLink<Type>&);
};

template<class Type>
bool queueLink<Type> ::isEmpty()const
{
	return head == nullptr;
}

template<class Type>
bool queueLink<Type> ::isFull()const
{
	return false;
}

template<class Type>
void queueLink<Type>::initializeQueue()
{
	node<Type>* temp = head;
	while (head)
	{
		head = head->next;
		delete temp;
		temp = head;
	}
	tail = nullptr;
	length = 0;
}
template<class Type>
Type queueLink<Type>::front()const
{
	assert(!isEmpty());
	return head->elem;
}
template<class Type>
Type queueLink<Type>::back()const
{
	assert(!isEmpty());
	return tail->elem;
}
template<class Type>
void queueLink<Type>::addElem(const Type& elem)
{
	node<Type>* newNode = new node<Type>;
	newNode->elem = elem;
	newNode->next = nullptr;
	if (head == nullptr)
	{
		tail = newNode;
		head = newNode;
	}
	else
	{
		tail->next = newNode;
		tail = tail->next;
	}
	length++;
}
template<class Type>
void queueLink<Type>::deleteElem()
{
	if (!isEmpty())
	{
		node<Type>* temp = head;
		head = head->next;
		delete temp;
		length--;
	}
	else
		cout << "The queue is empty,cannot remove an element" << endl;
}
template<class Type>
int queueLink<Type>::queueLen()const
{
	return length;
}
template<class Type>
queueLink<Type>::queueLink()
{
	head = nullptr;
	tail = head;
	length = 0;
}
template<class Type>
queueLink<Type>::~queueLink()
{
	initializeQueue();
}
template<class Type>
void queueLink<Type>::copyQueue(const queueLink<Type>& otherQueue)
{
	node<Type>* temp,otherCurrent;
	otherCurrent = otherQueue.head;
	if (head)
		initializeQueue();
	if (otherQueue.head)
	{
		head = new node<Type>;
		tail = head;
		head->elem = otherCurrent->elem;
		head->next = otherCurrent->next;
		otherCurrent = otherCurrent->next;
		length++;
		while (otherCurrent)
		{
			temp = new node<Type>;
			temp->next = otherCurrent->next;
			temp->elem = otherCurrent->elem;
			tail->next = temp;
			tail = tail->next;
			otherCurrent = otherCurrent->next;
			length++;
		}
	}
}
template<class Type>
queueLink<Type>::queueLink(const queueLink<Type>& otherQueue)
{
	copyQueue(otherQueue);
}
template<class Type>
const queueLink<Type>& queueLink<Type>::operator=(const queueLink<Type>& otherQueue)
{
	if (this != &otherQueue)
	{
		copyQueue(otherQueue);
	}
	return *this;
}

test.cpp

#include<iostream>
#include "queueArr.h"
#include "queueLink.h"
using namespace std;

int main()
{
	queueArr<int> que1,que2(4);
	que1.addElem(11);
	que1.addElem(12);
	que1.addElem(13);
	que1.addElem(13);
	que1.addElem(13);
	que1.printQueue();
	cout << que1.queueLen() << endl;
	que1.deleteElem();
	que1.addElem(44);
	que1.deleteElem();
	que1.addElem(32);
	que2 = que1;
	que1.printQueue();
	que2.printQueue();
	queueArr<int> que3(que1);
	que3.printQueue();
	que1.printQueue();
	cout << que1.queueLen() << endl;
	que2 = que1;
	que2.printQueue();
	que2.deleteElem();
	que2.deleteElem();
	que2.deleteElem();
	cout << que1.front() << "," << que1.back() << endl;

	queueLink<int> queL1,queL2;
	queL1.addElem(13);
	queL1.addElem(76);
	
	cout << queL1.front()<<" " << queL1.back();
	return 0;
}
春明外史
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
在编程语言中怎样定义队列及其使用(C++)
12-31
队列在编程语言中是如何定义的呢？小编与大家分享自己的经验。 队列的定义 队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表. 队列犹如一个两端开口的管道.允许插入的一端称为队头,允许删除的一端称为队尾.队头和队尾各用一个”指针”指示,称为队头指针和队尾指针.不含任何结点的队列称为”空队列”.队列的特点是结点在队列中的排队次序和出队次序按进队时间先后确定,即先进队者先出队.因此,队列又称先进先出表.简称FIFO(first in first out)表. 步骤 队列是用来存储暂未处理但需要按一定顺序处理的元素的一种数据结构。 队列是一种先进先出（First
【图文并茂】c++介绍之队列
m0_73421035的博客
09-07 5505
队列（queue）简称队，它也是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作队尾（rear） ：进行插入的一端队首（front）：进行删除的一端入队（enqueue）：插入新元素出队（dequeue）：删除新元素队列是一种先进先出表（FIFO），而前面介绍过的栈是一种先进后出表。（一个队列）
常用C++队列（Queue）详解与应用
最新发布
w_m_x_d的博客
06-08 1196
常用C++队列(queue)详解
数据结构——队列 c++详解
m0_54615144的博客
07-28 8638
1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点： （1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构； （2）在队尾添加元素，在队头删除元素。...
数据结构——队列（C++实现）
weixin_74753331的博客
05-28 5168
使用C++实现队列
c++队列
m0_72125469的博客
08-02 3063
队列：队列也是操作受限的线性表 限定在只能在表的一端进行插入 在表的另一端进行删除 c++队列 队列的基本操作c++ 数据结构c++队列
C++队列堆栈小作业
06-17
C++队列堆栈小作业　
C++队列用法实例
12-25
本文实例讲述了C++队列用法。分享给大家供大家参考。具体如下： /* 队列使用时必须包含头文件 #include <queue> 有以下几种方法 入队push(),出队pop(), 读取队首元素front(),读取队尾元素back() ， 判断队是否有...
C++队列操作.docx
10-30
在C++编程语言中，`std::queue`是标准库中的一个容器适配器，它提供了队列数据结构的功能。队列是一种先进先出（First In First Out, FIFO）的数据结构，这意味着第一个被插入的元素也将是第一个被删除的元素。`std:...
C++队列复原样例解析
08-07
C++队列复原样例解析
容器适配器之queue用法总结
陈实Yepper
12-23 1114
只能访问 queue 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素，只能从头部移除元素。 许多程序都使用了 queue 容器。queue 容器可以用来表示超市的结账队列或服务器上等待执行的数据库事务队列。对于任何需要用 FIFO 准则处理的序列来说，使用 queue 容器适配器都是好的选择。 图 1 展示了一个 queue 容器及其一些基本操作： queue 的生成方式和 sta...
C++数据结构之队列详解
dryter的博客
03-23 1916
此时思考一个问题，当删除元素时（元素出队列时）会出现假饱和的情况，如上图m_data[0]和m_data[1]再进行出队列操作之后，这两个位置可以容纳新的元素，但m_rear没有回到原本的m_data[0]位置，因此需要引入一个新的队列结构，环形队列，m_rear这个位置可以从0到9再到0,周而复始不停的重复，保存的数据像在一个环状空间一样，这种头尾相连的队列结构就叫循环队列。前面的几种队列都可以看成普通的队列，还有一种变形的队列-双端队列。STL中提供的名字叫做deque的容器，就是一个典型的双端队列。
c++队列详解
Yoyo的博客
01-09 2191
定义：队列（queue）在计算机科学里是常用的数据结构之一，是一种特殊的线性表。它只允许在队列头（head）进行删除操作，而在队列尾（tail）进行插入操作。队列为空(没有元素)时不能pop()、front()、back()。性质：队列（queue）只允许在队尾进行插入操作，而在队头进行删除操作。需要注意，head指向第1个元素，而tail是指向最后一个元素的后面。需要注意，head指向第1个元素，而tail是指向最后一个元素的后面。另外：由于可能在队头增加元素，head和tail开始时要在中间位置。
C++数据结构之队列
suren_jun的博客
10-23 2105
这里详细总结一下C++中队列这个数据结构，涉及队列的基本知识，以及队列的变种还有相应的应用场景等，总体来说算是一个知识的检索，不过遇到自己感兴趣的知识，还是会对其进行尝试。
C++数据结构-6-队列
qq_50533529的博客
05-09 2616
基于C++的数据结构-6-队列
c++中的队列
ShineSmile29的博客
09-09 8208
本文参考c++ queue 用法详解 1、什么是队列？ 队列是C ++ STL中定义的简单序列或数据结构，它以FIFO（先进先出）的方式插入和删除数据。队列中的数据以连续方式存储。只能访问 queue 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素，只能从头部移除元素。 2、queue 队列的生成方式 下面展示如何创建一个保存字符串对象的 queue: std::queue<std::string> words; queue<string> words; 也可以使用

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值