算法面试通关40讲 - 栈/队列

20. 有效的括号

std::stack<T>的几个方法：

1. top：相当于back
2. pop：相当于pop_back
3. push: 相当于push_back

class Solution {
public:
    static char leftOf(char c) {
        switch (c) {
            case ')':
                return '(';
            case '}':
                return '{';
            case ']':
                return '[';
            default:
                break;
        }
        return '*';
    }
    bool isValid(string s) {
        stack<char> braces;
        for (char c: s) {
            switch (c) {
                case '(':
                case '[':
                case '{':
                    braces.push(c);
                    break;
                case ')':
                case ']':
                case '}':
                    if (braces.empty() || braces.top() != leftOf(c)) {
                        return false;
                    } else {
                        braces.pop();
                    }
                default:
                    break;
            }
        }
        return braces.empty();
    }
};

232. 用栈实现队列

双栈 颠倒栈元素顺序（类似将链表首节点后面的所有节点做一遍头插，参考：25 K 个一组翻转链表）

class MyQueue {
public:
    MyQueue() {}
    void push(int x) {
        in.push(x);
    }
    int pop() {
            dumpInToOut();
        int value = out.top();
        out.pop();
        return value;
    }
    int peek() {
            dumpInToOut();
        return out.top();
    }
    bool empty() {
        dumpInToOut();
        return out.empty();
    }
private:
    void dumpInToOut() {
        if (out.empty()) {
        while (!in.empty()) {
            out.push(in.top());
            in.pop();
        }}
    }
    stack<int> in;
    stack<int> out;
};

225. 用队列实现栈

队列无法像栈那样一次性颠倒，颠倒了以后也还是和原来顺序保持一致的；因此，队列实现栈需要对每个元素单独保证入队列的时候，下次第一个出队列。
std::queue<T>的几个方法：

1. front：相当于front
   btw. back：相当于back
2. pop：相当于pop_front
3. push: 相当于push_back

class MyStack {
   public:
    MyStack() {}
    void push(int x) {
        auto sz = values.size();
        values.push(x);
        while (sz != 0) {
            values.push(values.front());
            values.pop();
            --sz;
        }
    }
    int pop() {
        int value = values.front();
        values.pop();
        return value;
    }
    int top() {
        return values.front();
    }
    bool empty() {
        return values.empty();
    }
   private:
    queue<int> values;
};

703. 数据流中的第 K 大元素

优先队列

#include <queue>
std::priority_queue<T, std::vector<T>, std::greater<T>> pq;