《C++ Stack 与 Queue 完全使用指南：基础操作 + 经典场景 + 实战习题》

#include <stack>  // 必须包含头文件
using namespace std;

// 定义栈：默认存储int类型，底层依赖deque实现
stack<int> st;

// 可指定底层容器（如vector、list）
stack<int, vector<int>> st_v;  // 基于vector的栈
stack<int, list<int>> st_l;    // 基于list的栈

void test_stack()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.emplace(4);

	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

int main()
{
	test_stack();
}

#include <queue>  // 必须包含的头文件
using namespace std;

// 定义队列：默认底层依赖deque实现
queue<int> q;

// 可指定底层容器（如list，不建议用vector，因vector头删效率低）
queue<int, list<int>> q_l;  // 基于list的队列

void test_queue()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.emplace(4);

	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}

int main()
{
	//test_stack();
	test_queue();
}

class MinStack {
public:
    MinStack() {
        //可以啥都不写，甚至可以删掉
        //会去调这个自定义类型的默认构造
    }
    
    void push(int val) {
        _st.push(val);

        if(_minst.empty()||_minst.top()>=val)
            _minst.push(val);
    }
    
    void pop() {
        if(_minst.top()==_st.top())
            _minst.pop();

        _st.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _minst.top();
    }
private:
    stack<int> _st;
    stack<int> _minst;
};
/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pushV int整型vector 
     * @param popV int整型vector 
     * @return bool布尔型
     */
    bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        int pushi=0,popi=0;
        stack<int> st;

        while(pushi<pushV.size())
        {
            st.push(pushV[pushi]);

            while(!st.empty()&&st.top()==popV[popi])
            {
                st.pop();
                popi++;
            }
            pushi++;
        }

        return st.empty();
    }
};

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;

        for(auto& str:tokens)
        {
            if(str=="+"||str=="-"||str=="*"||str=="/")
            {
                //运算符
                int right=st.top();
                st.pop();
                int left=st.top();
                st.pop();
                switch(str[0])
                {
                    case '+':
                        st.push(left+right);
                        break;
                    case '-':
                        st.push(left-right);
                        break;
                    case '*':
                        st.push(left*right);
                        break;
                    case '/':
                        st.push(left/right);
                        break;
                }
            }
            else{
                //运算数
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> q;
        int levelSize=0;

        if(root)
        {
            q.push(root);
            levelSize=1;
        }

        vector<vector<int>> vv;
        while(!q.empty())
        {
            vector<int> v;
            //一层一层的出
            while(levelSize--)
            {
                TreeNode* front=q.front();
                q.pop();
                v.push_back(front->val);

                if(front->left)
                    q.push(front->left);
                
                if(front->right)
                    q.push(front->right);
            }

            vv.push_back(v);
            //现在的leveSize等于当前队列的size
            levelSize=q.size();
        }
        return vv;
    }
};