剑指offer专题2：队列和栈

• 用两个栈模拟队列

  class CQueue {
      stack<int> stack1;
      stack<int> stack2;
  public:
      CQueue() {
  
      }
      
      void appendTail(int value) {
          stack1.push(value);
      }
      
      int deleteHead() {
          int val=-1;
          if(!stack2.empty())
          {
              val = stack2.top();
              stack2.pop();
             
          }
          else if(!stack1.empty())
          {
              
              while(!stack1.empty())
              {
                  val = stack1.top();
                  stack1.pop();
                  stack2.push(val);
              }
              stack2.pop();
          }
          return val;
      }
  };
  

• 用队列实现栈

  • 两个队列实现栈

    //每次入队一个元素都需要将这个元素放在队头
    // 时间O(n),空间O(n)
    class MyStack {
        queue<int> Que1;
        queue<int> Que2;
    public:
        MyStack() {
    
        }
        
        void push(int x) {
            Que1.push(x);
            while(!Que2.empty())
            {
                Que1.push(Que2.front());
                Que2.pop();
            }
            swap(Que1,Que2);
        }
        
        int pop() {
            int val = Que2.front();
            Que2.pop();
            return val;
        }
        
        int top() {
            return Que2.front();
        }
        
        bool empty() {
            return Que2.empty();
        }
    };
    

  • 一个队列实现栈

    // 一个队列实现，每次都将元素置前面
    // 时间O(n)，空间O(1)
    class MyStack {
        queue<int> Que;
    public:
        MyStack() {
    
        }
        
        void push(int x) {
            int n = Que.size();
            Que.push(x);
            while(n--)
            {
                Que.push(Que.front());
                Que.pop();
            }
        }
        
        int pop() {
            int val = Que.front();
            Que.pop();
            return val;
        }
        
        int top() {
            return Que.front();
        }
        
        bool empty() {
            return Que.empty();
        }
    };
    

• 包含min函数的栈

  • 双栈模拟

    // 利用辅助栈，时间O(1),空间O(n)
    class MinStack {
    public:
        /** initialize your data structure here. */
        stack<int> stack1; //正常栈
        stack<int> stack2; //最小栈
      
        MinStack() {
          stack2.push(INT_MAX);
        }
        
        void push(int x) {
            stack1.push(x);
            stack2.push(std::min(stack2.top(),x));
        }
        
        void pop() {
            stack1.pop();
            stack2.pop();
        }
        
        int top() {
            return stack1.top();
        }
        
        int min() {
            return stack2.top();
        }
    };
    

• 栈的压入、弹出序列

  / 利用栈模拟栈入栈出的情况
  class Solution {
  public:
      stack<int> stk;
      bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
          if(pushed.size()==0) return true;
          int k = 0;
          for(int i=0;i<pushed.size();++i)
          {
              stk.push(pushed[i]);
              while(!stk.empty()&&stk.top()==popped[k])
              {
                  stk.pop();
                  k++;
              }
          }
          return stk.empty();// ? 为什么用k判断不行
      }
  };
  

• 最小栈最优解

  // 时间O(1),空间O(1)
  class MinStack {
      stack<int> stk;
      int min;
  public:
      MinStack() {
  
      }
  
      void push(int val) {
          if(stk.empty())
          {
              min = val;
              stk.push(0);
          }
          else
          {
              int diff = val - min;
              if(diff<0)
              {
                  min = val;
              }
              stk.push(diff);
          }
      }
  
      void pop() {
          int val = stk.top();
          stk.pop();
          if(val<0)
          {
              min = min -val;
          }
      }
  
      int top() {
          int val = stk.top();
  
          return val<0?min:min+val;
      }
  
      int getMin() {
          return min;
      }
  };