棧的基本操作
1.pop 操作 彈出頂元素
2.top 或則 peek 操作 檢視頂元素
3.push 操作 進棧操作
4.size 操作

佇列基本操作（一端進，一端出）
1.push 操作在隊尾加入
2.pop 操作從隊頭彈出

圖的遍歷
深度優先遍歷（DFS） 棧實現
寬度優先遍歷 （BDF） 佇列實現

最值棧：定義棧的資料結構，實現一個能夠得到棧最小元素的Min 函式。

class Solution{
public:
    Stack<int> source_data,min_data;
    void push(int value){
        source_data.push(value
 
);
        if(min_data.empt()||min_data.top()>=value)
            min_data.push(value);
        else
            min_data.push(min_data.top());
    }
    void pop(){
        source_data.pop();
        min_data.pop();
    }
    int top(){
        return source_data.top();
    }
    int min(){
        return
 
 min_data.top();
    }
}

雙棧佇列：只用兩個棧實現佇列
思路：注意彈出時候，需要判斷彈出棧是否為空。輸入棧轉到彈出棧時候，需要一次性全部壓入。

class TwoStack {
public:
    stack<int> stack_push,stack_pop;
    vector<int> twoStack(vector<int> ope, int n) 
    {
        vector<int> res;
        int i;
        for(i=0;i<n;i++)
        {
            if
 
(ope[i]>0)
                push(ope[i]);
            if(ope[i]==0)
                res.push_back(pop());
            if(ope[i]<0)
                exit(-1);
        }
        return res;
    }
    void push(int value)
    {
        stack_push.push(value);
    }
    int pop()
    {
        if(stack_pop.empty())
            while(!stack_push.empty())
            {
                stack_pop.push(stack_push.top());
                stack_push.pop();
            }
            int res=stack_pop.top();
            stack_pop.pop();
            return res;
    }

};

棧的反轉：實現一個棧的逆序，只能用遞迴函式和棧本身的pop操作，不能申請額外的資料結構。

class StackReverse{
public :
    vector<int> reverseStack(vector<int> A,int n){
        stack<int> sta;
        int i;
        for(i = n-1;i>=0;i--)
            sta.push(A[i]);
        revStack(sta);
        vector<int> res;
        while(!sta.empty()){
            res.push_back(sta.top());
            sta.pop();
        }
        return res;
    }
    void revStack(stack<int> &A){
    //每次遞迴獲取棧底元素，並刪除了棧底元素，然後壓入操作。
        if(A.empty())
            return :
        itn res= Get(A);
        revStack(A);
        A.push(res);
    }
    int Get(Stack<int> &A){
    //移除棧底元素，並返回  傳遞一個不變的值，但是每一次傳遞時候都進行其他操作
        if(A.empty())
            exit(-1);
        int res1 = A.top();
        A.pop();
        if(A.empty())
            return res1;
        else{
            int res2 = Get(A);
            A.push(res1);
            return res2;
        }
    }
};

排序棧：按升序對棧進行排序，最多智慧使用一個額外的棧存放臨時資料。

class TwoStacks {
public:
    vector<int> twoStacksSort(vector<int> numbers){
        stack<int> sta;
        int i;
        for(i = n-1;i>=0;i--)
            sta.push(A[i]);
        StackSort(sta);
        ...
    }
    void StackSort(stack<int> &sta){
        stack<int> help;
        while(!sta.empty()){
            int res = sta.top();
            sta.pop();
            if(help.empty()||res<help.top())
                help.push(res);
            else{
                while(!help.empty()&& res>help.top()){
                    sta.push(help.top());
                    help.pop();
                }
                help.push(res);
            }
        }
        while(!help.empty()){
            sta.push(help.pop());
        }

    }
;