1. stack的介绍和使用

1.1 stack的介绍

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类

4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque

1.2 stack的使用

栈的方法，之前也进行过学习

实现最小栈

分析：最小栈1.必须有常规栈基本操作

2.提供或者栈中所有元素中最小值的操作0（1）

OJ练习

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {
        dataStack.push(val);
        if(minStack.empty()||val<=minStack.top())
        {
             minStack.push(val);
        }    
    }
    
    void pop() {
        
        if(dataStack.top()==minStack.top())
        {
            minStack.pop();
        }
        dataStack.pop();
    }
    
    int top() {
        return dataStack.top();
    }
    
    int getMin() {
        return minStack.top();
    }
    stack<int> dataStack;//存放元素
    stack<int> minStack;//存放最小值
};

逆波兰表达式求值

作用：让计算机非常简单的计算四则混合运算

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;
        for(auto& e:tokens)
        {
            //判断是数字还是运算符
            if(!(("+"==e)||("-"==e)||("*"==e)||("/"==e)))
            {
                //如果是数字直接入栈
                s.push(atoi(e.c_str()));
            }
            else
            {
                //e是符号
                int right=s.top();
                s.pop();
                int left=s.top();
                s.pop();

                switch(e[0])
                {
                    //看看是那个符号
                    case'+':
                        s.push(left+right);
                        break;
                    case'-':
                        s.push(left-right);
                        break;
                    case'*':
                        s.push(left*right);
                        break;
                    case'/':
                        s.push(left/right);
                        break;
                }
            }
        }
        return s.top();
    }
};

入栈出栈次序检测

#include <vector>
class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> s;
        size_t inidex=0,outidx=0;
        while(outidx<popV.size())
        {
            //栈是空或者栈顶元素与待出栈元素不相等时需要入栈
            while(s.empty()||s.top()!=popV[outidx])
            {
                //必须保证栈中还有元素
                if(inidex<pushV.size())
                {
                    s.push(pushV[inidex]);
                    inidex++;
                }
                else {
                    //还需要有元素入栈，但是pushV中已经没有元素了，所以肯定不匹配
                  return false;
                } 
            }
            s.pop();
            outidx++;    
        }  
        return true;
    }
};

2.stack的模拟实现

stack.h中

#pragma once
#include<iostream>
using namespace std;
#include<vector>

namespace zx
{
    //实现栈时候默认对vector进行了封装
    //container表示用来存储栈的那个容易
    template<class T,class Container= std::vector<T>>
    class stack
    {
    public:
        stack()
        {}

        void push(const T& val)
        {
            c.push_back(val);
        }

        void pop()
        {
            if (empty())
                return;

            c.pop_back();
        }

        T& top()
        {
            return c.back();
        }

        const T& top()const
        {
            return c.back();
        }

        size_t size()const
        {
            return c.size();
        }

        bool empty()const
        {
            return c.empty();
        }

    private:
        Container c;
    };
}

void TestMystack()
{
    zx::stack<int> s;
    s.push(1);
    s.push(8);
    s.push(6);
    s.push(99);
    s.push(55);
    s.push(15);

    cout << s.size() << endl;
    cout << s.top() << endl;
    
    s.pop();
    s.pop();
    cout << s.size() << endl;
    cout << s.top() << endl;
}

主函数中进行测试

#include<iostream>
using namespace std;
#include"Stack.h"

int main()
{
    void TestMystack();
    return 0;
}