【C++数据结构】用双栈实现队列（类模板）

于 2024-04-24 06:00:00 发布
阅读量816 收藏 14
点赞数 18
文章标签： 数据结构 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80937868/article/details/138140890
版权

目录

前言：

一、用栈实现队列的方法

二、代码实现

1.创建结点

2.创建栈

（1）入栈函数

（2）出栈函数定

（3）清空函数

3.创建队列（私有成员为栈）

（1）入列函数

（2）出列函数

（3）清空函数

（4）打印函数

（5）交换函数

（6）main函数

三、完整代码

前言：

        栈和队列都是动态集合，在栈中，被删除的是最后插入的元素：实现的是一种后进先出（last-in，first-out，LIFO）策略。类似地，在队列中，被删去的总是最先进入的那个元素：实现的是一种先进先出（first-in，first-out，FIFO）策略。本文将介绍用栈实现队列的方法。

提示：以下是本篇文章正文内容，代码注释较为详细，可供参考

一、用栈实现队列的方法

        由于要实现先进先出的策略，所以可以让一个栈(m_hold)用来存储数据。在需要完成出列的操作时，将存储数据的栈重新放入一个新的栈(m_out)，这样便能时最先存入的数据成为新栈的最后存入的数据。再让新栈完成一次出栈操作，便将最先存入的数据先输出，从而实现先进先出的策略。

        可用下图简略表示用双栈实现出列这一过程：

二、代码实现

1.创建结点

        关于结点的建立就不赘述了，这里要注意的是后面要用到的类模板Stack以及Queue要先提前声明，否则在Node类里声明友元时会报错。

2.创建栈

        入栈出栈清空都是基本的写法，不多赘述。

template<class T>
class Stack {
private:
	Node<T>* m_top = nullptr;//栈顶指针
public:
	Stack() = default;//默认构造
	Stack(const Stack&) = delete;//禁止复制
	Stack& operator=(const Stack&) = delete;//禁止赋值
	~Stack() {
		clear();
	};//析构
	void clear();//清空栈
	void push(const T& val);//入栈
	void pop();//出栈
	bool empty()const {
		return this->m_top == nullptr;
	}//判断是否为空
	const T& top() {
		return this->m_top->m_data;
	}//取出栈顶元素
	friend class Queue<T>;//声明友元
};

（1）入栈函数

template<class T>
void Stack<T>::push(const T& val) {
	Node<T>* node = new Node<T>(val);
	node->m_next = this->m_top;
	this->m_top = node;
}

（2）出栈函数

template<class T>
void Stack<T>::pop() {
	if (empty()) {
		return;
	}
	Node<T>* p = this->m_top;
	this->m_top = this->m_top->m_next;
	delete p;
}

（3）清空函数

template<class T>
void Stack<T>::clear() {
	Node<T>* p = nullptr;
	while (this->m_top != nullptr) {
		p = this->m_top;
		this->m_top = this->m_top->m_next;
		delete p;
	}
}

3.创建队列（私有成员为栈）

        其中私有成员栈m_hold用来存储数据，栈m_out用来出列以及打印数据，类定义如下：

template<class T>
class Queue {
private:
	Stack<T> m_hold, m_out;//设置两个栈，hold用来完成入列操作(后进排在后面)，out用来出列(先进先出)
public:
	Queue() = default;//默认构造
	Queue(const Queue&) = delete;//禁止复制
	~Queue() {
		clear();
	};//析构
	void push(const T &val);//入列
	void pop();//出列
	void clear();//清空
	void show();//打印队列元素
	void exchange();//将存有数据的栈内元素逐个出栈给另一个空栈(传完后为倒序)
	bool empty()const {
		return (this->m_hold.m_top == nullptr) && (this->m_out.m_top == nullptr);
	}//判断是否为空
};

（1）入列函数

        在入列时，要先判断此时数据存储在哪个栈内，如果在m_out内则需先放入m_hold内，否则会出现乱序，然后直接调用Stack内的push()成员函数即可。

template<class T>
void Queue<T>::push(const T &val) {
	if (this->m_out.m_top == nullptr) {
		this->m_hold.push(val);
	}
	else {
		this->exchange();//如果此时数据存储在m_out栈则先将元素放回m_hold
		this->m_hold.push(val);
	}

}

（2）出列函数

        在出列时要将数据存入m_out内再对m_out出栈即可实现先进先出，原理及图示在上文已呈现，不再复述。

template<class T>
void Queue<T>::pop() {
	if (this->empty()) {
		return;
	}
	if (this->m_out.m_top == nullptr && this->m_hold.m_top != nullptr) {
		this->exchange();
		this->m_out.pop();
	}//如果此时数据存储在m_hold，则先将数据放入m_out，以便倒序实现先进先出
	else {
		this->m_out.pop();
	}
}

（3）清空函数

        简单粗暴，不为空直接out，Stack out！

template<class T>
void Queue<T>::clear() {
	if (this->m_hold.m_top != nullptr) {
		this->m_hold.clear();
	}
	if (this->m_out.m_top != nullptr) {
		this->m_out.clear();
	}
}//将两个栈都清空

（4）打印函数

        遍历并输出Stack里Node的数据域m_data。

template<class T>
void Queue<T>::show() {
	if (this->empty()) {
		return;
	}
	if (this->m_hold.m_top != nullptr) {
		this->exchange();
	}//将数据放在m_out内打印出来，这样的顺序为先进先打印
	Node<T>* p = this->m_out.m_top;
	while (p != nullptr) {
		cout << p->m_data << " ";
		p = p->m_next;
	}//遍历
	cout << endl;
}

（5）交换函数

        其实就是将一个栈的所有元素依次出栈然后入到另外一个栈。

//执行此函数时 if判断哪个为空就将另一个依次出栈然后入栈到为空的栈
template<class T>
void Queue<T>::exchange() {
	if (this->empty()) {
		return;
	}//都为空直接返回，换不了一点
	else if (this->m_out.m_top == nullptr && this->m_hold.m_top != nullptr) {
		Node<T>* p = nullptr;
		while (this->m_hold.m_top != nullptr) {
			p = this->m_hold.m_top;
			this->m_out.push(p->m_data);
			this->m_hold.m_top = this->m_hold.m_top->m_next;
			delete p;
		}//while遍历栈，直到栈底指针为空
	}
	else {
		Node<T>* p = nullptr;
		while (this->m_out.m_top != nullptr) {
			p = this->m_out.m_top;
			this->m_hold.push(p->m_data);
			this->m_out.m_top = this->m_out.m_top->m_next;
			delete p;
		}//while遍历栈，直到栈底指针为空

	}
}

（6）main函数

        其实就是测试，可以随意测，对于类对象应该也可以，不过前提是你要在类里重载<<运算符，或者在show( )函数里实例化此情况，否则必报错。

int main()
{
	Queue<int> q1;
	for (int i = 0; i < 10; i++) {
		q1.push(i);
	}
	q1.show();
	q1.pop();
	q1.show();
	q1.clear();
	for (int i = 5; i < 10; i++) {
		q1.push(i);
	}
	q1.show();
	Queue<string> q2;
	q2.push("first");
	q2.push("second");
	q2.push("third");
	q2.pop();
	q2.show();
}

三、完整代码

        以下是完整代码展示，由于个人水平有限，如有错误/不严谨的地方敬请指正。

#include <iostream>
#include <string>
using namespace std;
template<class T>class Stack;//向前声明
template<class T>class Queue;//向前声明
template<class T>
class Node {
private:
	T m_data;//数据域
	Node* m_next;//指针域
public:
	Node(const T& val) {
		this->m_data = val;
	}//有参构造
	Node& operator=(const Node& rhs) = delete;//禁止赋值
	friend class Stack<T>;//声明友元
	friend class Queue<T>;//同上
};

template<class T>
class Stack {
private:
	Node<T>* m_top = nullptr;//栈顶指针
public:
	Stack() = default;//默认构造
	Stack(const Stack&) = delete;//禁止复制
	Stack& operator=(const Stack&) = delete;//禁止赋值
	~Stack() {
		clear();
	};//析构
	void clear();//清空栈
	void push(const T& val);//入栈
	void pop();//出栈
	bool empty()const {
		return this->m_top == nullptr;
	}//判断是否为空
	const T& top() {
		return this->m_top->m_data;
	}//取出栈顶元素
	friend class Queue<T>;//声明友元
};

template<class T>
void Stack<T>::push(const T& val) {
	Node<T>* node = new Node<T>(val);
	node->m_next = this->m_top;
	this->m_top = node;
}

template<class T>
void Stack<T>::pop() {
	if (empty()) {
		return;
	}
	Node<T>* p = this->m_top;
	this->m_top = this->m_top->m_next;
	delete p;
}

template<class T>
void Stack<T>::clear() {
	Node<T>* p = nullptr;
	while (this->m_top != nullptr) {
		p = this->m_top;
		this->m_top = this->m_top->m_next;
		delete p;
	}
}

template<class T>
class Queue {
private:
	Stack<T> m_hold, m_out;//设置两个栈，hold用来完成入列操作(后进排在后面)，out用来出列(先进先出)
public:
	Queue() = default;//默认构造
	Queue(const Queue&) = delete;//禁止复制
	~Queue() {
		clear();
	};//析构
	void push(const T &val);//入列
	void pop();//出列
	void clear();//清空
	void show();//打印队列元素
	void exchange();//将存有数据的栈内元素逐个出栈给另一个空栈(传完后为倒序)
	bool empty()const {
		return (this->m_hold.m_top == nullptr) && (this->m_out.m_top == nullptr);
	}//判断是否为空
};

template<class T>
void Queue<T>::push(const T &val) {
	if (this->m_out.m_top == nullptr) {
		this->m_hold.push(val);
	}
	else {
		this->exchange();//如果此时数据存储在m_out栈则先将元素放回m_hold
		this->m_hold.push(val);
	}

}

template<class T>
void Queue<T>::pop() {
	if (this->empty()) {
		return;
	}
	if (this->m_out.m_top == nullptr && this->m_hold.m_top != nullptr) {
		this->exchange();
		this->m_out.pop();
	}//如果此时数据存储在m_hold，则先将数据放入m_out，以便倒序实现先进先出
	else {
		this->m_out.pop();
	}
}

template<class T>
void Queue<T>::clear() {
	if (this->m_hold.m_top != nullptr) {
		this->m_hold.clear();
	}
	if (this->m_out.m_top != nullptr) {
		this->m_out.clear();
	}
}//将两个栈都清空

template<class T>
void Queue<T>::show() {
	if (this->empty()) {
		return;
	}
	if (this->m_hold.m_top != nullptr) {
		this->exchange();
	}//将数据放在m_out内打印出来，这样的顺序为先进先打印
	Node<T>* p = this->m_out.m_top;
	while (p != nullptr) {
		cout << p->m_data << " ";
		p = p->m_next;
	}
	cout << endl;
}
//执行此函数时 if判断哪个为空就将另一个依次出栈然后入栈到为空的栈
template<class T>
void Queue<T>::exchange() {
	if (this->empty()) {
		return;
	}
	else if (this->m_out.m_top == nullptr && this->m_hold.m_top != nullptr) {
		Node<T>* p = nullptr;
		while (this->m_hold.m_top != nullptr) {
			p = this->m_hold.m_top;
			this->m_out.push(p->m_data);
			this->m_hold.m_top = this->m_hold.m_top->m_next;
			delete p;
		}//while遍历栈，直到栈底指针为空
	}
	else {
		Node<T>* p = nullptr;
		while (this->m_out.m_top != nullptr) {
			p = this->m_out.m_top;
			this->m_hold.push(p->m_data);
			this->m_out.m_top = this->m_out.m_top->m_next;
			delete p;
		}//while遍历栈，直到栈底指针为空

	}
}
int main()
{
	Queue<int> q1;
	for (int i = 0; i < 10; i++) {
		q1.push(i);
	}
	q1.show();
	q1.pop();
	q1.show();
	q1.clear();
	for (int i = 5; i < 10; i++) {
		q1.push(i);
	}
	q1.show();
	Queue<string> q2;
	q2.push("first");
	q2.push("second");
	q2.push("third");
	q2.pop();
	q2.show();
}

idokira
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++类模板实现的队列
12-21
用C++类模板实现的队列，通过此例子可以清楚理解类模板的使用和数据结构中队列的实现
C++双栈实现队列
CrazyRabbitttt
10-09 199
//A栈用来添加新的元素 B栈用来出队 //因为队列FIFO 栈FILO 因此将A中的翻转后存放到B中 //B栈（反转后出栈和出队要求相同）用来模拟出队 Stack<int>A,B; void appendTail(int value) //入队 { A.push(value); //入队在A栈中实现 } int deleteHead() { //出队，返回队首元素 //1：如果B栈是不为空的，那么栈顶元素就相当于队首...
c++模板队列类
wuuu21的博客
11-13 760
#include using namespace std; template class QueueNode{ public:         QueueNode*next;    T data;//类型为T的数据域     QueueNode(T& x,QueueNode *l=NULL){             data=x;             next=l;  
用C++模板类实现队列（含详细注释）
qq_45768060的博客
04-02 4206
队列是一种先进先出的数据结构：即插入在表的一端（队尾）进行，删除在表的另一端（队头）进行 与线性表相似，队列也有顺序储存和链式储存两种储存方法；本文运用C++模板类实现了简单队列
C++模板实现队列
randyjiawenjie的专栏
08-28 5023
我准备练习一下模板的知识，然后自己实现vector类。在这之前，先用模板实现一个队列来热身吧。队列的底层是链表。主要是熟悉一下模板的写法。 另外，就是模板的定义和实现都要写在一个文件中（export关键字可以避免这样。还没用过），所以倒数第二行我加了个# include "qu
C++ 循环队列和链式队列的实现 数据结构 类模板
02-04
1. Queue.hpp是队列的基类，只定义基本操作，具体实现在另外两个hpp文件中 2. seqQueue.hpp是循环队列的实现 3. linkQueue.hpp是链式队列的实现 4. test.cpp是简单的测试文件，main函数在这里面
C++利用链表模板类实现简易队列
08-26
在C++中，链表是一种常用的数据结构，链表模板类是指使用模板类来实现链表的结构体。链表模板类的优点是可以根据需要自定义数据类型，并且可以轻松地实现链表的操作。 知识点二：队列的实现 队列是一种先进先出的...
C++数据结构与算法之双缓存队列实现方法详解
08-29
双缓存队列的实现方法可以使用C++实现，通过使用模板类DoubleArray来实现双缓存队列。DoubleArray类中包含两个队列A和B，分别用来写入和读取数据。写入数据时，先将数据写入队列A，直到队列A满了，然后将写入请求...
《数据结构C++版》-顺序表实验-使用类模板的方式实现
10-24
用C++实现了数据结构中的顺序表，并且使用了面向对象知识中的类模板
数据结构C++版-二叉树实验-使用类模板的方式实现
11-27
一、实验目的：1、实现二叉树的存储结构（二叉链表或三叉链表等存储结构任选）2、熟悉二叉树基本术语的含义3、掌握使用栈和队列及递归思想完成二叉树相关操作的编程实现二、实验内容: 主要完成以下功能:1....
c++制作简单计算器
12-11
c++制作简单计算器
c++ 通过顺序表，链表实现队列操作,使用模板类
最新发布
s103424的博客
01-31 365
同时模板指针格式应为 mytemplate<elment>* ,mytemplate<elment>是一种格式，而不是。mytemplate*<elment>, 不存在数据类型mytemplate*，在创建指针时应指出变量类型所以应为。使用模板类不能在使用typedef，系统无法分配内存。
C++模板实现队列（2）
Alexon Xu的博客
05-29 1585
循环队列中添加和删除元素时并不像链式队列那样使用动态内存分配，一般采用固定的队列长度，一次分配一片内存用于存储数据，等到队列使用完毕后释放掉即可。内存使用效率比链式队列高，也比较容易实现。队列的数据定义如下： unsigned int size;//存储总的队列大小，最多可以存储size-1个数据 int head;//记录队头的下标 int rear;//记录队尾的下标...
C++实现双栈结构(一个顺序表中使用两个栈)
m0_51955470的博客
10-15 588
因为平常栈中push的数据不会太多，为了节约空间，所以可以在一个顺序表中使用两个栈 结构图: 在这里我会留一个空间用来判断栈是否满！ #include <iostream> using namespace std; typedef int ElemType; class DoubleStack { private: ElemType *top_1; ElemType *base_1; ElemType *top_2; ElemType *base_2; public: Do
c++队列类模板的实现
CodingAdo
07-11 7150
//队列类模板定义 template class VarQueue { public: VarQueue() { m_MaxCount=MAX_POINTS; m_Count=0; } VarQueue(unsigned int MaxCount) { if(MaxCount>MAX_POINTS) m_MaxCount=MAX_POINTS; el
C++ 队列（queue）的基本操作(使用模板类)
ChanJose的博客
01-11 5184
一、成员函数：      二、实现程序： #include &lt;iostream&gt; template&lt;class T&gt; struct Node { T data; Node *next; }; template&lt;class T&gt; class MyQueue { public: MyQueue(); // 构造函数 ~My...
队列类模板【C++模板类应用之一】
席木木的博客
12-04 2431
队列类模板1 队列（Queue）特点2 队列中常用的操作3 队列类模板的设计与代码实现3.1 队列类模板的设计3.2 队列类模板的实现3.3 队列类模板的使用举例 1 队列（Queue）特点     队列（Queue）是一种先进先出的数据结构，例如：日常生活中在食堂排队打饭，每个后到的人都要排到队伍的最后边，而队伍最前面的人最先打到饭离开队伍。     因此，队列总是从队尾加入元素，而从队首移除元素，满足先进先出的规则。一般来说
双栈（Dual Stack）c++实现
m0_62466789的博客
03-10 998
某程序需要两个栈s1、s2，但任何时候s1、s2存储的元素总数不超过2MAX，但某些时候s1或s2储存的元素个数会超过MAX。 对于双栈，可以采用同一个内存空间，通过首指针和尾指针分别作为两个栈的顶指针，从而实现双栈。 双栈最大的好处是内存利用率高，灵活性强。 但也有运算复杂、长度固定等缺点。 #include<iostream> using namespace std; template <class T> class DualStack { private: in
数据结构各种算法实现(C++模板)1
08-08
该资源是一份C++实现的数据结构与算法教程，涵盖了多种常见的数据结构和排序算法。它包括了顺序表、单链表、双向链表、循环链表、顺序栈、链式栈、顺序队列、链式队列、优先级队列、字符串、二叉树、线索二叉树、堆...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值