LeetCode-剑指offer栈的题目

1.剑指offer-09 用2个栈实现队列

题目链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/

栈是先进后出，队列是先进先出的特点，画图走起来：

这道题还是比较简单的。
动图演示：

代码如下:

class CQueue {
public:
    CQueue() {
        //自定义类型会自动调用默认构造
    }    
    void appendTail(int value) {
     s1.push(value);
    }
    
    int deleteHead() 
    {
    //s2第1次为空
    if(s2.empty())
    {
        //将s1的元素入到s2中
        while(!s1.empty())
        {
            s2.push(s1.top());
            s1.pop();
        }
    }
   //s2不为空pop，先保存栈顶的人值再pop
    if(!s2.empty())
     {
          int tmp = s2.top();
          s2.pop();
          return tmp;     
     }  
     //s2第2次为空就返回-1     
    else
    {
        return -1;       
    }    
 }
 private:
 stack<int> s1,s2;
};

时间复杂度：力扣官方给的是插入删除都是O(1),空间复杂度是O(N)。

2.剑指offer-30 包含min函数的栈

题目链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof/

思路：

1.用1个变量来记录最小值

2.优化，再用1个栈来记录最小值

动图演示：

代码如下：

class MinStack {
public:
   stack<int> st;
    stack<int> minst;
    /** initialize your data structure here. */
    MinStack() {

    }
    
    void push(int x) {
        //minst为空或者minst的栈顶元素<=x入栈
        st.push(x);
        if(minst.empty() || minst.top() >= x)
        {
            minst.push(x);
        }
    }
    
    void pop() {
        if(st.top() == minst.top())
        {
            minst.pop();
        }
         st.pop();
    }
    
    int top() {
        return st.top();
    }
    
    int min() {
        return minst.top();
    }

 
};

时间复杂度：都是O(1),空间复杂度O(N)。

3.剑指offer-31 栈的压入、弹出序列

题目链接：https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/

思路：找规律，出栈的顺序有很多次，找规律不行。要用1个栈模拟压入和弹出。

当栈没有元素就是匹配的顺序。

动图演示：

代码如下：

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        stack<int> st;
        int i = 0,j = 0;
        while(i < pushed.size())
        {
            //现将pushed的数组入栈
            st.push(pushed[i]);
            ++i;
            //栈不为空,且pop数组和栈顶元素相等就出栈,继续往后走
            //和栈顶相比较
            while(!st.empty() &&  st.top() == popped[j])
            {                
                st.pop();
                j++;
            }
        }
    //  if(st.empty())
    //  {
    //      return true;
    //  }
    //  return false;
    return st.empty();
    }
};

时间复杂度：O(N)，每个元素最多出栈入栈1次
空间复杂度：O(N),辅助栈最多存储N个元素