队列和栈的相关算法题

最新推荐文章于 2023-02-26 10:48:27 发布
最新推荐文章于 2023-02-26 10:48:27 发布
阅读量310 收藏 1
点赞数
分类专栏： 解题模板 LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiao2018428/article/details/105587999
版权

LeetCode20——有效的括号

题目：

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true
示例 2:

输入: "()[]{}"
输出: true
示例 3:

输入: "(]"
输出: false
示例 4:

输入: "([)]"
输出: false
示例 5:

输入: "{[]}"
输出: true

思路：

用栈的存储括号，左右同种类型的括号相匹配才可以顺利出栈，注意判断栈的容量为空，以及首字符为 右括号的情况。

代码：

class Solution {
public:
	bool isValid(string s) {
		stack<char>t;
		for (int i = 0; i < s.length(); i++)
		{
			if (s[i] == '(' || s[i] == '[' || s[i] == '{')
				t.push(s[i]);
			else if (s[i] == ')')
			{
				if (i == 0 || t.size() == 0 || t.top() != '(')
					return false;
				else
					t.pop();
			}
			else if (s[i] == ']')
			{
				if (i == 0 || t.size() == 0 || t.top() != '[')
					return false;
				else
					t.pop();
			}
			else if(s[i]=='}')
			{
				if (i == 0 || t.size() == 0 || t.top() != '{')
					return false;
				else
					t.pop();
			}
		}
		return t.empty();

	}
};

LeetCode150——逆波兰表达式

题目：

根据逆波兰表示法，求表达式的值。

有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入: ["2", "1", "+", "3", "*"]
输出: 9
解释: ((2 + 1) * 3) = 9
示例 2：

输入: ["4", "13", "5", "/", "+"]
输出: 6
解释: (4 + (13 / 5)) = 6
示例 3：

输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
输出: 22
解释: 
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

思路：

读入数字的时候放入栈中，遇到运算符号就取出栈顶的前两个元素进行运算。两个非常好用的函数 string转int -> stoi(s,0,10),以及int转整型 to_string。

代码：

class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		int len = tokens.size();
		if (len == 0) return 0;
		stack<string>st;
		for (int i = 0; i < len; i++)
		{
			if (tokens[i] != "+" &&tokens[i] != "-"&&tokens[i] != "/"&& tokens[i] != "*")
			{
				st.push(tokens[i]);
			}
 			else if (tokens[i] == "+")
			{
				string num1 = st.top();
				st.pop();
				string num2 = st.top();
				st.pop();//string 字符串转数字，stoi(s,p,b)	把字符串s从p开始转换成b进制的int
				int n1 = stoi(num1, 0, 10);
				int n2 = stoi(num2, 0, 10);
				int result = n2 + n1;
				string res = to_string(result);
				st.push(res);
			}
			else if (tokens[i] == "-")
			{
				string num1 = st.top();
				st.pop();
				string num2 = st.top();
				st.pop();//string 字符串转数字，stoi(s,p,b)	把字符串s从p开始转换成b进制的int
				int n1 = stoi(num1, 0, 10);
				int n2 = stoi(num2, 0, 10);
				int result = n2 - n1;
				string res = to_string(result);
				st.push(res);
			}
			else if (tokens[i] == "*")
			{
				string num1 = st.top();
				st.pop();
				string num2 = st.top();
				st.pop();//string 字符串转数字，stoi(s,p,b)	把字符串s从p开始转换成b进制的int
				int n1 = stoi(num1, 0, 10);
				int n2 = stoi(num2, 0, 10);
				int result = n2 * n1;
				string res = to_string(result);
				st.push(res);
			}
			else 
			{
				string num1 = st.top();
				st.pop();
				string num2 = st.top();
				st.pop();//string 字符串转数字，stoi(s,p,b)	把字符串s从p开始转换成b进制的int
				int n1 = stoi(num1, 0, 10);
				int n2 = stoi(num2, 0, 10);
				int result = n2/n1;
				string res = to_string(result);
				st.push(res);
			}
			
		}
		return stoi(st.top());
	}
};

LeetCode145——二叉树先序遍历的非递归实现：https://www.cnblogs.com/kangna/p/11846156.html

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		stack<TreeNode*>st;
		vector<int>ans;
		if (root == nullptr)
			return ans;
		st.push(root);
		while (!st.empty())
		{
			TreeNode* temp = st.top();
			st.pop();
			ans.push_back(temp->val);
			if (temp->right != nullptr)
				st.push(temp->right);
			if (temp->left != nullptr)
				st.push(temp->left);
		}
		return ans;
	}
};

 

LeetCode146——二叉树中序遍历的非递归实现：https://www.cnblogs.com/kangna/p/11846156.html

class Solution {
 public:
	 vector<int> inorderTraversal(TreeNode* root) {
		 stack<TreeNode*>st;
		 vector<int>ans;
		 if (root == nullptr)
			 return ans;
		 TreeNode* p = root;
		 while (!st.empty()||p)//注意这个条件“||”
		 {
			 if (p)
			 {
				 st.push(p);
				 p = p->left;
			 }
			 else
			 {
				 
				 TreeNode* temp = st.top();
				 ans.push_back(temp->val);
				 st.pop();
				 p = temp->right;

			 }
		 }
		 return ans;
	 }
 };

LeetCode147——二叉树的层序遍历：

class Solution {
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>>result;
		if (root == NULL)
			return result;
		vector<int>temp;
		queue<TreeNode*>record;
		record.push(root);
		
		while (record.size()!=0)
		{
			int size = record.size();
			while (size--)
			{
				TreeNode* tmp = record.front();
				record.pop();
				temp.push_back(tmp->val);
				if (tmp->left != NULL)
					record.push(tmp->left);
				if (tmp->right != NULL)
					record.push(tmp->right);
			}
			result.push_back(temp);
			temp.clear();
		
		}
		return result;
	}
};

LeetCode107——二叉树的层次遍历II

 

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

思路：

其实就是把层序遍历的每层结果先放到栈里面，然后出栈在放入容器中，调换了一下输出顺序而已。

代码：

class Solution {
public:
	vector<vector<int>> levelOrderBottom(TreeNode* root) {
		vector<vector<int>>ans;
		if (root == nullptr)
			return ans;
		queue<TreeNode*>q;
		stack<vector<int>>st;
		vector<int>layer;

		TreeNode* pNode = root;
		q.push(pNode);
		while (!q.empty())
		{
			int size = q.size();
			while (size--)
			{
				TreeNode* p = q.front();
				q.pop();
				layer.push_back(p->val);
				if (p->left)
					q.push(p->left);
				if (p->right)
					q.push(p->right);
			}
			st.push(layer);
			layer.clear();
		}
		while (!st.empty())
		{
			ans.push_back(st.top());
			st.pop();
		}
		return ans;

	}
};

 

LeetCode103——二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

 

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回锯齿形层次遍历如下：

[
  [3],
  [20,9],
  [15,7]
]

思路：

其实还是正常的进行层序遍历，只不过设置了一个标志为flag，相邻两层的标志位相反，第一层正常入向量，第二层先入一个临时的栈，最后再入向量中，这样上下两层的节点顺序就相反了。

代码：

class Solution {
public:
	vector<vector<int>>  zigzagLevelOrder(TreeNode* root) {
		vector<vector<int>>ans;
		if (root == nullptr)
			return ans;
		queue<TreeNode*>q;
		stack<vector<int>>st;
		vector<int>layer;

		TreeNode* pNode = root;
		q.push(pNode);
		bool flag = true;
		stack<int>rev;
		while (!q.empty())
		{
			int size = q.size();
			while (size--)
			{
				TreeNode* p = q.front();
				q.pop();
				if(flag==true)
					layer.push_back(p->val);
				else
				{
					rev.push(p->val);
				}
				
				if (p->left)
					q.push(p->left);
				if (p->right)
					q.push(p->right);
			}

			if (flag == true)
			{
				flag = false;
			}
			else
			{
				while (!rev.empty())
				{
					int temp = rev.top();
					layer.push_back(temp);
					rev.pop();
				}
				flag = true;
			}
			ans.push_back(layer);
			layer.clear();

			
			
		}
		
		return ans;

	}
};

LeetCode199——二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

思路：

其实还是二叉树的层序遍历，只不过保留的是每一层节点的最后一个节点的值。

代码：

class Solution {
public:
	vector<int> rightSideView(TreeNode* root) {
		vector<int>ans;
		if (root == NULL)
			return ans;
		TreeNode* pNode = root;
		queue<TreeNode*>q;
		q.push(pNode);

		while (!q.empty())
		{
			int size = q.size();
			while (size--)
			{
				TreeNode* temp = q.front();
				q.pop();
				if (size == 0)
					ans.push_back(temp->val);
				if (temp->left)
					q.push(temp->left);
				if (temp->right)
					q.push(temp->right);
			}
		}
		return ans;
	}
};

 

LeetCode279——完全平方数的和

题目：

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3 
解释: 12 = 4 + 4 + 4.
示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

 

思路：

其实动态规划的做法比较好想到，这里是用了图论的方法，比如从10开始有10->9,10->6,10->1,这三条路径，然后把这三个点入队列，把step+1，依次取出这些节点，然后放入他们能够到达的下一个节点，step继续加一。注意这里有很多重复计算，可以设置一个visited数组记录访问过的元素，然后跳过计算。直到出现值为0的节点，返回step就可以了。

class Solution {
public:
	int numSquares(int n) {

		queue<pair<int, int>>q;
		q.push(make_pair(n, 0));
		vector<bool>visited(n + 1, false);
		visited[n] = true;

		while (!q.empty())
		{
			int num = q.front().first;
			int step = q.front().second;
			q.pop();

			for (int i = 1;; i++)
			{
				int a = num - i * i;
				if (a < 0)
					break;
				if (a == 0)
					return step + 1;
				if (!visited[a])
				{
					q.push(make_pair(a, step + 1));
					visited[a] = true;
				}
			}
		}
        throw invalid_argument("No Solution");
	}
};

 

//动态规划的做法
class Solution {
public:
	int numSquares(int n) {
		vector<int>dp(n + 1);
		dp[0] = 0;
		
		for (int i = 1; i <= n; i++)
		{
			int min = 9999;

			for (int j = 1; j <= int(sqrt(n));j++)
			{
				if (i-j*j >=0)
				{
					int temp = dp[i - j * j];
					if (temp + 1 < min)
					{
						dp[i] = temp + 1;
						min = dp[i];
					}
						

				}
			}
		}
		return dp[n];
	}
};

 

优先级队列的底层是“最大堆”，用法要特别注意，常用来解决topK的问题。

LeetCode347——前k个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

思路：

首先还是用map获得对应数字的出现频率，然后创建一个大小为k的优先级队列，底层选择最小堆实现，然后放入pair（频率，数字），每当一个新的map中的pair过来的时候（注意这个时候两个pair里面的元素位置是反过来的），比较频率的大小，如果新的频率大就加入优先级队列中，不大就不做操作，这样最后优先级队列里面的就是出现频率最多的k元素。

代码：

class Solution {
public:
	vector<int> topKFrequent(vector<int>& nums, int k) {
		int len = nums.size();
		vector<int>res;
		unordered_map<int,int>mp;//元素对应的频率；
		for (int i = 0; i < len; i++)
		{
			mp[nums[i]]++;
		}

		priority_queue<pair<int, int>, vector < pair<int, int>>, greater<pair<int, int>>> pq;
		//降序队列
		//priority_queue <int, vector<int>, greater<int> > q;
	    //升序队列（默认）
	    //priority_queue <int, vector<int>, less<int> >q;
		for (unordered_map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)
		{
			if (pq.size() == k)
			{
				if (it->second > pq.top().first)
				{
					pq.pop();
					pq.push(make_pair(it->second, it->first));
				}
            }
            else
                pq.push(make_pair(it->second, it->first));
			
		}
		
		while (pq.size()!=0)
		{
			res.push_back(pq.top().second);
			pq.pop();
		}
		return res;
	}
};

 

 

 

 

 

Xiao2018428
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构栈和队列以及常见算法题
qq_43941925的博客
03-21 572
栈 概念：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的 一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 数据结构的栈和jvm运行时内存区域中的stack是啥关系：方法的调用涉及到栈帧，调用一个方法就压栈，方法执行完就出栈。 栈帧中有局部变量表， 有效的括号： 根据括号的匹配原则，选择数据结构为栈。 创建一
栈和队列的算法题目总结
maple的博客
05-21 250
栈和队列的算法题目总结
栈和队列的算法题
想要上进的coder的博客
02-26 99
关于栈和队列的算法题
C++-queue：queue基本用法【q.push(x)、q.front()、q.back()、q.pop()、q.size()、q.empty()】
u013250861的博客
12-20 1万+
为了降低时间复杂度，将数组当作一个首尾相连的圆环，分别用两个标志front、rear代表队列的头部和尾部。删除元素时，队首标志往后移，添加元素时，若队尾没有空间，考虑数组的头部空间若还有，则在队头添加元素，防止数组内存空间的流失。出队操作：数组头部元素出队之后，头部之后的元素均需要往前移动一个位置，时间复杂度为O（n）设置一个标志变量flag，同时满足front=rear且flag=1时为满队列。入队操作：在数组的末尾添加元素，时间复杂度为O（1）链表头为队列头部，链表尾为队列尾部。空一个元素，保持为空。
C++队列queue基本用法
jiuguaqiao6494的博客
07-13 2211
C++队列queue基本用法定义常用函数 定义 queue <TreeNode*> q; 常用函数 q.push(u) 入队列 q.empty() 判断队列是否为空 q.front() 取队列第一个数的值 q.pop() 删除队列第一个数
栈和队列的算法以及应用
12-06
栈的算法和应用，以及相应习题，队列的算法及应用，学会利用栈和队列解决一些问题
利用顺序栈逆置循环队列.docx
06-13
设计一个算法，用一个栈s将-一个队列Q逆置: (1)要求采用顺序栈和循环队列来实现。 (2)要求采用链栈和链队列来实现。
第三章栈和队列课后习题.pptx
05-25
"栈和队列" 栈和队列是两种基本的数据结构，它们在计算机科学和信息技术中扮演着重要的角色。栈是一种后进先出（LIFO）的数据结构，元素的添加和删除操作都在栈顶进行。队列是一种先进先出（FIFO）的数据结构，元素...
算法笔试题：（Python实现）—— 算法面试题汇总
01-21
算法笔试题：（Python实现）—— 算法面试题汇总算法笔试题：（Python实现）—— 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落字符串Python实现验证回文串...
数据结构及应用算法教程习题第四章栈和队列.pdf
09-30
数据结构及应用算法教程习题第四章栈和队列 本章节主要讲解了栈和队列的基本概念、操作和应用。栈是一种后进先出的数据结构，栈的操作包括入栈和出栈。队列是一种先进先出的数据结构，队列的操作包括入队和出队。 ...
网络最大流（DFS和BFS实现）
02-20
使用c++实现算法导论上最大流算法，同时使用了深度优先和广度优先算法。
数据结构与算法：栈队列的题库
04-30
数据结构与算法：栈队列的题库
几道和「堆栈、队列」有关的面试算法题
weixin_34341117的博客
03-05 376
题目一：有效的括号 问题描述 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 解题思路 这道题让我们验证输入的字符串是否为括号字符串，包括大括号，中括号和小括号。 这里我们使用栈。 遍历输入字符串 如果当前字符为左半边括号时，则将其压入栈中 如果遇到右半边括号时，分类讨论： 1）如栈不为空且为对应的左半边括号，则取出栈顶元素，继续循环 2）若此时栈...
栈和队列相关算法题目
annuoa的专栏
08-09 251
算法面试题栈和队列栈栈的基本性质栈的应用小问题几个练习题有效的括号棒球比赛比较含退格的字符串单调栈[^1] [^2]单调栈模板下一个更大元素每日温度下一个更大的元素II队列循环队列阻塞队列和并发队列几个小的例子用队列实现栈设计循环队列功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章
栈和队列：面试题（Java）
博客
09-27 7799
两个队列实现一个栈 使用两个队列完成栈的功能, 思路： 如上图，入队顺序为：1 2 3 4 5，如果要模拟栈的功能，那么就要上5先弹出来，因为是队列，所以只能从1开始出，把1 2 3 4存到另外一个队列中，这样就可以把5弹出来了： 这样就完成了一次出栈，这下上面的队列为空，所有的数据存储在下面这个队列中： 如果要继续出栈，那么就把1 2 3 挪到空的队列中，弹出4，到这里已经明白了如何模拟出...
数据结构—栈和队列经典面试题
3166375975@的博客
09-21 8684
栈和队列面试题： 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 使用两个栈实现一个队列 使用两个队列实现一个栈 元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1) 一个数组实现两个栈(共享栈) 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O...
C++ pair 用法
热门推荐
依然一笑作春温。
10-04 1万+
pair
栈和队列的常见面试题
snow_5288的博客
05-04 3799
1、两个队列实现一个栈 两个队列实现一个栈2、两个栈实现一个队列 【算法思想】 1>设计类 成员变量：给两个栈s1和s2来模拟实现一个队列 成员函数：入队Push()和出队Pop() 2>给两个指向栈对象s1、s2的指针input和output，分别用来入队和出队 3>按照先进先出的方式模拟入队和出队操作 Push：将input指向不空的栈，然后在input中入队 Pop：将inp
数据结构栈与队列题库
闲狗的博客
08-01 9701
网络课课后题 1、设栈S 和队列Q 的初始状态为空，元素e1，e2，e3，e4，e5和e6依次通过栈S，一个元素出栈后即进队列Q，若6 个元素出队的序列是e2，e4，e3，e6，e5，e1则栈S的容量至少应该是 3 解析：不难，在本子上写写画画就行 2、双端队列可以在队列的两端进行插入和删除操作，既可在队尾进行插入/删除，又可在队头进行插入/删除。现有4个不同的元素顺序输入到双端队列...
写前端常见的面试算法题和案例
最新发布
05-25
前端面试中常见的算法题和案例有： 1. 翻转字符串：给定一个字符串，将其翻转并返回。 2. 反转链表：给定一个链表，将其反转并返回。 3. 斐波那契数列：输出斐波那契数列的前 n 项。 4. 数组去重：给定一个数组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值