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

最新推荐文章于 2024-10-25 12:00:00 发布
最新推荐文章于 2024-10-25 12:00:00 发布
阅读量947 收藏 14
点赞数 19
文章标签： 数据结构 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80937868/article/details/138140890
版权
本文详细介绍了如何使用栈来实现队列，通过创建双栈结构，一个栈用于存储数据，另一个栈用于出列操作，实现了先进先出的队列特性。代码中包括节点类、栈类和队列类的实现，以及主要操作函数如入列、出列、清空和打印等。
摘要由CSDN通过智能技术生成

目录

前言：

一、用栈实现队列的方法

二、代码实现

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
关注
【C++】STL之适配器---用deque实现栈和队列
m0_63198468的博客
09-22 2576
本介绍了什么是适配器，deque，并且使用queue去实现了stack和queue，重点介绍了他们函数接口的使用，以及后面的stack和queue模拟实现。
C++代码Queue队列
01-13
C++作为一种强大的编程语言，提供了多种方式来实现队列，包括标准模板库（STL）中的`queue`容器以及自定义的数据结构。本篇文章将深入探讨C++中队列的实现及其应用。 首先，我们要了解C++标准库中的`<queue>`头文件...
用两个栈实现一个队列的功能
08-19
//用两个栈实现一个队列的功能 //栈s1提供入队列的功能，栈s2提供出队列的功能 //入队列：如s1 //出队列：(1)如果s2不为空，则直接弹出栈s2的数据(2)如果栈s2为空，则依次弹出栈s1的数据，放入s2中，再弹出栈s2的数据
【leetcode 简单】 第六十六题 用栈实现队列
weixin_30715523的博客
08-24 302
使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); ...
数据结构 ——— 用栈实现队列
最新发布
weixin_55341642的博客
10-25 306
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
剑指 Offer 09. 用两个栈实现队列
qq_33287871的博客
10-05 274
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例 1： 输入： [“CQueue”,“appendTail”,“deleteHead”,“deleteHead”] [[],[3],[],[]] 输出：[null,null,3,-1] 示例 2： 输入： [“CQueue”,“deleteHead”,“appendTail”,“ap
用两个栈实现队列 C++
YOONGI
06-24 213
题目描述 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 题目链接：https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&&tqId=11158&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking 代码： class So..
C++用栈的方式实现队列结构
qq_44857420的博客
12-08 426
使⽤栈实现队列的下列操作：push(x) – 将⼀个元素放⼊队列的尾部。pop() – 从队列⾸部移除元素。peek() – 返回队列⾸部的元素。empty() – 返回队列是否为空。
队列实现栈_栈_数据结构_队列_
09-30
同样，"232栈实现队列.cpp"文件可能是用栈来实现队列的逻辑，这种实现称为双栈队列。这里通常会用到两个栈，一个用于入队，一个用于出队，以保持队列的FIFO特性。 数据结构的选择取决于具体的问题需求。例如，栈常...
数据结构第三章：栈、队列与串的理论与实现
在C++中，我们可以使用模板类来创建一个通用的顺序栈，如下所示： ```cpp template class SeqStack { public: // 初始化栈 void InitStack(int stackSize) {...} // 销毁栈 void DestroyStack() {...} // 在...
清华殷人昆数据结构笔记(c++)4
09-02
在C++编程中，数据结构的实现对于优化程序性能至关重要。殷人昆的清华大学数据结构笔记第四部分主要讲解了三种基本的线性数据结构：栈、队列以及优先队列。 **栈（Stack）** 栈是一种后进先出（LIFO, Last In First...
C++实现用两个栈实现队列
weixin_30888707的博客
04-07 67
/* * 用两个栈实现队列.cpp * * Created on: 2018年4月7日 * Author: soyo */ #include<iostream> #include<stack> using namespace std; int main() { void MakeQueue(int a[],i...
剑指 Offer 09. 用两个栈实现队列（C++实现）
呋喃吖的博客
10-08 258
文章目录题目实现思路实现代码 题目 剑指 Offer 09. 用两个栈实现队列 实现思路 创建两个栈，A,B； appendTail函数，完成对A的入栈； deleteHead函数，完成用A的出栈元素对B的入栈，同时B再出栈； 其中deleteHead函数：对B入栈，前提B必须为空；当B不为空时候就出栈，出栈前也要判断B是否为空，空的话就返回-1； 实现代码 class CQueue { public: //设计一个栈A和一个栈B： //栈A用来入栈；栈B用栈A出栈，然后入栈B中，最后出栈；
C++模板的实现（模板函数和模板类，附带模板实现顺序表和链表代码）
龙跃十二
05-05 3360
模板 一、模板函数 模板函数的格式： 模板参数隐式实例化 模板参数显示实例化 二、模板类 模板类的格式 模板类示例 模板  当我们实现一个交换函数时，我们可以写成如下。 void Swap(int&amp; x, int&amp; y) { int tmp = x; x = y; y = tmp; }  这里只能交换两个整数...
利用双栈实现队列
qq_44754935的博客
10-12 150
定义两个数组对象视为两个栈 1.首先将s1的元素全部转移至s22.这时候s2的栈顶即为最先入队列的head元素 3.在s2栈空之前栈顶的元素始终为队列头4.如果在这之间有元素入队列，则全部暂存在s1 1.首先查看s1中是否含有元素2.如果有则将s1中的元素再次全部转移至s2，此时s2的栈顶仍为队列头3.如果s1、s2均为空，则返回-1 var CQueue = function() { this.stack1=[]; this.stack2=[]; }; /** * @para
用双栈实现队列
kcy的博客
08-17 542
一个栈的入栈操作当做入队操作，另外一个栈的出栈操作当做出队操作。因为入栈的顺序与出栈的顺序刚好相反，所以我们需要将当做入队的那个栈中所有的元素全部出栈到另外一个栈，并且在向另一个栈入栈的时候需要先判断其是不是空栈，否则会引起顺序混乱。...
双栈实现一个队列
qq_62636650的博客
07-10 310
设有含三个元素的栈 A = [1,2,3] 和空栈 B = []。若循环执行 A 元素出栈并添加入栈 B ，直到栈 A 为空，则 A = [] , B = [3,2,1] ，即栈 B 元素为栈 A 元素倒序。B：倒序后，B执行出栈则相当于删除了A的栈底元素，即对应队首元素。因此，可以设计栈A用于加入队尾操作，栈B用于将元素倒序，从而实现删除队首元素。
双栈实现队列
文王梦熊的博客
01-09 303
主要思想 有两个栈stack1和stack2， 在push时，直接压入stack1 在pop时，判断stack2是否为空，空则将stack1的数据压入stack2，不空则只需将stack2的栈顶弹出。 代码实现 #ifndef _MYQUEUE_H_ #define _MYQUEUE_H_ #include&lt;iostream&gt; #include&lt;stack&gt; usin...
C++自定义类模板：实现数据结构与算法应用
- mySTL.h：这个头文件可能是一个自制的STL（标准模板库）的实现，里面包含了一些基本的类模板和函数模板的定义，为其它文件提供数据结构和算法的支持。 通过上述知识点的整理，读者可以对C++中自定义类模板的编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值