栈与队列刷题总结

最新推荐文章于 2024-08-29 18:44:48 发布

看到请叫我去学习

最新推荐文章于 2024-08-29 18:44:48 发布

阅读量55

点赞数

分类专栏：算法刷题文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/m0_74041368/article/details/129802148

版权

算法刷题专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章展示了如何使用栈和队列数据结构实现特定功能，如MyQueue和MyStack，以及在括号匹配和重复元素去除等问题中的应用。同时，文中包含求解逆波兰表达式和找到数组中出现频率最高的k个元素的解决方案。

摘要由CSDN通过智能技术生成

class MyQueue {
public: stack<int>st1;//控制减少元素
        stack<int>st2;//控制增加元素
    MyQueue() {

    }
    
    void push(int x) {//把st1的元素导入到st2，然后再加新的元素
        while(!st1.empty()){
            st2.push(st1.top());
            st1.pop();
        }
        st2.push(x);
    }
    
    int pop() {//把st2的元素导入到st1，再移除元素
        while(!st2.empty()){
            st1.push(st2.top());
            st2.pop();
        }
        int res=st1.top();
        st1.pop();
        return res;
    }
    
    int peek() {
        while(!st2.empty()){
            st1.push(st2.top());
            st2.pop();
        }
        return st1.top();
    }
    
    bool empty() {
        if(st1.empty()&&st2.empty())return true;
        else{
            return false;
        }
    }
};

class MyStack {
public:
    queue<int> que1;
    queue<int> que2; // 辅助队列，用来备份
    /** Initialize your data structure here. */
    MyStack() {

    }

    /** Push element x onto stack. */
    void push(int x) {
        que1.push(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int size = que1.size();
        size--;
        while (size--) { // 将que1 导入que2，但要留下最后一个元素
            que2.push(que1.front());
            que1.pop();
        }

        int result = que1.front(); // 留下的最后一个元素就是要返回的值
        que1.pop();
        que1 = que2;            // 再将que2赋值给que1
        while (!que2.empty()) { // 清空que2
            que2.pop();
        }
        return result;
    }

    /** Get the top element. */
    int top() {
        return que1.back();
    }

    /** Returns whether the stack is empty. */
    bool empty() {
        return que1.empty();
    }
};

class Solution {
public:
    bool isValid(string s) {
        stack<char>st;
        for(int i=0;i<s.size();i++){
            //如果发现有左配对，则将对应的右元素加入栈
            if(s[i]=='('){
                st.push(')');
            }
            else if(s[i]=='{'){
                st.push('}');
            }
            else if(s[i]=='['){
                st.push(']');
            }
            //如果发现右元素
            else if(s[i]==')'||s[i]=='}'||s[i]==']'){
                //如果栈非空并且与栈顶相等
                if(!st.empty()&&st.top()==s[i]){
                    st.pop();
                }
                else{
                    return false;
                }
            }
        }
        if(st.empty())return true;
        else return false;
    }
};

class Solution {
public:
    string removeDuplicates(string s) {
        string res;
        stack<char>st;
        for(int i=0;i<s.size();i++){
            if(!st.empty()&&s[i]==st.top()){//如果为空，不会执行top语句
                st.pop();
            }
            else{
                st.push(s[i]);
            }
        }
        while(!st.empty()){
            res+=st.top();
            st.pop();
        }
        //还要反转
        reverse(res.begin(),res.end());
        return res;
    }
};

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        // 力扣修改了后台测试数据，需要用longlong
        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();
        st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
    }
};

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        dic = {}
        for i in range(n):
            if nums[i] not in dic:
                dic[nums[i]] = 1
            else:
                dic[nums[i]] += 1
        
        res = []
        while k > 0:
            tmp = 0
            for num in dic:
                if dic[num] > tmp:
                    tmp = dic[num]
                    cur = num
            dic[cur] = -1
            res.append(cur)
            k -= 1
        return res

class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};