栈和队列

栈的基本操作

empty() 堆栈为空则返回真

pop() 移除栈顶元素 （删除）

push() 在栈顶增加元素 （增加）

size() 返回栈中元素数目

top() 返回栈顶元素，不删除（获取）

队列的基本操作

back()返回最后一个元素

empty()如果队列空则返回真

front()返回第一个元素

pop()删除第一个元素

push()在末尾加入一个元素

size()返回队列中元素的个数

 

232. 用栈实现队列 - 力扣（LeetCode） (leetcode-cn.com)

注意细节，要等输出栈空了才能转移输入栈元素到输出栈，否则先push1234，再pop一次，输出还剩下234，再push5，这时候如果直接放入输出栈，会直接放在头部，首先输出，再依次输出的话就是5234了

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    MyQueue() {

    }

    void push(int x) {//push和pop交替，那么这种情况，必须stOut为空了，再转移stIn里的数据
        stIn.push(x);
    }
    
    int pop() {
       
        int res = this->peek();
        stOut.pop();
        return res;
    }
    
    int peek() {
        if(stOut.empty())
            while(!stIn.empty()){
                stOut.push(stIn.top());
                stIn.pop();
            }
        int res = stOut.top();
        return res;
    }
    
    bool empty() {
        return stIn.empty()&&stOut.empty();
    }
};

 

225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com)

class MyStack {
public:
    queue<int> que;
    MyStack() {

    }
    
    void push(int x) {
        que.push(x);
    }
    
    int pop() {
        int res = que.back();
        int size = que.size();
        size--;
        while(size--){
            que.push(que.front());
            que.pop();
        }
        que.pop();
        return res;
     
    }
    
    int top() {
        return que.back();
    }
    
    bool empty() {
        return que.empty();
    }
};

 

20. 有效的括号 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for(int i=0;i<s.size();i++){
            if(s[i]=='('||s[i]=='{'||s[i]=='[')
                st.push(s[i]);
            else{
                if(st.empty())//")))"
                    return false;
                char temp = st.top();
                st.pop();
                cout<<s[i]<<temp;
                if((temp=='('&&s[i]==')')||(temp=='{'&&s[i]=='}')||(temp=='['&&s[i]==']'))//三种正确情况，就继续执行
                    continue;
                else    
                    return false;
            }
        }
        if(st.empty())
            return true;
        else   
            return false;
    }
};

 另外一种巧写法，比如碰到左括号就放入对应右括号哈哈哈，这样就可以直接判等了

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(st.empty()||st.top()!=s[i])
                return false;
            else
                st.pop();
        }
        return st.empty();
    }
};

 

150. 逆波兰表达式求值 - 力扣（LeetCode） (leetcode-cn.com)

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 a = st.top();st.pop();//注意a,b顺序，a先出是靠后的数，b在a前
                int b = st.top();st.pop();
                if(tokens[i]=="+")
                    st.push(b+a);
                else if(tokens[i]=="-")
                    st.push(b-a);
                else if(tokens[i]=="*")
                    st.push(b*a);
                else if(tokens[i]=="/")
                    st.push(b/a);
            }else{
 
                st.push(stoi(tokens[i]));
            }
        }
        return st.top();
    }
};

 

滑动窗口k，维护的队列长度其实是<=k的，因为队列进行了数据筛选，如果数组下标大的还比下标小的数据大，那么下标小的数在队列（滑动窗口）里就没有存在的必要了，基于这种情况做出的单调性

比如 1，3，-1，-3，5，3，6，7，k=3

初始化队列：3，-1

i=3：3，-1，-3

i=4：5

i=5：5，3

i=6：6

i=7：7

懂了吧哈哈哈

239. 滑动窗口最大值 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
private:
    class MyQueue{
    public:
        deque<int> que;
        void pop(int value){
            if(!que.empty()&&value == que.front())//value和front大小关系，value不可能闭front大，
            //如果比front小，那么队列里没有value这个值了，因为递增，value早在front加入队列时push操作那就被移除了,这时候就不用移除了
                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();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
         vector<int> result;
        for(int i=0;i<k;i++){
           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;
    }
};

 

自定义重载优先队列，第一种pair实现，第一种结构体，最后一种就是契合默认优先队列，按第一位排序且是大根堆，队首最大

自定义vector，第四种，时间慢了，维护了n个元素，nlog(n)，队列的话只维护k个元素，就是nlog(k)

347. 前 K 个高频元素 - 力扣（LeetCode） (leetcode-cn.com)

这个题也可以不用重载，放入优先队列时，交换一下first和second的位置，因为是根据second来排序，所以把second排在第一位，然后有因为默认是大根堆每次弹出最大的，取相反数就刚好了。还要注意结果数据和队列一次弹出数据是反着的。

如果是设置成友元函数（friend），一定要注意： 
（1）当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。 
（2）有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。 

比如这道题结构体重载<，就要用friend消除this指针，不然报错三个参数啥的。

class Solution {
public:
    typedef pair<int, int> PII;
    struct cmp{
        bool operator ()(const PII& l,const PII& r){
           return l.second>r.second;
        }
    };
       
    vector<int> topKFrequent(vector<int>& nums, int k) {
        
        unordered_map<int, int> mp;
        for(auto num: nums)  mp[num] ++ ;
        priority_queue<PII,vector<PII>,cmp> pq;
        for(auto item: mp){
            pq.push(item);
            if(pq.size() > k) pq.pop();
        }
        vector<int> res(k);
        for(int i = k - 1; i >= 0; i --){
            res[i] = pq.top().first;
            pq.pop();
        }
        return res;
    }
};

class Solution {
public:
    struct node{
        int x, y;
        friend bool operator < (node a, node b){
            return a.y > b.y;                               //y小的优先
        }
    };
       
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        for(auto num: nums)  mp[num] ++ ;
        priority_queue<node> pq;
        for(auto item: mp){
            node t;
            t.x = item.first;
            t.y = item.second;
            pq.push(t);
            if(pq.size() > k) pq.pop();
        }
        vector<int> res(k);
        for(int i = k - 1; i >= 0; i --){
            res[i] = pq.top().x;
            pq.pop();
        }
        return res;
    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        typedef pair<int, int> PII;
        unordered_map<int, int> mp;
        for(auto num: nums)  mp[num] ++ ;
        priority_queue<PII> pq;
        for(auto item: mp){
            PII t(-item.second, item.first);
            pq.push(t);
            if(pq.size() > k) pq.pop();
        }
        vector<int> res(k);
        for(int i = k - 1; i >= 0; i --){
            res[i] = pq.top().second;
            pq.pop();
        }
        return res;
    }
};

class Solution {
public:
    struct node{
        int x, y;
        friend bool operator < (node a, node b){
            return a.y > b.y;                               //y小的优先
        }
    };
       
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        for(auto num: nums)  mp[num] ++ ;
        vector<node> pq;
        for(auto item: mp){
            node t;
            t.x = item.first;
            t.y = item.second;
            pq.push_back(t);
        }
        sort(pq.begin(),pq.end());
        vector<int> res(k);
        for(int i = 0; i < k; i ++){
            res[i] = pq[i].x;
        }
        return res;
    }
};

 

42. 接雨水 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {//记录当前列最左边高度和最右边高度，取他们之间较小的那个，与当前列高度作差就是当前列的雨水
public://第一和最后不接水
    int trap(vector<int>& height) {//化整为零，不要想着一次性求解每一步大块面积，一数列一数列随着i的遍历来。不要一会按行计算一会按列计算，稀里糊涂。一直按行计算也行。
        int sum = 0;
        vector<int>left(height.size(),height[0]);vector<int>right(height.size(),height[height.size()-1]);
        for(int i=1;i<height.size()-1;i++){
            left[i] = max(left[i-1],height[i]);
        }
        for(int i=height.size()-2;i>=0;i--){
            right[i] = max(right[i+1],height[i]);
        }
        for(int i=1;i<height.size()-1;i++){
            sum+=max(0,min(left[i],right[i])-height[i]);
        }
        return sum;

    }
};