初识栈和队列

---

 目录

🥬栈

🥬队列

💧循环队列

🥬用栈实现队列

🥬用队列实现栈

🥬小结

---

🥬栈

🐬灵魂三问

1、什么是栈？--->从数据结构角度来看，栈就是一种数据结构，它的特点就是先进后出。
2、什么是Java虚拟机栈？
3、什么是栈帧？

此时JVM stack只是JVM当中的一块内存，该内存一般用来存放
例如:局部变量……
调用函数的时候，我们会为这个函数开辟一块内存， 叫做栈帧。在哪里开辟呢?---> JVM stack

这里主要介绍栈：

常见方法的使用：

栈怎么用？

🐬1、不可能的出栈顺序

如果一个堆栈的入栈顺序为ABCDE,那么不可能出栈的顺序为：D

• ABCDE

• DECBA

• EDCBA

• DCEAB

 那么以上出栈的不可能顺序用代码怎么实现呢？接下来再来看一个例题：

来源：力扣

解题思路：

 代码示例：

   public boolean validateStackSequences(int[] pushed, int[] popped) {
    Stack<Integer> stack=new Stack<>();
    int j=0;
    for(int i=0;i<pushed.length;i++){
        stack.push(pushed[i]);
        while(j<popped.length&&!stack.empty()&&stack.peek()==popped[j]){
          stack.pop();
          j++;
        }
    }
    return stack.empty();
    }

 🐬2、最小栈

来源：力扣

 解题思路：

 代码示例：

class MinStack {
    Stack<Integer> stack;
    Stack<Integer> minStack;

    public MinStack() {
        stack=new Stack<>();
        minStack=new Stack<>();
    }
    
    public void push(int val) {
      stack.push(val);
      if(minStack.isEmpty()){
          minStack.push(val);
      }else{
          int top=minStack.peek();
          if(val<=top){
              minStack.push(val);
          }
      }
    }
    
    public void pop() {
        int popval=stack.pop();
        if(!minStack.isEmpty()){
            int val=minStack.peek();
            if(val==popval){
                minStack.pop();
            }
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
      return  minStack.peek();
    }
}

🐬3、有效的括号

 解题思路：

 代码示例：

 public boolean isValid(String s) {
     //用出栈入栈来做
     Stack<Character> stack=new Stack<>();
     for(int i=0;i<s.length();i++){
         char ch=s.charAt(i);
         if(ch=='{'||ch=='('||ch=='['){
           stack.push(ch);
         }else{
             //如果遇到了右括号
             if(stack.empty()){
                 //右括号多
                 return false;
             }
           char top=stack.peek();
           if(top=='{' && ch=='}'||top=='(' && ch==')'||top=='[' && ch==']'){
               stack.pop();
           }else{//左右括号不匹配
             return false;
           }
         }
     }
     if(!stack.empty()){
         return false;//左括号多
     }
     return true;
    }

🥬队列

队列的特点是先进先出。

 Queue常见方法使用：

 Deque方法就很多了：（可以从队头出队和入队，也可以从队尾出队和入队）

对于LinkedList来说，他不仅可以当做普通的队列，也可以当做双端队列，也可以当做双向链表,也可以当做栈。所有可以说LinkedList功能非常强大。

💧循环队列

环形队列通常使用数组实现。

 通过一道题了解循环队列：

来源：力扣

 解题思路：

代码示例：

class MyCircularQueue {
    public int[] elem;
    public int Front;
    public int Rear;
    
    public MyCircularQueue(int k) {
        this.elem=new int[k+1];//牺牲最后一个位置不放
    }
    
    public boolean enQueue(int value) {
        if(isFull()) return false;
        elem[Rear]=value;
        Rear=(Rear+1)%elem.length;
        return true;
    }
    
    public boolean deQueue() {
        if(isEmpty()) return false;
        Front=(Front+1)%elem.length;
        return true;
    }
    
    public int Front() {
         if(isEmpty()){
             return -1;
         }
         return elem[Front];
    }
    
    public int Rear() {
       if(isEmpty()){
           return -1;
         }
         int index;
         if(Rear==0){
             index=elem.length-1;
         }else{
             index=Rear-1;
         }
         return elem[index];
    }
    
    public boolean isEmpty() {
        return Rear==Front;
    }
    
    public boolean isFull() {
        return Front==(Rear+1)%elem.length;
    }
}

🥬用栈实现队列

来源：力扣

 解题思路：

代码示例： 

class MyQueue {
   public Stack<Integer> stack1;
   public Stack<Integer> stack2;
  
   public MyQueue() {
      stack1=new Stack<>();
      stack2=new Stack<>();
    }
    
    public void push(int x) {
      stack1.push(x);//先把元素全部放入一个栈中
    }
    
    public int pop() {
        if(empty()) return-1;
        if(stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
        public int peek() {
        if(empty()) return-1;
        if(stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }

    
    public boolean empty() {
      return stack1.isEmpty()&&stack2.isEmpty();
  }
}

🥬用队列实现栈

来源：力扣

 解题思路：

 代码示例：

class MyStack {
    public Queue<Integer> qu1;
    public Queue<Integer> qu2;

    public MyStack() {
        qu1=new LinkedList<>();
        qu2=new LinkedList<>();
    }

    public void push(int x) {
        if(!qu1.isEmpty()){
            qu1.offer(x);
        }else if(!qu2.isEmpty()){
            qu2.offer(x);
        }else{
            qu1.offer(x);
        }
    }

    public int pop() {
        if(empty()) return -1;

        if(!qu1.isEmpty()) {
            int size = qu1.size();
            for(int i = 0; i < size-1;i++) {
                int val = qu1.poll();
                qu2.offer(val);
            }
            return qu1.poll();
        }

        if(!qu2.isEmpty()) {
            int size = qu2.size();
            for(int i = 0; i < size-1;i++) {
                int val = qu2.poll();
                qu1.offer(val);
            }
            return qu2.poll();
        }
        return -1;
    }

    public int top() {
        if(empty()) return -1;
        int val=-1;
        if(!qu1.isEmpty()){
            int size=qu1.size();
            for(int i=0;i<size;i++){
             val=qu1.poll();
             qu2.offer(val);
            }
            return val;
        }
        if(!qu2.isEmpty()){
            int size=qu2.size();
            for(int i=0;i<size;i++){
             val=qu2.poll();
             qu1.offer(val);
            }
                return val;
      }
      return -1;
    }

    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }
}

🥬小结

以上就是今天的内容了，有什么问题大家都可以在评论区留言✌✌✌