数据结构（day01）笔记

1.剑指 Offer 09. 用两个栈实现队列

题目解读：

     1：      ["CQueue","appendTail","deleteHead","deleteHead"]
     2：     [    [],           [3],                 [],                   []]
输出：[null,           null,                3,                  -1]

---

代表代码：

CQueue obj = new CQueue();   

obj.appendTail(3);

int param_2 = obj.deleteHead();  //param_2的值就是 3

int param_3 = obj.deleteHead();  //param_3的值就是 -1

思路：

要求 利用两个删实现队列的删除和添加功能 

添加

1.首先添加功能--》都是添加尾部，因此我们直接添加就可以

删除

2.首先我们要知道：栈的特点：是先进后出     队列的特点：是先进先出

 

   通俗点说就是 栈的删除是先删除尾元素   队列删除是先删除头元素

3.要求我们利用两个栈来表示队列    但是我们知道栈删除只能删除尾元素 

 

  如果要实现删除头元素 ---》其实可以转化为删除逆序的尾元素（其实想当与删除头）

 

代码实现

class CQueue {
    //定义两个栈 a和b
    Stack<Integer> a;
    Stack<Integer> b;
    public CQueue() {
      //无参构造 进行栈的初始化 
       a=new Stack<>();
       b=new Stack<>();
    }
    //在队尾进行插入元素
    public void appendTail(int value) {
       a.push(value);
    }
    //删除头元素
    public int deleteHead() {
      //先判断b是否为空  
      //如果不为空 说明栈a已经将其元素反序进入b栈中了 因此直接输出尾元素即可
      if(!b.empty() )return b.pop();  //输出尾元素 （栈特点：先进后出）
      if(a.empty()) return -1; //如果a为空 代表没有元素  则根据题解返回-1

      //都不成立的时候  将a的元素全部加入到b  这样b其实就是a的逆序  
       //也就是输出队列的头元素  ---》   其实就是b的尾元素 
      while(!a.empty()){
          b.push(a.pop());
      }
     //返回b的尾元素
      return b.pop();
    }
}

---

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

 

题目解读：

     实现min、push 及 pop top的时间复杂度都是 O(1)

---

min() : 返回栈中最小值（查看不删除这个元素）

push() : 向栈顶添加元素

pop() : 移除栈顶元素

top() ：返回栈顶元素（不删除）

主要难度：要求复杂度都为O(1),因此我们没有办法使用循环解题，因此我们要使用辅助栈来进行解决

A栈 ：正常存放元素

B栈：我们只要保证栈顶元素永远是栈的最小元素即可

思路：

push() : 向A栈顶添加元素 

            然后判断B栈是否为空  如果为空就将这个元素加入到B栈

            在判断如果B栈的栈顶元素大于或者等于当前添加的元素 ---》我们就将这个元素添加到栈顶（目的是保证B栈的栈顶元素永远是A栈中的              最小元素）   

 pop() : 移除A栈顶元素 

            然后判断一下A栈移除的栈顶元素是不是B栈的栈顶元素  如果是B栈也移除（主要是保证B栈的栈顶元素是A栈中的最小元素）--》也就是不能A栈中都没有这个元素了 B栈的栈顶还是这个元素     

min() : 返回栈中最小值（查看不删除这个元素）   直接返回B栈的栈顶元素即可

top() ：返回栈顶元素（不删除）   直接返回A栈的栈顶元素即可

 

代码

class MinStack {
    //定义两个栈
    Stack<Integer> A ,B;
    /** initialize your data structure here. */
    public MinStack() {
     //初始化栈
       A=new Stack<>();
       B=new Stack<>();
       
    }
    
    public void push(int x) {
       A.push(x);
       //如果B为空或栈顶元素小于当前元素的时候 将其添加到B栈中
       //保证栈B中存入的一定是A栈中的最小元素
      if(B.empty()||B.peek()>=x){
          B.push(x);
      }     
    }
    
    public void pop() {
        //删除A栈的栈顶元素
        Integer top=A.pop();
        //如果B栈中栈顶元素与A栈中要删除的一样就删除
        if(top.equals(B.peek())){
            B.pop();
        }
    }
    
    public int top() {
       return A.peek();
    }
    
    public int min() {
       return B.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.min();
 */

大体思路是参照力扣的Krahets    

---