栈与队列 | 优先队列（priotity_queue)

20. 有效的括号

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

class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if (n % 2 == 1) {
            return false;
        }
        unordered_map<char, char> pairs = {
            {')', '('},
            {']', '['},
            {'}', '{'}
        };
        stack<char> stk;
        for (char ch: s) {
            if (pairs.count(ch)) {
                if (stk.empty() || stk.top() != pairs[ch]) {
                    return false;
                }
                stk.pop();
            }
            else {
                stk.push(ch);
            }
        }
        return stk.empty();
    }
};

1047. 删除字符串中的所有相邻重复项

题目：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在 S 上反复执行重复项删除操作，直到无法继续删除。返回最终的字符串。

示例：输入："abbaca"  输出："ca"

class Solution {
public:
    string removeDuplicates(string s) {
        string st;
        for (char ch : s) {
            if (!st.empty() && st.back() == ch) {
                st.pop_back();
            } else {
                st.push_back(ch);
            }
        }
        return st;
    }
};

• 150. 逆波兰表达式求值

题目：有效的运算符包括 + ,  - ,  * ,  / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。整数除法只保留整数部分。 表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：输入: ["2", "1", "+", "3", " * "]   输出: 9

解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

思路：遍历字符串，如果是数字就压入栈，如果是运算符，就对栈顶的两个数进行运算，并将结果压入栈。然后继续遍历字符串到结束，返回栈就可以。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st; 
        for (int i = 0; i < tokens.size(); i++) {
            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
                long long num1 = st.top(); st.pop();
                long long num2 = st.top(); st.pop();
                if (tokens[i] == "+") st.push(num2 + num1);
                if (tokens[i] == "-") st.push(num2 - num1);
                if (tokens[i] == "*") st.push(num2 * num1);
                if (tokens[i] == "/") st.push(num2 / num1);
            } else {
                st.push(stoll(tokens[i]));
            }
        }
        int result = st.top();
        return result;
    }
};

 239. 滑动窗口最大值

题目：给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。

思路：优先队列可以实时维护一系列元素中的最大值。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        priority_queue<pair<int, int>> q;
        for (int i = 0; i < k; ++i) {
            q.emplace(nums[i], i);
        }
        vector<int> ans = {q.top().first};
        for (int i = k; i < n; ++i) {
            q.emplace(nums[i], i);
            while (q.top().second <= i - k) {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

347.前 K 个高频元素

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

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

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
    unordered_map<int, int> freq;
    for (int num : nums) {
        freq[num]++;
    }
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> min_heap;
    for (const auto& kv : freq) {
        min_heap.push({kv.second, kv.first});
        if (min_heap.size() > k) {
            min_heap.pop();
        }
    }
    vector<int> result(k);
    for (int i = k - 1; i >= 0; --i) {
        result[i] = min_heap.top().second;
        min_heap.pop();
    }
    return result;
    }
};