算法训练-Day09 | 150. 逆波兰表达式求值 239. 滑动窗口最大值 347.前 K 个高频元素

150. 逆波兰表达式求值

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;    //long  long是一种数据类型，比long还要大
        
        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]));  // stoll函数是将字符串转换为long long型
        }

        int result = st.top();
        st.pop();
        return result;
    }
};

239. 滑动窗口最大值

采用双端队列

1、deque内仅包含窗口内的元素->每轮窗口滑动移除了元素nums[i-1]，需要将deque 内的对应元素一起删除

2、deque内的元素要递减->每轮窗口滑动添加了元素nums[j+1]，需要将deque内所有小于它的元素一起删除。

算法流程：

1、初始化：双端队列dq，结果列表result，数组长度n

2、滑动窗口：左边界i ∈[1−k,n−k]，右边界范围 j∈[0,n−1]

        a、若i > 0且队首元素deque[0] = 被删除元素nums[i-1]：则删除队首元素

        b、删除队列内所有小于num[j] 的元素，保证队列内是递减的

        c、将nums[j] 添加到尾部

        d、如果已经形成窗口(i >= 0)，则将窗口最大值（即队首元素）添加到列表result

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if(nums.size() == 0 || k == 0)
            return {};

        deque<int> dq;
        vector<int> result(nums.size()-k+1);

        for(int i = 1-k,j = 0;j < nums.size();i++,j++){

            // 删除 deque 对应的num[i-1]
            if(i > 0 && dq.front() == nums[i-1])
                dq.pop_front();
            
            // 保证deque是递减的
            while(!dq.empty() && dq.back() < nums[j])
                dq.pop_back();
            dq.push_back(nums[j]);
            //记录窗口最大值
            if(i >= 0)
                result[i] = dq.front();
        }
        return result;
    }
};

可以分成“未形成窗口”和“形成窗口后”两个阶段拆分到两个循环里，可以减少冗余的判断操作

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if(nums.size() == 0 || k == 0) return {};
        deque<int> deque;
        vector<int> res(nums.size() - k + 1);    //vector是标准库容器，可以动态调整大小
        // 未形成窗口
        for(int i = 0; i < k; i++) {
            while(!deque.empty() && deque.back() < nums[i])
                deque.pop_back();
            deque.push_back(nums[i]);
        }
        res[0] = deque.front();
        // 形成窗口后
        for(int i = k; i < nums.size(); i++) {
            if(deque.front() == nums[i - k])
                deque.pop_front();
            while(!deque.empty() && deque.back() < nums[i])
                deque.pop_back();
            deque.push_back(nums[i]);    //新元素加入队列
            res[i - k + 1] = deque.front();
        }
        return res;
    }
};

347.前 K 个高频元素

（1）统计元素出现次数

（2）对频率进行排序

（3）取前 k 个高频元素  

        对于统计元素出现频率的问题，可以采用 map 进行统计；对于频率进行排序，可以采用一种容器适配器也就是优先级队列（从队头取元素，队尾添加元素），默认情况下优先级队列时利用大顶堆进行元素排序，该大顶堆是以 vector 为表现形式的完全二叉树。

        堆的大小为k，因此要用小顶堆，若有新的元素要加入，则弹出最小的频率堆顶元素即可。

        priority_queue<Type, Container, Functional>;(Type是要存放的数据类型；Container是实现底层堆的容器，必须是数组实现的容器，如vector、deque；Functional是比较方式/比较函数/优先级）

        priority_queue<Type>; 此时默认的容器是vector，默认的比较方式是大顶堆less<type>

例如：

//小顶堆
priority_queue <int,vector<int>,greater<int> > q;
//大顶堆
priority_queue <int,vector<int>,less<int> >q;
//默认大顶堆
priority_queue<int> a

常用的函数有top（）、pop（）、push（）、emplace（）、empty（）、size（）

自定义比较方式：当数据类型并不是基本数据类型，而是自定义的数据类型时，就不能用greater或less的比较方式了，而是需要自定义比较方式，例如自定义水果的数据类型：

struct fruit
{
	string name;
	int price;
};

重载 “ < ”，如果希望水果价格高为优先级高，则

//大顶堆
struct fruit
{
	string name;
	int price;
	friend bool operator < (fruit f1,fruit f2)
	{
		return f1.peice < f2.price;
	}
};

如果希望水果价格低为优先级高，则

//小顶堆
struct fruit
{
	string name;
	int price;
	friend bool operator < (fruit f1,fruit f2)
	{
		return f1.peice > f2.price;  //此处是>
	}
};

仿函数：

//小顶堆
struct myComparison
{
	bool operator () (fruit f1,fruit f2)
	{
		return f1.price > f2.price;
	}
};

//此时优先队列的定义应该如下
priority_queue<fruit,vector<fruit>,myComparison> q;

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
    // 1、使用map记录元素出现的次数
        unordered_map<int,int> map;
        for(auto & i:nums)
            map[i]++;   // map[key,value],  map[i]]表示key为i的value

    // 2、利用优先队列，将次数进行排序
        // 自定义优先队列的比较方式，采用小顶堆
        // oprator是重载运算符;pair类型的对象需要两个数据类型，但是两个数据类型不一定要相同。
        struct Comparison{
            bool operator()(pair<int,int> &m,pair<int,int> &n){
                return m.second > n.second; // 大于号是小顶堆，左右节点都大于父亲节点
            }
        };
        // 创建优先队列，因为 map 有两种数据类型，所以这里用pair
        priority_queue<pair<int,int>,vector<pair<int,int>>,Comparison> pq;
        
        // 遍历map中的元素
        // 1、不管是很么元素，先入队列，队列会自己进行排序将元素放在合适的位置
        // 2、若队列元素个数超过 k ，则栈顶元素出栈(栈顶元素一定是最小频率)
        for(auto &j:map){
            pq.push(j);
            if(pq.size() > k)
                pq.pop();
        }

        // 导出结果
        vector<int>  res;
        // 因为题目说可以按任意顺序返回答案，所以这里按元素出现频次从小到大也没事，如果按出现频次从大到小则反转一下 res 即可。
        while(!pq.empty()){
            res.push_back(pq.top().first);  //这里的first是指 pair 类型中的的第一个数据类型的元素
            pq.pop();
        }
        return res;
    }
};