7月12日-周三

一、刷题

力扣347，前K个高频元素

使用map统计元素频率，然后对频率进行排序，最后输出前k个高频元素

对频率进行排序时要使用优先级队列

注意到底是使用大根堆还是小根堆

整体代码

class MyCompare {
public:
    bool operator()(const pair<int,int>& a, const pair<int,int>& b) {
        return a.second < b.second;
    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> map;
        //统计元素频率
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }
        //对频率进行排序
        priority_queue<pair<int,int>, vector<pair<int,int>>, MyCompare> que;

        for (unordered_map<int,int>::iterator it = map.begin(); it != map.end(); it++) {
            que.push(*it);
        }

        //输出前k个高频元素
        vector<int> res(k);
        // for (int i = k - 1; i >= 0; i--) {
        //     res[i] = que.top().first;
        //     que.pop();
        // }     
        for (int i = 0; i < k; i++) {
            res[i] = que.top().first;
            que.pop();
        }
        return res;
    }
};

力扣239，滑动窗口最大值

要使用单调队列，单调队列的实现并不是对队列里的数进行排序，

单调队列代码（对头元素为滑动窗口中的最大值）

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

整体代码

class MyQue {//定义单调队列
public:
    deque<int> que;

    void pop(int value) {
        if (!que.empty() && value == que.front()) {
            que.pop_front();
        }
    }

    void push(int value) {
        while (!que.empty() && value > que.back()) {
            que.pop_back();
        }
        que.push_back(value);
    }

    int front() {
        return que.front();
    }

};

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQue que;
        vector<int> res;
        for (int i = 0; i < k; i++) {
            que.push(nums[i]);
        }
        res.push_back(que.front());
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]);
            que.push(nums[i]);
            res.push_back(que.front());
        }

        return res;
    }
};

力扣150，逆波兰表达式

关键一步是将数组中的数字压入栈中，如果遇到运算符则将栈顶的两个元素取出进行计算，然后再压入栈中

整体代码

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for (int i = 0; i < tokens.size(); i++) {
            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
                int num1 = st.top(); st.pop();
                int 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(stoi(tokens[i]));
            }
        }
        int res = st.top();
        st.pop();
        return res;

    }
};

二、面经整理

1、C++类

2、计算机网络