目录
一、stack 相关的练习
1.1 - 最小栈
1.2 - 栈的压入、弹出序列
1.3 - 逆波兰表达式求值
1.4 - 用栈实现队列
二、queue 相关的练习
2.1 - 二叉树的层序遍历
2.2 - 二叉树的层序遍历 II
2.3 - 用队列实现栈
三、priority_queue 相关的练习
3.1 - 数组中的第K个最大元素
一、stack 相关的练习
1.1 - 最小栈
class MinStack {
public:
void push(int val) {
st.push(val);
if (min_st.empty() || val <= min_st.top())
min_st.push(val);
}
void pop() {
if (st.top() == min_st.top())
min_st.pop();
st.pop();
}
int top() {
return st.top();
}
int getMin() {
return min_st.top();
}
private:
stack<int> st;
stack<int> min_st;
};思路：
1.2 - 栈的压入、弹出序列
class Solution {
public:
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
if (pushV.size() != popV.size())
return false;
stack<int> st;
int i = 0;
int j = 0;
while (i < pushV.size())
{
if (pushV[i] != popV[j])
{
st.push(pushV[i++]);
}
else
{
++i; // 入栈
++j; // 出栈
while (!st.empty() && popV[j] == st.top())
{
st.pop();
++j;
}
}
}
return st.empty();
}
};思路：
根据入栈和出栈序列，用一个栈 st 来模拟整个过程。
-
如果入栈序列中待入栈的数字，即 pushV[i]，不等于出栈序列中待出栈的数字，即 popV[j]，则将 pushV[i] 入栈。
-
反之，则表示数字入栈后马上就要出栈，然后还要判断后面待出栈的数字是否等于栈顶元素，即判断是否还有数字需要出栈。
1.3 - 逆波兰表达式求值
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for (auto& s : tokens)
{
if (s == "+" || s == "-" || s == "*" || s == "/")
{
int right = st.top(); // 右操作数
st.pop();
int left = st.top(); // 左操作数
st.pop();
switch(s[0])
{
case '+':
st.push(left + right);
break;
case '-':
st.push(left - right);
break;
case '*':
st.push(left * right);
break;
case '/':
st.push(left / right);
break;
}
}
else
{
st.push(stoi(s));
}
}
return st.top();
}
};思路：
-
遇到操作数，则将其入栈。
-
遇到操作符，则取出栈顶两个数字分别作为右操作数和左操作数进行运算，然后再将运算结果压入栈中。
注意：在判断字符串 s 是否为操作符时，不能使用
s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/'进行判断，因为当 s 表示负数时，例如 "-11"，s[0] 也是 '-'。而在已经确定字符串 s 为操作符时，就可以使用 s[0] 对操作符进行区分了。
1.4 - 用栈实现队列
class MyQueue {
public:
void push(int x) {
in_st.push(x);
}
int peek() {
if (out_st.empty())
{
while (!in_st.empty())
{
out_st.push(in_st.top());
in_st.pop();
}
}
return out_st.top();
}
int pop() {
int front = peek();
out_st.pop();
return front;
}
bool empty() {
return in_st.empty() && out_st.empty();
}
private:
stack<int> in_st; // 用于入队的栈
stack<int> out_st; // 用于出队的栈
};二、queue 相关的练习
2.1 - 二叉树的层序遍历
题目描述：
给你二叉树的根节点 root，返回其节点值的 层序遍历（即逐层地、从左到右访问所有节点）。
代码实现：
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> q;
size_t levelSize = 0; // 所在层数的节点个数
if (root)
{
q.push(root);
levelSize = 1;
}
vector<vector<int>> vv;
while (!q.empty())
{
vector<int> v;
for (size_t i = 0; i < levelSize; ++i)
{
TreeNode* front = q.front();
q.pop();
v.push_back(front->val);
if (front->left)
q.push(front->left);
if (front->right)
q.push(front->right);
}
vv.push_back(v);
levelSize = q.size();
}
return vv;
}
};2.2 - 二叉树的层序遍历 II
题目描述：
给你二叉树的根节点 root，返回其节点值 自底向上的层序遍历（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）。
代码实现：
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
queue<TreeNode*> q;
size_t levelSize = 0; // 所在层数的节点个数
if (root)
{
q.push(root);
levelSize = 1;
}
vector<vector<int>> vv;
while (!q.empty())
{
vector<int> v;
for (size_t i = 0; i < levelSize; ++i)
{
TreeNode* front = q.front();
q.pop();
v.push_back(front->val);
if (front->left)
q.push(front->left);
if (front->right)
q.push(front->right);
}
vv.push_back(v);
levelSize = q.size();
}
reverse(vv.begin(), vv.end()); // 逆置
return vv;
}
};2.3 - 用队列实现栈
class MyStack {
public:
void push(int x) {
// 让一个队列存储数据，让另一个队列为空
if (!q1.empty())
q1.push(x);
else
q2.push(x);
}
int pop() {
// 前提是栈非空
assert(!empty());
// 找到非空队列和空队列
queue<int>* empty = &q1;
queue<int>* nonempty = &q2;
if (!q1.empty())
{
empty = &q2;
nonempty = &q1;
}
// 将非空队列中的数据移至空队列中，仅仅保留最后一个数据
while (nonempty->size() > 1)
{
empty->push(nonempty->front());
nonempty->pop();
}
int top = nonempty->front();
nonempty->pop();
return top;
}
int top() {
assert(!empty());
if (!q1.empty())
return q1.back();
else
return q2.back();
}
bool empty() {
return q1.empty() && q2.empty();
}
private:
queue<int> q1;
queue<int> q2;
};三、priority_queue 相关的练习
3.1 - 数组中的第K个最大元素
方法一：
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
// 排升序
// sort(nums.begin(), nums.end());
// return nums[nums.size() - k];
// 排降序
sort(nums.begin(), nums.end(), greater<int>());
return nums[k - 1];
}
};无论是排升序，还是排降序，时间复杂度都是 O(n * logn)。
方法二：
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
priority_queue<int> pq(nums.begin(), nums.end());
while (--k) // 注意：循环次数为 k - 1
{
pq.pop();
}
return pq.top();
}
};时间复杂度为 O(n + k * logn)。
方法三：
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
priority_queue<int, vector<int>, greater<int>> pq(nums.begin(), nums.begin() + k);
for (size_t i = k; i < nums.size(); ++i)
{
if (nums[i] > pq.top())
{
pq.pop();
pq.push(nums[i]);
}
}
return pq.top();
}
};时间复杂度为 O(k + (n - k) * logk)。
