数据结构与算法之栈的实现及逆波兰计算器简易版

数据结构与算法之栈的实现及逆波兰计算器简易版

1. 栈的介绍
   （1) 栈的英文为(stack)
   （2) 栈是一个先入后出(FILO-First In Last Out)的有序列表。
   （3) 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
   （4) 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
   （5) 图解方式说明出栈(pop)和入栈(push)的概念
   
2. 栈的应用场景
   （1) 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
   （2) 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
   （3) 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
   （4) 二叉树的遍历。
   （5) 图形的深度优先(depth 一 first)搜索法。
3. 数组模拟栈
   （1）思路
   
   （2）代码实现

package com.datastrucate.stack;

import java.util.Scanner;


/**
 * ClassName:ArrayStackDemo
 * Package:com.datastrucate.stack
 * Description:
 *
 * @Date:2021/5/11 16:18
 * @Author:hm
 */



public class ArrayStackDemo {



    public static void main(String[] args) { //测试一下 ArrayStack 是否正确
        // 先创建一个 ArrayStack 对象->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";

        boolean loop = true; //控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while(loop) {

            System.out.println("show: 表示显示栈");

            System.out.println("exit: 退出程序");


            System.out.println("push:  表示添加数据到栈(入栈)");

            System.out.println("pop: 表示从栈取出数据(出栈)");
            System.out.println("请输入你的选择");

            key = scanner.next(); switch (key) {

                case "show":
                    stack.list();
                    break;

                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);

                    break;
                 case "pop":

                    try {

                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);

                    } catch (Exception e) {

                        //	TODO: handle exception
                        System.out.println(e.getMessage());

                    }

                    break;
                case "exit":

                    scanner.close();
                    loop = false; break;


                default:

                    break;

            }

        }

        System.out.println("程序退出~~~");

    }



}



    //定义一个 ArrayStack 表示栈
class ArrayStack {

    private int maxSize; // 栈的大小
    private int[] stack; // 数组，数组模拟栈，数据就放在该数组
    private int top = -1;// top 表示栈顶，初始化为-1

    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];

    }


    //栈满
    public boolean isFull() {

        return top == maxSize - 1;

    }


    //栈空
    public boolean isEmpty() {

        return top == -1;
    }

    //入栈-push
    public void push(int value) {
        //先判断栈是否满
        if(isFull()) {

            System.out.println("栈满");
            return;

        }

        top++;

        stack[top] = value;
    }

    //出栈-pop, 将栈顶的数据返回
    public int pop() {

        //先判断栈是否空
        if(isEmpty()) {

            //抛出异常
            throw new RuntimeException("栈空，没有数据~");

        }

        int value = stack[top];
        top--;
        return value;

    }

    //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if(isEmpty()) {

            System.out.println("栈空，没有数据~~"); return;

         }

        //需要从栈顶开始显示数据
        for(int i = top; i >= 0 ; i--) {

            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }

    }

 }

4. 栈实现综合计算器（中缀表达式）
   （1）问题描述
   使用栈来实现综合计算器
   
   （2）思路
   
   （3）代码实现
   先实现一位数的运算，在扩展到多位数的运算

package com.datastrucate.stack;

import java.util.Stack;

/**
 * ClassName:Calculator
 * Package:com.datastrucate.stack
 * Description:
 *
 * @Date:2021/5/11 21:49
 * @Author:hm
 */
public class Calculator {


    public static void main(String[] args) {

        //根据前面老师思路，完成表达式的运算

        String expression = "12+2*3-11"; // 7//如何处理多位数的问题？
        //String expression = "5+2*3-3";//8
        //创建两个栈，数栈，一个符号栈
        Stack<Integer> numStack = new Stack<Integer>();
        Stack<Character> operStack = new Stack<Character>();



        int index = 0;//记录运算表达式的下标，用于判断是否入栈结束
        int num1 = 0;//第一个操作数
        int num2 = 0;//第二个操作数
        int oper = 0;//操作符
        int res = 0;//运算结果
        char ch = ' ';//保存每次扫描的字符内容
        String  keepNum = "";//用于拼接多位数

        //循环express表达式
        while(true){

            ch = expression.substring(index,index+1).charAt(0);
            //判断ch的内容
            if(isOper(ch)){//ch是操作符
                //判断操作符栈是否为空
                if(!operStack.empty()){//不为空
                    //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符就需要从数栈中 pop 出两个数,

                    //在从符号栈中 pop 出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if (hasPriority(ch) <= hasPriority(operStack.peek())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();

                        res = calculate(num1, num2, oper); //把运算的结果如数栈
                        numStack.push(res); //然后将当前的操作符入符号栈
                        operStack.push(ch);

                    }else{//优先级大于栈内的则入栈
                        operStack.push(ch);
                    }
                }else{//操作栈为空，入栈

                    operStack.push(ch);
                }
            }else{//为数字

                //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                // 2. 在处理数，需要向 expression 的表达式的 index 后再看一位,如果是数就进行扫描，如果是符号才入栈

                //3. 因此我们需要定义一个变量 字符串，用于拼接

                keepNum += ch;  // 处理多位数

                //如果 ch 已经是 expression 的最后一位，就直接入栈
                if (index == expression.length()-1) {

                    numStack.push(Integer.parseInt(keepNum));

                }else{
                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    // 注意是看后一位，不是index++;
                   if (isOper(expression.substring(index+1,index+2).charAt(0))) { //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"

                       numStack.push(Integer.parseInt(keepNum));

                       //注意keepNum 清空
                       keepNum = "";
                   }

                }

            }
            index++;//下标后移，并判断是否到结尾
            if (index >= expression.length()){

                break;//结束循环
            }
        }

        //当表达式扫描完毕，就顺序的从 数栈和符号栈中 pop 出相应的数和符号，并运行
        while(true){

            //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
            if(operStack.isEmpty()) {
                break;
            }

            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();

            res = calculate(num1, num2, oper);
            numStack.push(res);//入栈

        }

        //将数栈的最后数，pop 出，就是结果
        int result = numStack.pop();

        System.out.printf("表达式 %s = %d", expression, result);




    }

    //计算
    private static int calculate(int num1, int num2, int oper) {

        int res = 0; // res 用于存放计算的结果
        switch (oper) {

            case '+':

                res = num1 + num2;
                break;

            case '-':

                res = num2 - num1;// 注意顺序
                break;

            case '*':

                res = num1 * num2;
                break;

            case '/':

                res = num2 / num1;
                break;

            default:

                break;

         }

        return res;

    }

    //判断操作符优先级
    private static int hasPriority(int oper) {
        //数字越大，则优先级就越高. public int priority(int oper) {

        if(oper == '*' || oper == '/'){

            return 1;

        } else if (oper == '+' || oper == '-') {

            return 0;

        } else {

            return -1; //  假定目前的表达式只有 +, - , * , /

        }


    }


    //判断字符是否为操作符
    private static boolean isOper(char ch) {

        return ch == '+' | ch == '-'| ch=='*' | ch == '/';
    }

}

5. 逆波兰计算器的具体实现（中缀转后缀）
   我们完成一个逆波兰计算器，要求完成如下任务:
   输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果
   
   （1）大体思路
   第一步：将中缀表达式转存为List数组，方便遍历，不需要声明下标变量
   第二步：将中缀表达式list数组变成后缀表达式list数组
   第三步：后缀表达式实现进行计算实现逆波兰计算器
   （2）具体实现思路
   第一步实现：
   ① 循环中缀表达式的每一个字符，判断是操作数还是操作符
   ② 如果是操作符，则加入到list数组中，指针后移
   ③ 如果是数字，需要考虑多位数，则循环拼接数字，放入list数组
   第二步实现：
   （1）初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；
   （2）从左至右扫描中缀表达式；
   （3）遇到操作数时，将其压 s2；
   （4）遇到运算符时，比较其与 s1 栈顶运算符的优先级：
   ① 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
   ② 否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
   ③ 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到(4-1)与 s1 中新的栈顶运算符相比较；
   （5）遇到括号时：
   ① 如果是左括号“(”，则直接压入 s1
   ② 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
   （6）重复步骤 2 至 5，直到表达式的最右边
   （7) 将 s1 中剩余的运算符依次弹出并压入 s2
   （8) 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
   第三步：遍历后缀表达式list数组，若为数字则入栈，若为操作符，则pop出两个数进行计算
   （3）代码实现

package com.datastrucate.stack;

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

/**
 * ClassName:PolandNotation 逆波兰计算器（中缀转后缀）
 * Package:com.datastrucate.stack
 * Description:
 *
 * @Date:2021/5/12 15:50
 * @Author:hm
 */

public class PolandNotation {

    public static void main(String[] args) {


        //完成将一个中缀表达式转成后缀表达式的功能
        //说明
        //1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
        //2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
        //   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
        //   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]

        String expression = "1+((2+3)*4)-5";//注意表达式
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
        System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–]

        System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
    }

    //第一步：将 中缀表达式转成对应的List
    //  s="1+((2+3)×4)-5";
    public static List<String> toInfixExpressionList(String s) {
        //定义一个List,存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0; //这时是一个指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c
        do {
            //如果c是一个非数字，我需要加入到ls
            if((c=s.charAt(i)) < 48 ||  (c=s.charAt(i)) > 57) {
                ls.add("" + c);
                i++; //i需要后移
            } else { //如果是一个数，需要考虑多位数
                str = ""; //先将str 置成"" '0'[48]->'9'[57]
                while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        }while(i < s.length());
        return ls;//返回
    }

    //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //第二步：将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpreesionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<String>(); // 符号栈
        //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
        //Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
        List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2

        //遍历ls
        for(String item: ls) {
            //如果是一个数，加入s2
            if(item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while(!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//!!! 将 ( 弹出 s1栈， 消除小括号
            } else {
                //当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
                //问题：我们缺少一个比较优先级高低的方法
                while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) {
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }

        //将s1中剩余的运算符依次弹出并加入s2
        while(s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List

    }

    //第三步：完成对逆波兰表达式的运算
    public static int calculate(List<String> ls) {
        // 创建给栈, 只需要一个栈即可
        Stack<String> stack = new Stack<String>();
        // 遍历 ls
        for (String item : ls) {
            // 这里使用正则表达式来取出数
            if (item.matches("\\d+")) { // 匹配的是多位数
                // 入栈
                stack.push(item);
            } else {
                // pop出两个数，并运算， 再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num1 - num2;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把res 入栈
                stack.push("" + res);
            }

        }
        //最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }

}

//编写一个类 Operation 可以返回一个运算符 对应的优先级
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //写一个方法，返回对应的优先级数字
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符" + operation);
                break;
        }
        return result;
    }

}