初识先进后出的栈

✨hello，愿意点进来的小伙伴们，你们好呐！
✨ 🐻🐻系列专栏：【数据结构】
🐲🐲本篇内容：浅解数据结构中的栈
🐯🐯作者简介:一名现大二的三非编程小白

前言

在Java中，谈起栈，我们脑海里会浮现出数据结构的栈，虚拟机栈还有栈帧。现在先让我来简单介绍一下这三个“栈”的区别。
栈： 是一种先进后出的数据结构。
虚拟机栈： 是JVM的一块内存空间。
栈帧 ： 是在调用函数的过程中，在Java虚拟机栈上开辟的一块内存空间
今天我来介绍的就是数据结构中先进后出的栈。

栈的概念

栈：是一种特殊的线性表，它只允许在固定的一端进行插入元素与删除元素。在进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。

简单实现栈

Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安
全的。所以我们用顺序表来实现栈

创建Stack类

public class Stack_ {

    private int[] elem;
    private int usedSize;
    public static final int DEFAULT_SIZE = 10;

    public Stack_(){
        elem = new int[DEFAULT_SIZE];
    }
}

压栈 push（）

public int push(int val){
    //先判断是否满了写一个isFull() 方法
    if(isFull()){
        elem = Arrays.copyOf(elem,elem.length * 2);
    }
    return elem[usedSize++];          
}

判断栈是否满了 isFull

public boolean isFull(){
    return usedSize == elem.length;
}

出栈 pop()

public int pop(){
     //我们要先判断栈是否为空，是抛出异常
     if(empty()){
         throw new MyEmptyStackException("栈为空");
     }
     return elem[--usedSize];
 }
 
 public boolean empty(){
     return elem.length == 0;
 }

public class MyEmptyStackException extends RuntimeException{
    public MyEmptyStackException() {
    }

    public MyEmptyStackException(String e){
        super(e);
    }
}

查找栈顶元素

public int peek(){
    if(empty()){
        throw new MyEmptyStackException("栈为空"); 
    }             
    return elem[usedSize - 1];
}

我们已经将Stack中常用的方法实现了一遍，更加清晰的认识到底层是如何实现出栈与压栈的。

Stack应用

1. 对于一个链表来说，我们正常 情况下只能让它正序打印，然后想逆序打印可以用递归来实现。
我们在链表中存放 1 2 3 4 5 5个元素。

使用递归方法将元素逆序打印

我们可以看到递归可以很完美的将链表逆序打印出来，但是在面对要开辟栈帧太多的时候，就有可能出现栈溢出现象，我们也可以用栈来实现链表的逆序打印

public void printList2(ListNode head){
    Stack<ListNode> stack = new Stack<>();
    while(head != null){
        stack.push(head);
        head = head.next;
    }
    while(!stack.empty()){
        System.out.print(stack.pop());
    }
}

这样子也·可以顺利实现链表逆序打印

Stack OJ题

让我们用OJ题来更好的熟悉Stack的使用。

1.

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack();
        int len = s.length();
        for(int i = 0; i < len; i++){
            char ch = s.charAt(i);
            if(ch == '(' || ch == '[' || ch == '{'){
                stack.push(ch);
            }else{
                if(stack.empty()){
                    return false;
                }
                if(ch == ')' && stack.peek() == '(' || ch == ']' && stack.peek() == '[' || ch == '}' && stack.peek() == '{'){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }

        if(!stack.empty()){
            return false;
        }
        return true;
    }
}

思路：

1. 我们将字符串中的元素一个取出来，判断是否为 左括号，如果是就 压栈。
2. 如果不是 就判断栈中是否为 null ，如果为空，就说明该字符串不符合要求。
3. 如果不为null，就判断是否与栈顶元素为一对括号，如果不是就返回false。
4. 将字符串遍历完后，判断栈中是否为null，如果不为空，则返回 false。

2.

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
      Stack<Integer> stack = new Stack<>();
      int len1 = pushA.length;
      int j = 0;
      for(int i = 0; i < len1;i++){
        stack.push(pushA[i]);
        while(j < len1 && !stack.empty() && stack.peek() == popA[j]){
            stack.pop(); 
            j++;
        }
      }
      return stack.empty();
    }
}

3.

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack();
        int len = tokens.length;
        for(int i = 0; i < len;i++){
            if(isOpertion(tokens[i])){
                int num1 = stack.pop();
                int num2 = stack.pop();
                switch(tokens[i]){
                    case "+" : 
                        stack.push(num1 + num2);
                        break;
                    case "-" : 
                        stack.push(num2 - num1);
                        break;
                    case "*" : 
                        stack.push(num2 * num1);
                        break;
                    case "/" : 
                        stack.push(num2 / num1);
                        break;
                }
            }else{
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();
        
    }
    public boolean isOpertion(String s){
        if(s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")){
            return true;
        } 
        return false;
    }
}