【数据结构】栈的模拟和使用理解

欧橘猫

已于 2022-11-30 06:07:09 修改

阅读量457

点赞数

分类专栏：数据结构文章标签：数据结构 java 算法

于 2022-11-26 02:41:43 首次发布

本文链接：https://blog.csdn.net/m0_66483195/article/details/127855487

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

学习目录

栈(Stack)

栈(Stack)

栈的概念

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

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶
出栈：栈的删除操作叫做出栈。出数据在栈顶
在这里插入图片描述
在集合框架中，Stack的继承实现关系如下：
从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表
不同的是Vector类，是线程安全的动态数组，但是性能较差 , 现在已经不是很常用了 , 可以说已经过时了

栈的使用

方法	解释
Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();//创建一个栈
        stack.push(1);//添加一个元素到栈中
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println("当前元素有:"+ stack.size());
        System.out.println(stack);

        int x = stack.pop();//取出栈顶的元素返回
        System.out.println(x);
        System.out.println("当前元素有:"+ stack.size());

        int n = stack.peek();//获取当前栈顶的元素
        System.out.println(n);

        if(stack.empty()){
            System.out.println("空栈！");
        }else{
            System.out.println("当前栈空间为："+stack.size());
        }
    }

栈相关的应用场景

. 改变元素的序列

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A： 1、4、3、2
B： 2、3、4、1
C： 3、1、4、2
D： 3、4、2、1

图解：
在这里插入图片描述

一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（）。
A：1、2、3、4、5、A、B、C、D、E
B： E、D、C、B、A、5、4、3、2、1
C： A、B、C、D、E、1、2、3、4、5
D： 5、4、3、2、1、E、D、C、B、A

图解：
在这里插入图片描述

栈的模拟实现

public class MyStack {
    public int[] elen;
    public int usedsize;

    public MyStack() {
        this.elen = new int[10];
    }

    //压栈
    public int push(int val){
        if(isFull()){
            // 扩容
            elen = Arrays.copyOf(elen,2*elen.length);
        }
        this.elen[usedsize] = val;
        usedsize++;
        return val;
    }
    // 判断数组的空间是否满了
    public boolean isFull(){
        return usedsize == elen.length;
    }
    
    // 弹出
    public int pop(){
        if(empty()){
            throw new MyEmptyStackException("栈为空！");
        }
        int n = elen[usedsize-1];
        usedsize--;
        return n;

        // 第二种方法  这种方法和上面比较简洁一点
        // return elen[--usedsize];
    }
    // 判断数组是否为空
    public boolean empty(){
        return usedsize == 0;
    }

   // 获取栈顶元素
    public int peet(){
        if(empty()){
            throw new MyEmptyStackException("栈为空！");
        }
        return elen[usedsize-1];
    }
}

中缀表达式转后缀表达式

基本概念
中缀表达式：
操作符以中缀形式位于运算数中间，日常通用的算术和逻辑公式表示方法，(例如：1+2 、 3*4)
后缀表达式：
又称逆波兰式，操作符以后缀形式位于两个运算数后，(例如：1+2 在转换成后缀表达形式就是1 2 +)
前缀表达式：
又称波兰式，操作符以前缀形式位于两个运算数前（如：3+2的前缀表达形式就是+ 3 2）

例如：
在这里插入图片描述
中缀转后缀表达式通常是应用在计算器上
👀👀👀
例如：

力扣链接: 逆波兰表达式求值

将后缀表达式：1 2 3 * + 4 5 * 6 + 7 * + 进行计算，求结果？
在这里插入图片描述

public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        //1.遍利 tokens 数组，判断当中的字符串的类型
        for(String x : tokens){
            //如果不是运算符的情况下
            if(!isOperations(x)){
                // Integer.parseInt() 是把字符串转换成整数
                stack.push(Integer.parseInt(x));// 压栈

            }else{
                int n2 = stack.pop();
                int n1 = stack.pop();
                switch(x) {
                    case "+":
                        stack.push(n1+n2);
                        break;
                     case "-":
                        stack.push(n1-n2);
                       break;
                    case "*":
                        stack.push(n1*n2);
                        break;
                    case "/":
                        stack.push(n1/n2);
                        break;
                }
            }
        }
        return stack.pop();
   }
    // 判断是否是运算符
    public boolean isOperations(String s){
        if(s.equals("+") ||s.equals("-") ||s.equals("*") ||s.equals("/") ){
            return true;
        }
        return false;
    }