Stack_Queue_OJ题

最新推荐文章于 2021-11-14 19:39:30 发布
最新推荐文章于 2021-11-14 19:39:30 发布
阅读量220 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BOXING666/article/details/85035275
版权

1.逆波兰表达式

#include <iostream>
#include <vector>
#include <string>
#include <stack>
using namespace std;
int evalRPN(vector<string>& tokens) {
	stack<int> num;
	for (size_t i = 0; i < tokens.size(); i++){
		string& str = tokens[i];
		if (!("+" == str || "-" == str || "*" == str || "/" == str)){
			num.push(atoi(str.c_str()));          //将数字入栈
		}
		else{
			int right = num.top();
			num.pop();
			int left = num.top();
			num.pop();
			switch (str[0])
			{
			case '+':
				num.push(left + right);
				break;
			case '-':
				num.push(left - right);
				break;
			case '*':
				num.push(left*right);
				break;
			case '/':
				num.push(left / right);
				break;
			}
		}
	}
	return num.top();
}
int main()
{
	vector<string> s; //["2", "1", "+", "3", "*"]
	s.push_back("2");
	s.push_back("1");
	s.push_back("+");
	s.push_back("3");
	s.push_back("*");
	cout << evalRPN(s) << endl;
	return 0;
}

2.前序遍历二叉树

#include <iostream>
#include <vector>
#include <string>
#include <stack>
using namespace std;
typedef struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}Tree;
//vector<int> preorderTraversal(TreeNode* root)
//{
//	vector<int> ret;
//	vector<int> tmp;
//	if (root == nullptr)
//		return ret;
//	ret.push_back(root->val);
//	tmp = preorderTraversal(root->left);
//	for (size_t i = 0; i < tmp.size(); i++){
//		ret.push_back(tmp[i]);
//	}
//	tmp = preorderTraversal(root->right);
//	for (size_t i = 0; i < tmp.size(); i++){
//		ret.push_back(tmp[i]);
//	}
//	return ret;
//}
vector<int> preorderTraversal(TreeNode* root) {
	vector<int> ret;
	stack<TreeNode*> node;
	if (root == nullptr){
		return ret;
	}
	TreeNode* cur = root;
	while (cur || !node.empty())
	{
		while (cur){
			node.push(cur);
			ret.push_back(cur->val);
			cur = cur->left;
		}
		cur = node.top()->right;
		node.pop();
	}
	return ret;
}
int main()
{
	Tree* root = new TreeNode(1);
	root->left = nullptr;
	root->right = new TreeNode(2);
	root->right->left = new TreeNode(3);
	vector<int> ret = preorderTraversal(root);
	for (auto x : ret){
		cout << x << " ";
	}
	return 0;
}

3.后续遍历二叉树

#include <iostream>
#include <vector>
#include <string>
#include <stack>
using namespace std;
typedef struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}Tree;
vector<int> postorderTraversal(TreeNode* root) {
	vector<int> ret;
	stack<TreeNode*> node;
	TreeNode* prev = nullptr;
	if (root == nullptr){
		return ret;
	}
	TreeNode* cur = root;
	while (cur || !node.empty()){
		while (cur){
			node.push(cur);
			cur = cur->left;
		}
		TreeNode* top = node.top();
		if (top->right == nullptr || top->right == prev)   //一旦右子树访问过了
		{
			ret.push_back(top->val);
			prev = top;
			node.pop();
		}
		else
		{
			cur = top->right;
		}
	}
	return ret;
}
int main()
{
	Tree* root = new TreeNode(1);
	root->left = nullptr;
	root->right = new TreeNode(2);
	//root->right->left = new TreeNode(3);
	vector<int> ret = postorderTraversal(root);
	for (auto x : ret){
		cout << x << " ";
	}
	return 0;
}

4.层序遍历二叉树，倒序输出

#include <iostream>
#include <vector>
#include <string>
#include <queue>
using namespace std;
typedef struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}Tree;

vector<vector<int>> levelOrder(TreeNode* root) {
	vector<vector<int>> vv;
	queue<TreeNode*> q;
	if (root == nullptr)
		return vv;
	q.push(root);
	while (!q.empty()){
		int sz = q.size();      //sz为每层结点的个数
		vector<int> v;
		while (sz--){
			TreeNode* top = q.front();
			v.push_back(top->val);
			q.pop();
			if (top->left)
				q.push(top->left);
			if (top->right)
				q.push(top->right);
		}
		vv.push_back(v);
	}
	for (int i = 0; i<vv.size() / 2; i++){     //交换元素，把最底层的元素放在第一层
		swap(vv[i], vv[vv.size() - 1 - i]);
	}
	return vv;
}

5.层序遍历N叉数

#include <iostream>
#include <vector>
#include <string>
#include <queue>
using namespace std;
class Node {
public:
	int val = NULL;
	vector<Node*> children;
	Node() {}
	Node(int _val, vector<Node*> _children) {
		val = _val;
		children = _children;
	}
};

vector<vector<int>> levelOrder(Node* root) {
	vector<vector<int>> vv;
	if (root == nullptr){
		return vv;
	}
	queue<Node*> q;
	q.push(root);
	while (!q.empty()){
		int sz = q.size();
		vector<int> v;
		while (sz--){
			Node* top = q.front();
			v.push_back(top->val);
			q.pop();
			if (!top->children.empty()){
				for (int i = 0; i<top->children.size(); i++){      //遍历Node里边的children
					q.push(top->children[i]);
				}
			}
		}
		vv.push_back(v);
	}
	return vv;
}

6.二叉树最近的公共祖先节点

#include <iostream>
#include <vector>
#include <string>
#include <stack>
using namespace std;
typedef struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}Tree;


bool FindNode(TreeNode* root, TreeNode* node)    //在以root为根的树中找node
{
	if (root == nullptr){
		return false;
	}
	if (root == node){
		return true;
	}
	return FindNode(root->left, node) || FindNode(root->right, node);
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
{
	if (root == nullptr){
		return root;
	}
	if (root == p || root == q)
		return root;
	bool lp = FindNode(root->left, p);      //在左右子树中分别找p,q
	bool lq = FindNode(root->left, q);
	bool rp = FindNode(root->right, p);
	bool rq = FindNode(root->right, q);
	if (lp && lq)            //若都在左子树，那在左子树中继续找
		return lowestCommonAncestor(root->left, p, q);
	if (rp && rq)            //若都在右子树，那在右子树中继续找
		return lowestCommonAncestor(root->right, p, q);
	if ((lp&&rq) || (rp&&lq))
		return root;
	else
		return nullptr;
}

7.移除数组中指定的元素

#include <iostream>
#include <vector>
using namespace std;

//1.遍历数组，直到找到要删的元素
//2.从该元素的后边找到别的元素，交换
//3.当j遍历完的时候，就结束了
//4.再遍历到要删的元素，截断
int removeElement(vector<int>& nums, int val) {
	size_t sz = nums.size();
	size_t i, j;
	for ( i = 0; i<sz; i++){
		if (val == nums[i]){              
			for (j = i + 1; j<sz; j++){
				if (nums[j] != nums[i]){
					swap(nums[i], nums[j]);
					break;
				}
			}
		}
		if (j == sz){
			break;
		}
	}
	for (i = 0; i<sz; i++)
	{
		if (nums[i] == val){
			nums.resize(i);
			break;
		}
	}
	return i;
}

int main()
{
	vector<int> nums;
	nums.push_back(3);
	nums.push_back(2);
	nums.push_back(2);
	nums.push_back(3);
	cout << removeElement(nums, 3);
}

8.两个栈实现一个队列

#include <iostream>
#include <stack>
using namespace std;
template<class T>
class Queue
{
private:
	stack<T> s1;
	stack<T> s2;
public:
	void Push(T data)     //将数据压入栈1
	{
		s1.push(data);
	}
	void Pop()
	{
		if (s1.empty() && s2.empty())
			cout << "无元素！" << endl;
		if (!s2.empty())              //从栈2出
		{
			s2.pop();
		}
		else
		{
			while (!s1.empty()){
				s2.push(s1.top());
				s1.pop();
			}
			s2.pop();
		}
	}
	T& top()
	{
		if (s1.empty() && s2.empty())
			return nullptr;
		if (s2.empty()){
			while (!s1.empty()){
				s2.push(s1.top());
				s1.pop();
			}
		}
		return s2.top();
	}
	bool Empty()
	{
		if (s1.empty() && s2.empty())
			return true;
		else
			return false;
	}
	void Print()
	{
		if (s1.empty() && s2.empty())
		{
			cout << "无元素！" << endl;
			return;
		}
		if (s2.empty())
		{
			while (!s1.empty()){
				s2.push(s1.top());
				s1.pop();
			}
		}
		if (!s2.empty())
		{
			while (!s2.empty()){
				cout << s2.top() << endl;
				s2.pop();
			}
			if (!s1.empty())
			{
				while (!s1.empty())
				{
					s2.push(s1.top());
					s1.pop();
				}
				while (!s2.empty())
				{
					cout << s2.top() << endl;
					s2.pop();
				}
			}
		}
	}
};

int main()
{
	Queue<int> q1;
	q1.Push(1);
	q1.Push(2);
	q1.Push(3);
	q1.Pop();
	q1.Pop();
	q1.Push(4);
	q1.Print();
	return 0;
}

9.两个队列实现一个栈

#include <iostream>
#include <vector>
#include <string>
#include <queue>
using namespace std;
class MyStack {
	queue<int> q1;
	queue<int> q2;
public:
	void push(int x) {
		if (!q2.empty()){
			q2.push(x);
			return;
		}
		q1.push(x);
	}

	/** Removes the element on top of the stack and returns that element. */
	int pop() {                     //始终保持一个队列为空
		if (!q1.empty()){
			int sz = q1.size();
			for (size_t i = 0; i < sz - 1; i++){
				q2.push(q1.front());
				q1.pop();
			}
			int ret = q1.front();
			q1.pop();
			return ret;
		}
		if (!q2.empty()){
			int sz = q2.size();
			for (size_t i = 0; i < sz - 1; i++){
				q1.push(q2.front());
				q2.pop();
			}
			int ret = q2.front();
			q2.pop();
			return ret;
		}
		else
			return NULL;
	}

	/** Get the top element. */
	int top() {
		if (!q1.empty()){
			int sz = q1.size();
			for (size_t i = 0; i < sz - 1; i++){
				q2.push(q1.front());
				q1.pop();
			}
			int ret = q1.front();
			q2.push(ret);
			q1.pop();
			return ret;
		}
		if (!q2.empty()){
			int sz = q2.size();
			for (size_t i = 0; i < sz - 1; i++){
				q1.push(q2.front());
				q2.pop();
			}
			int ret = q2.front();
			q1.push(ret);
			q1.pop();
			return ret;
		}
		else
			return NULL;
	}

	/** Returns whether the stack is empty. */
	bool empty() {
		if (q1.empty() && q2.empty())
			return true;
		return false;
	}
};

int main()
{
	MyStack m;
	m.push(1);
	m.push(2);
	m.push(3);
	cout << m.top() << endl;
	return 0;
}

10.最小栈

#include <iostream>
#include <stack>
#include <assert.h>
#include <vector>
using namespace std;

class minStack
{
private:
	stack<int> _cur;
	stack<int> _min;
	vector<int> _arr;
public:
	void Push(int x)
	{
		_cur.push(x);
		if (_min.empty())
		{
			_min.push(x);
			_arr.push_back(1);
			return;
		}
		if (x < _min.top())
		{
			_min.push(x);
			_arr.push_back(1);
			return;
		}
		if (x == _min.top())
		{
			_arr[_arr.size() - 1]++;
		}
	}
	void Pop()
	{
		assert(!_cur.empty());
		if (_cur.top() == _min.top())
		{
			if (_arr[_arr.size() - 1] == 1)
			{
				_cur.pop();
				_min.pop();
			}
			else
			{
				_cur.pop();
				_arr[_arr.size() - 1]--;
			}
		}
		else
		{
			_cur.pop();
		}
	}
	int Top()
	{
		return _cur.top();
	}
	int GetMin()
	{
		return _min.top();
	}
};

int main()
{
	minStack min;
	min.Push(1);
	min.Push(8);
	min.Push(0);
	min.Push(0);
	min.Push(0);
	min.Push(3);
	min.Pop();
	min.Pop();
	min.Pop();
	min.Pop();
	cout << min.Top() <<endl;
	cout << min.GetMin() << endl;
	return 0;
}

 

博兴666
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OJ：STL之queue
GuoMengKai
03-01 234
#include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;queue&amp;amp;gt; using namespace std; int main() { queue&amp;amp;lt;int&amp;amp;gt; q; cout &amp;amp;lt;&amp;amp;lt; q.empty() &amp;amp;lt;&amp;amp;lt;
数据结构及算法基础--链表实现stack,queue(java)
weixin_34362875的博客
09-21 63
首先，链表是物理储存单元上非连续，非顺序的储存结构，数据元素是通过链表中的指针（在java中为应用，即Reference）链接次序实现的。链表有一系列结点（链表中每个元素称为结点）组成，每个结点包括储存数据的数据域和只想下一个结点的指针域。 那么为什么教授推荐我们使用链表表示呢，主要在于一下几个原因： 链表可以克服需要预先知道数据大小的缺点。（当然，我所设计的stack和queue的array...
算法_stack_queue
weixin_44208324的博客
02-22 103
栈，stack S.top(): 取出栈顶 S.empty(): 判断栈是否为空 S.push(x): 将x添加至栈 S.pop(): 弹出栈顶 S. size(): 栈的存储元素个数 #include<stack> #include<stdio.h> int main() { std::stack<int> S; if (S.empty()) { pr...
(Java)数据结构之队列(Queue)，含有三个OJ题（用队列实现栈，用栈实现队列，实现一个最小栈）
X_H学Java的博客
11-14 1396
1. 队列的概念 队列只允许在一端进行插入操作，在另一端进行删除操作的特殊线性表，队列具有先进先出（FIFO）的特性，进行插入操作的一端为队尾，进行删除操作的一端为队头。 2. 队列的使用 在Java中，Queue是一个接口，底层是通过链表来实现的 方法 功能说明 boolean offer(E e) 入队列 E poll() 出队列 E peek() 获取对头元素 int size() 获取队列中有效元素的个数 boolean is...
算法: 用队列Queue实现栈Stack
AI架构师易筋
08-02 370
题目 Implement Stack using Queues Implement the following operations of a stack using queues. push(x) – Push element x onto stack. pop() – Removes the element on top of the stack. top() – Get the top element. empty() – Return whether the stack is empty. Exa
Stack_Queue_Stack_
10-02
Data structure: Stack->Queue Example
stack_queue
02-26
stack_queue
Stack_Queue_Stack_源码.zip
10-25
Stack_Queue_Stack_源码
stack_and_queue.cpp
最新发布
06-13
stack_and_queue.cpp
link_stack_queue.rar_C 链表_C++链表_链表
09-22
实现栈，队列，链表的简单操作，其中链表包括单链表，双链表，循环链表。
oj教程--队列
weixin_30729609的博客
12-21 215
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 转载于:https://www.cnblogs.com/daxiang2008/p/10155925.html...
[C++系列] 60. queue介绍使用及相关OJ
Y-puyu 的博客
12-07 381
1. queue的介绍和使用 1.1 queue的介绍 1.队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。 2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。 3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层...
数据结构与算法(4) -- list、queue以及stack
dnhua的博客
12-12 386
今天主要给大家介绍几种数据结构，这几种数据结构在实现原理上较为类似，我习惯称之为类list的容器。具体有list、stack以及queue。 list的节点Node 首先介绍下node，也就是组成list的节点。从面向对象的角度来说节点也是就一个类，list里面包含了node对象的实例，以及操作/管理这些实例的方法。先给出一个粗糙的node的C++代码如下代码块所示。可以看出除了保有当前节点的...
队列（Queue）
你的你的都是你的的博客
10-30 526
#include #include #include #include #include #include #include #include #include #include #include #include using namespace std; #define TRUE         1 #define FALSE    
ACM/ICPC竞赛之STL--queue
逐梦者
06-25 2686
ACM模版stack（栈）和queue（队列）是在程序设计中经常会用到的数据容器，STL为我们提供了方便的stack（栈）和queue（队列）的实现。准确的说，STL中的stack和queue不同于vector、list等容器，而是对这些容器进行了重新的包装。这里我们不去深入讨论STL的stack和queue的实现细节，而是来了解一些他们的基本使用。queuequeue模版类的定义在<queue>头
Queue 实现代码
du771278794的博客
03-31 715
package ch03; /** * 队列实现底层代码 * 队列的特性是先进先出 * 用front来标记需要被移除的时候数组下标 * 删除的时候 * 队列没有数据 不再删除 * 如果队列扔有数据 * 当队头没有达到临界值得时候 正常通过 front++ 来进行删除 * 当队头达到了临界值 需要先通过front拿出数据 然后对front进行格式化操作 再进...
java中queue的使用
Beyond_the_Limits的专栏
06-04 762
[size=medium]java中queue的使用 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的...
c++stl之queue（队列）oj题目练习
zhoucheng_123的博客
01-14 2707
nefu 1632 周末舞会-队列 熟悉语法题，不难 #include <bits/stdc++.h> using namespace std; int main() { int m,n,k; cin>>n>>m>>k; queue<int>q1,q2; for(int i=1;i<=n;i++)...
Java中Stack和Queue的常用方法汇总
肉丸不肉
03-13 2138
一、Stack常用方法 Stack stack = new Stack<>(); boolean empty() 测试堆栈是否为空。 E peek() 查看堆栈顶部的对象，但不从堆栈中移除它。 E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。 E push(E item) ...
stack queue deque priority_queue
08-13
栈（Stack）、队列（Queue）、双端队列（Deque）和优先队列（Priority Queue）是常见的数据结构。 栈（Stack）是一种后进先出（LIFO）的数据结构，类似于我们叠放书籍的方式。元素只能在栈顶进行插入和删除操作。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值