20/239/347

20.有效的括号

class Solution {
public:
    bool isValid(string s) {
        //长度不达标
        if(s.size()%2!=0) return false;
        stack<int> 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(st.empty()||s[i]!=st.top()) return false;
            //如果相同则出战
            else st.pop();
        }
        return st.empty();//如果为空则说明完全匹配了
    }
};

239.滑动窗口最大值

维持一个单调递减队列，出口始终为最大值，如果当前值比入口大的话，则取出比它小的值，然后将当前值推入队列；

加入当前值以前，需要将前面一个值删除，那么需要判断是否是之前窗口中的最大值，即是否需要将队列出口最大值弹出。

线形复杂度解决：

class Solution {
private:
    class MyQueue{
    public:
        deque<int> que;//双向实现单调队列
    //每次弹出的时候，比较当前的弹出值和队列出口元素的最大值是否相等，相等的话则弹出
    //同时pop之前判断队列是否为空
    void pop(int value)//输入需要弹出值，判断是否跟栈顶数据相等
    {
        if(!que.empty()&& value == que.front())
        {
            que.pop_front();//队列是pop_front
        }
    }
    //如果需要移动窗口，则意味着需要push 但是需要将前面的小值都删除 只留下需要的大值
    //push维持单调队列，将较小值都pop_back
    void push(int value){
        while(!que.empty()&&value>que.back()){
            que.pop_back();
        }
        que.push_back(value);
    }

    //每一次窗口获取最大值
    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++){
        //push的时候已经在内部排序了
        que.push(nums[i]);
    }
    //弹出第一轮的最大值
    result.push_back(que.front());
    //接下来开始滑动窗口
    for(int i=k;i<nums.size();i++){
        que.pop(nums[i-k]);//内部判断这个数值是否是栈顶 最大的数字，是的话就需要删除
        que.push(nums[i]);//加入新值
        result.push_back(que.front());//记录本轮
    }
    return result;
    }
};

347.前k个高频元素

小顶堆，留着最大的k个元素在堆里面，动态变化数值。

priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison> pri_que;

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){
    //返回前k的数值
    vector<int> result(k);
    //使用map来记录数值及对应出现的频率
    unordered_map<int,int> map;
    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的时候，就将最小值删掉
            pri_que.pop();
        }
    }
    //找出前k个高频元素，因为小顶堆先弹出最小值
    for(int i=k-1;i>=0;i--){
        result[i] = pri_que.top().first;
        pri_que.pop();
    }
    return result;
    
}

};