【栈，队列】两栈实现队列

最新推荐文章于 2022-09-13 19:31:04 发布
最新推荐文章于 2022-09-13 19:31:04 发布
阅读量303 收藏
点赞数
分类专栏： 数据结构&算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruan875417/article/details/49848721
版权

一、用STL中的stack实现

MyQueue.h

#ifndef MYQUEUE_H
#define MYQUEUE_h

#include<iostream>
#include<stack>
//MyQueue
template<typename T>
class MyQueue{
public:
	typedef T value_type;
	typedef T& reference;
	MyQueue();//constructor
	~MyQueue();//destructor
	void push(const T value);//push
	void pop();//pop
	reference get_front();//front
	reference get_back();//back
	bool empty();//whether MyQueue is empty or not
	int size();//get length
private:
	std::stack<T> stack1;
	std::stack<T> stack2;
};
//constructor
template<typename T>
MyQueue<T>::MyQueue(){}
//destructor
template<typename T>
MyQueue<T>::~MyQueue(){}
//push
template<typename T>
void MyQueue<T>::push(const T value){
	stack1.push(value);
}
//pop
template<typename T>
void MyQueue<T>::pop(){
	if (stack2.size() == 0){
		while (stack1.size() > 0){
			value_type data = stack1.top();
			stack2.push(data);
			stack1.pop();
		}
	}
	if (stack2.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	stack2.pop();
}
//front
template<typename T>
typename MyQueue<T>::reference MyQueue<T>::get_front(){
	if (stack2.size() <= 0){
		while (stack1.size() > 0){
			value_type data = stack1.top();
			stack2.push(data);
			stack1.pop();
		}
	}
	if (stack2.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return stack2.top();
}
//back
template<typename T>
typename MyQueue<T>::reference MyQueue<T>::get_back(){
	if (stack1.size() <= 0){
		while (stack2.size() > 0){
			value_type data = stack2.top();
			stack1.push(data);
			stack2.pop();
		}
	}
	if (stack1.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return stack1.top();
}
//whether MyQueue is empty or not
template<typename T>
bool MyQueue<T>::empty(){
	return size() == 0 ? true : false;
}
//get length
template<typename T>
int MyQueue<T>::size(){
	return stack1.size() + stack2.size();
}

#endif
main.cpp 
#include"MyQueue.h"
using namespace std;

int main(){
	MyQueue<int> int_queue;
	cout << int_queue.size() << endl; //0
	cout << boolalpha << int_queue.empty() << endl;//true

	for (int i = 1; i < 10; i++){
		int_queue.push(i);
	}

	cout << int_queue.size() << endl; //9
	cout << int_queue.get_front() << endl;//1
	cout << int_queue.get_back() << endl;//9
	cout << boolalpha << int_queue.empty() << endl;//false

	int_queue.pop();
	int_queue.pop();
	int_queue.pop();
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//9

	int_queue.push(10);
	int_queue.push(11);
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//11

	int_queue.push(12);
	int_queue.push(13);
	int_queue.push(14);
	cout << int_queue.size() << endl; //11
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//14

	return 0;
}
二、用自己写的LinkedStack实现

LinkedStack.h

#ifndef LINKEDSTACK_H
#define LINKEDSTACK_H

#include<iostream>
//Stack node
template<typename T>
struct stack_node{
	typedef stack_node<T>* pointer;
	T data;
	pointer next;
	stack_node() :next(NULL){}
	stack_node(const T value) :data(value), next(NULL){}
};
// LinkedStack
template<typename T>
class LinkedStack{
public:
	typedef T value_type;
	typedef T* pointer;
	typedef value_type& reference;
	typedef stack_node<T>* link_type;
	LinkedStack();//constructor
	~LinkedStack();//destructor
	void push(const T value);//push
	void pop();//pop
	reference get_top();//top
	bool empty();//whether LinkedStack is empty or not
	int size();//get length
private:
	void clear();//clear LinkedStack
private:
	link_type top;
};
//constructor
template<typename T>
LinkedStack<T>::LinkedStack() :top(NULL){}
//destructor
template<typename T>
LinkedStack<T>::~LinkedStack(){
	clear();
}
//push
template<typename T>
void LinkedStack<T>::push(const T value){
	link_type p = new stack_node<T>(value);
	p->next = top;
	top = p;
}
//pop
template<typename T>
void LinkedStack<T>::pop(){
	if (empty()){
		std::cout << "there is no element in stack" << std::endl;
		exit(1);
	}
	link_type p = top;
	top = top->next;
	delete p;
}
//top
template<typename T>
typename LinkedStack<T>::reference LinkedStack<T>::get_top(){
	if (empty()){
		std::cout << "there is no element in stack" << std::endl;
		exit(1);
	}
	return top->data;
}
//whether stack is empty or not
template<typename T>
bool LinkedStack<T>::empty(){
	return top == NULL ? true : false;
}
//get length
template<typename T>
int LinkedStack<T>::size(){
	int count = 0;
	link_type p = top;
	while (p != NULL){
		p = p->next;
		count++;
	}
	return count;
}
//clear LinkedStack
template<typename T>
void LinkedStack<T>::clear(){
	link_type p;
	while (top != NULL){
		p = top;
		top = top->next;
		delete p;
	}
}

#endif
MyQueue.h 

#ifndef MYQUEUE_H
#define MYQUEUE_h

#include"LinkedStack.h"
#include<iostream>
//MyQueue
template<typename T>
class MyQueue{
public:
	typedef T value_type;
	typedef T& reference;
	MyQueue();//constructor
	~MyQueue();//destructor
	void push(const T value);//push
	void pop();//pop
	reference get_front();//front
	reference get_back();//back
	bool empty();//whether MyQueue is empty or not
	int size();//get length
private:
	LinkedStack<T> stack1;
	LinkedStack<T> stack2;
};
//constructor
template<typename T>
MyQueue<T>::MyQueue(){}
//destructor
template<typename T>
MyQueue<T>::~MyQueue(){}
//push
template<typename T>
void MyQueue<T>::push(const T value){
	stack1.push(value);
}
//pop
template<typename T>
void MyQueue<T>::pop(){
	if (stack2.size() == 0){
		while (stack1.size() > 0){
			value_type data = stack1.get_top();
			stack2.push(data);
			stack1.pop();
		}
	}
	if (stack2.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	stack2.pop();
}
//front
template<typename T>
typename MyQueue<T>::reference MyQueue<T>::get_front(){
	if (stack2.size() == 0){
		while (stack1.size() > 0){
			value_type data = stack1.get_top();
			stack2.push(data);
			stack1.pop();
		}
	}
	if (stack2.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return stack2.get_top();
}
//back
template<typename T>
typename MyQueue<T>::reference MyQueue<T>::get_back(){
	if (stack1.size() == 0){
		while (stack2.size() > 0){
			value_type data = stack2.get_top();
			stack1.push(data);
			stack2.pop();
		}
	}
	if (stack1.size() == 0){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return stack1.get_top();
}
//whether MyQueue is empty or not
template<typename T>
bool MyQueue<T>::empty(){
	return size() == 0 ? true : false;
}
//get length
template<typename T>
int MyQueue<T>::size(){
	return stack1.size() + stack2.size();
}

#endif
main.cpp 

#include"MyQueue.h"
using namespace std;

int main(){
	MyQueue<int> int_queue;
	cout << int_queue.size() << endl; //0
	cout << boolalpha << int_queue.empty() << endl;//true

	for (int i = 1; i < 10; i++){
		int_queue.push(i);
	}

	cout << int_queue.size() << endl; //9
	cout << int_queue.get_front() << endl;//1
	cout << int_queue.get_back() << endl;//9
	cout << boolalpha << int_queue.empty() << endl;//false

	int_queue.pop();
	int_queue.pop();
	int_queue.pop();
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//9

	int_queue.push(10);
	int_queue.push(11);
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//11

	int_queue.push(12);
	int_queue.push(13);
	int_queue.push(14);
	cout << int_queue.size() << endl; //11
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//14

	return 0;
}

ruan875417
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C++中用两栈实现一个队列
浮生流年的博客
03-08 129
第二种方法较好！ class MyQueue { public: // 出队 void pop() { // 第一种： // 1、先把 s1 留一个元素， 其他导入到 s2 中 // 2、s1 出栈 // 3、将 s2 元素再导入到 s1 中 // 第二种 // 1、先判...
两个栈实现一个队列
ailunlee的博客
12-19 5万+
用栈实现队列 1、栈的特点 栈的特点是先进后出，进出元素都是在同一端（栈顶）。 入栈： 出栈： 2、队列的特点 队列的特点是先进先出，出入元素是在不同的两端（队头和队尾）。 入队： 出队： 3、两个栈实现队列 我们拥有两个栈，可以让其中一个栈作为队列的入口，负责插入新元素；另一个栈作为队列的出口，负责移除老的元素。 队列的主要操作无非有两个：入队和出队。在...
用两个队列实现栈
jiaomubai的博客
10-04 2007
首先，明白了栈和队列的特点之后，就发现用队列来实现栈和用栈来实现队列的思想差不多是一样的。队列的特点是先进先出，栈的特点是先进先出，用队列来实现栈，即使用队列来完成先进后出的操作。 和用栈实现队列一样，我们假设需要操作的数据为A、B、C、D、E。有两个队列queue1和queue2，和用栈实现队列不同的是，此两个队列没有严格的插入和删除之分，栈实现队列时，我们使用主栈来压栈，辅助栈来弹栈。首先我...
用两个栈实现队列
qq_45793102的博客
06-15 2059
1、题目描述 用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。 队列中的 元素为 int 类型。 2、题目分析 由于队列是先进先出的，而栈是先进后出的，故可以用2个栈实现队列的入、出队功能，队列的入队功能与栈的一样，出队时，先将第一个栈中的元素全部弹出，并倒入到第二个栈中，将第二个栈中栈顶元素弹出，并将stack2中剩下的元素倒回到stack1中，即实现一次出队。 3、代码 4、运行结果 ...
两个栈模拟实现队列
Oliver King 的小窝
09-13 1595
两个栈模拟实现队列
两个队列实现一个栈
高老板爱吃橙子和橙子的博客
05-15 2809
两个栈实现一个队列1.主要思想2.结构设计3.基本操作（1）初始化（2）入栈（3）获取栈顶第一个元素的值，但不删除（4）获取栈顶第一个元素的值并删除（5）判空（6）判满（7）获取队列有效元素个数（8）清空（9）销毁4.完整代码 1.主要思想 栈的特点：先进后出。队列的特点：先进先出。 我们在用两个队列实现栈的时候是用顺序队列。 2.结构设计 既然是用两个队列实现栈的操作，所以定义的结构体中的成员就是两个队列。 typedef struct { SqQueue q1; SqQueue q2; }TQSt
栈实现队列(队列实现栈)
weixin_55742319的博客
01-14 3000
数据结构与算法应用(栈与队列互相实现)
用栈实现队列和用队列实现栈
SmileTimLi的博客
02-23 1762
第一 队列和栈的了解 栈 -- 先进后出(FILO—First-In/Last-Out) 队列 -- 先进先出(FIFO—first in first out) 对应的方法 栈 入栈：s.push(x) 出栈：s.pop() 访问栈顶：s.top() 判断栈空：s.empty() 访问栈中的元素个数：s.size() 队列  入队：q.push(x) 出队：q.pop(...
C++用两个栈实现队列
暮日落流年的博客
05-06 1342
1. 基础 队列：先进先出，即插入数据在队尾进行，删除数据在队头进行； 栈：后进先出，即插入与删除数据均在栈顶进行。 2. 思路 两个栈实现一个队列的思想：用pushStack栈作为push数据的栈，用popStack栈作为pop数据的栈。 只要是对队列进行push操作，就将数据push入pushStack栈中。 要实现队列的pop操作，有二点原则，如果popStack为空的话那...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 20万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
如何使用JavaScript实现栈与队列
10-16
主要介绍了如何使用JavaScript实现栈与队列。栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。,需要的朋友可以参考下
解析如何用两个栈来实现队列的方法
09-05
本篇文章是对如何用两个栈实现队列的方法进行了详细的分析介绍，需要的朋友参考下
Queue_栈队列_pop_
09-30
任务描述栈和队列都提供 Push/Pop 两种操作，其中 Push：加入一个元素。Pop：弹出一个元素。给出一个线性结构的进出顺序，判定这个结构是栈还是队列。(40’) 输入描述第一行输入一个整数s，代表有s组测试数据。第一...
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
【排序】归并排序（递归和非递归版本）
ruan875417的专栏
05-14 2394
#include using namespace std; void merge(int* a, int* temp, int begin, int middle, int end){ int i = begin; int j = middle + 1; int k = 0; while (i <= middle&&j <= end){//比较两个指针所指向的元素，选择相对小的元素放入到
【图】最短路径Dijkstra算法和Floyd算法
ruan875417的专栏
03-30 779
一、Dijkstra算法 #include using namespace std; const int maxint = 10000; class Dij{ public: void initial(int m, int n); void read_case(); void dijkstra(int begin, int end); void search_path(int begi
【树】已知二叉树前序和中序遍历求后序遍历，及中序和后序遍历求前序遍历
ruan875417的专栏
01-11 744
#include using namespace std; //已知二叉树前序遍历和中序遍历，求后序遍历 void binary_tree_postorder(char* preorder,char* inorder,int length){ if (length == 0) return; char root = *preorder; int index = 0; for (; in
【String】引用计数实现String
ruan875417的专栏
11-29 714
String.h #ifndef STRING_H #define STRING_H #define _CRT_SECURE_NO_WARNINGS #include //String class String{ public: String(const char* str = NULL);//constructor String(const String& rhs);//copy cons
如何用两个栈实现队列
最新发布
08-18
下面是使用两个栈实现队列的步骤： 1. 入队操作（enqueue）： - 将元素依次压入入队栈（Stack A）。 2. 出队操作（dequeue）： - 如果出队栈（Stack B）为空，将入队栈中的元素逐个弹出并压入出队栈，直到入队栈...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值