算发刷题day10|栈和队列：150. 逆波兰表达式求值、239. 滑动窗口最大值、347. 前 K 个高频元素

最新推荐文章于 2024-07-14 23:27:07 发布

哆来咪咪咪

最新推荐文章于 2024-07-14 23:27:07 发布

阅读量753

点赞数 9

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_61936886/article/details/140401727

版权

150. 逆波兰表达式求值

适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

std::stoi, std::stol, std::stoll的区别和用法

int stoi ( const std::string& str,
std::size_t* pos = nullptr, int base = 10 );

long stol ( const std::string& str,
std::size_t* pos = nullptr, int base = 10 );

long long stoll( const std::string& str,
std::size_t* pos = nullptr, int base = 10 );

参数

str	-	要转换的字符串
pos	-	存储已处理字符数的整数的地址
base	-	数的底

返回值

对应 str 内容的整数值。

异常

无法进行转换时会抛出 std::invalid_argument。
转换值会落在结果类型的范围外，或底层函数（即 std::strtol 或 std::strtoll）将 errno 设置为 ERANGE 时会抛出 std::out_of_range。

本人AC版

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> stk;
        for (int i = 0; i < tokens.size(); i++) {
            try {
                auto num = stoll(tokens[i]);
                if (num >= -200 && num <= 200) {
                    stk.push(num);
                    continue;
                }
            } catch (...) {
                // （...）能捕获到任何类型的异常
                if (!stk.empty() && tokens[i] == "+") {
                    long long temp1 = stk.top();
                    stk.pop();
                    long long temp2 = stk.top();
                    stk.pop();
                    stk.push(temp2 + temp1);
                } else if (!stk.empty() && tokens[i] == "-") {
                    long long temp1 = stk.top();
                    stk.pop();
                    long long temp2 = stk.top();
                    stk.pop();
                    stk.push(temp2 - temp1);
                } else if (!stk.empty() && tokens[i] == "*") {
                    long long temp1 = stk.top();
                    stk.pop();
                    long long temp2 = stk.top();
                    stk.pop();
                    stk.push(temp2 * temp1);
                } else if (!stk.empty() && tokens[i] == "/") {
                    long long temp1 = stk.top();
                    stk.pop();
                    long long temp2 = stk.top();
                    stk.pop();
                    stk.push(temp2 / temp1);
                }
            }
        }
        int res = stk.top();
        return res;
    }
};

注：自己第一次写的时候不太清楚stoll的用法，没有处理异常，导致迟迟没有AC。因为stoll调用的时候如果参数不是数字会抛出异常，所有要将这个异常try catch掉。（非常感谢当时解答的大佬鱼哥）

优雅简洁版

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;
    }
};

239. 滑动窗口最大值

单调队列

思路：自定义一个单调队列，que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。在队列中，如果有更大的元素进队列，则前面的元素全部出队。

pop：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作

push：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
        //因为当前的队列出口元素是当前窗口的最大值，如果要弹出的值与当前队列出口元素相等，必须弹出，因为要遍历到下一个窗口时最大值是会更新的
        // 同时pop之前判断队列当前是否为空。
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);

        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front() {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素，该操作不会每次都执行，因为在push的过程中有时会直接把较小值pop掉
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};

multiset作为单调队列

多重集合(multiset) 用以有序地存储元素的容器。允许存在相等的元素。

在遍历原数组的时候，只需要把窗口的头元素加入到multiset中，然后把窗口的尾元素删除即可。因为multiset是有序的，并且提供了*rbegin()，可以直接获取窗口最大值。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        multiset<int> st;
        vector<int> ans;
        for (int i = 0; i < nums.size(); i++) {
            if (i >= k) st.erase(st.find(nums[i - k]));
            st.insert(nums[i]);
            if (i >= k - 1) ans.push_back(*st.rbegin());
        }
        return ans;
    }
};

优先队列+下标

将数组 nums 的前 k 个元素放入优先队列中。每当我们向右移动窗口时，我们就可以把一个新的元素放入优先队列中，此时堆顶的元素就是堆中所有元素的最大值。然而这个最大值可能并不在滑动窗口中，在这种情况下，这个值在数组 nums 中的位置出现在滑动窗口左边界的左侧。

我们不断地移除堆顶的元素，直到其确实出现在滑动窗口中。此时，堆顶元素就是滑动窗口中的最大值。为了方便判断堆顶元素与滑动窗口的位置关系，我们可以在优先队列中存储二元组 (num,index)，表示元素 num 在数组中的下标为 index。

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) {
            //emplace 原地构造一个元素并插入队列
            q.emplace(nums[i], i);
        }
        vector<int> ans = {q.top().first};
        for (int i = k; i < n; ++i) {
            q.emplace(nums[i], i);
            //如果堆顶元素不在滑动窗口内，则不断地pop，直至在窗口内，此时才是当前窗口的最大值
            while (q.top().second <= i - k) {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

347. 前 K 个高频元素

std::priority_queue的定义

template<

  class T,
  class Container = std::vector<T>,
  class Compare = std::less<typename Container::value_type>

> class priority_queue;

模板形参

T - 存储元素的类型。T 与 Container::value_type 不是同一类型时非良构。

Container

用于存储元素的底层容器类型。容器必须满足序列容器 (SequenceContainer) 的要求，并且它的迭代器必须满足老式随机访问迭代器 (LegacyRandomAccessIterator) 的要求。另外，它必须提供拥有通常语义的下列函数：

back()，例如 std::vector::back()，
push_back()，例如 std::deque::push_back()，
pop_back()，例如 std::vector::pop_back()。

标准容器 std::vector（包括 std::vector<bool>）和 std::deque 满足这些要求。

Compare

提供严格弱序的比较 (Compare) 类型。

注意比较 (Compare) 形参的定义，使得它的第一实参在弱序中先于它的第二实参时返回 true。但因为优先级队列首先输出最大元素，所以“先来”的元素实际上会在最后输出。即队列头含有按照比较 (Compare) 所施加弱序的“最后”元素。

priority_queue 默认使用的仿函数是 less，所以默认建成的堆是大堆；如果我们想要建小堆，则需要指定仿函数为 greater

仿函数是一个类，但是该类必须重载函数调用运算符 ( )，即 operator()(参数)；由于这样的类的对象可以像函数一样去使用，所以我们将其称为仿函数/函数对象（下面的小顶堆写法会涉及到）

哈希表+大顶堆

map集合中存放<key, value>，key存放数组中的元素，value存放元素出现的次数。然后将键值对存放到优先队列中，输出前k个队头元素。

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        priority_queue<pair<int, int>> pq;
        vector<int> res;
        for(int num : nums) {
            mp[num]++;
        }
        for(auto it = mp.begin(); it != mp.end(); it++) {
            //此时次数在前，元素在后
            pq.push(pair<int, int>(it->second, it->first));
        }
        while(k--) {
            //因为之前次数和元素的顺序交换了，而最后结果为元素，所有是second
            res.push_back(pq.top().second);
            pq.pop();
        }
        return res;
    }
};

小顶堆

要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

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;

    }
};