155. 最小栈

方法一：辅助栈（同步）

这个方法是最基础的方法，即利用一个辅助栈同步压栈，用以保存最小元素

class MinStack
{
private:
    stack<int> stk;
    stack<int> minStk;
public:
    MinStack() {}

    void push(int val)
    {
        if (stk.empty() == true)
        {
            minStk.push(val);
        }
        else if (val < minStk.top())
        {
            minStk.push(val);
        }
        else
        {
            minStk.push(minStk.top());
        }

        stk.push(val);
    }

    void pop()
    {
        stk.pop();
        minStk.pop();
    }

    int top()
    {
        return stk.top();
    }

    int getMin()
    {
        return minStk.top();
    }
};

方法二：辅助栈（不同步）

将方法一稍做修改就可以得到方法二，即辅助栈与主栈不同步，只有新来的数小于等于（注意等于也算哦！）辅助栈栈顶元素时，辅助栈才压栈

class MinStack
{
private:
    stack<int> stk;
    stack<int> minStk;
public:
    MinStack() {}

    void push(int val)
    {
        if (stk.empty() == true)
        {
            minStk.push(val);
        }
        else if (val <= minStk.top())
        {
            minStk.push(val);
        }

        stk.push(val);
    }

    void pop()
    {
        if (stk.top() == minStk.top())
        {
            minStk.pop();
        }

        stk.pop();
    }

    int top()
    {
        return stk.top();
    }

    int getMin()
    {
        return minStk.top();
    }
};

方法三：利用STL中的pair容器

思路与方法一相同，不过是利用了pair容器，这样只用一个栈就可以了

class MinStack
{
    stack<pair<int, int>> s;
public:
    MinStack() {}

    void push(int val)
    {
        if (s.empty() == true)
        {
            s.push({ val,val });
        }
        else if (val < s.top().second)
        {
            s.push({ val,val });
        }
        else
        {
            s.push({ val,s.top().second });
        }
    }

    void pop() 
    {
        s.pop();
    }

    int top() 
    {
        return s.top().first;
    }

    int getMin() 
    {
        return s.top().second;
    }
};