前缀(波兰式)、中缀、后缀表达式(逆波兰式)

 

package com.zengwen.stack;

/**
 * 使用栈完成表达式的计算 思路
 * 1. 通过一个 index  值（索引），来遍历我们的表达式
 * 2. 如果我们发现是一个数字, 就直接入数栈
 * 3. 如果发现扫描到是一个符号,  就分如下情况
 *  3.1 如果发现当前的符号栈为 空，就直接入栈
 *  3.2 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
 * 4. 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
 * 5. 最后在数栈只有一个数字，就是表达式的结果
 */

public class Calculator {

    public static void main(String[] args) {
        String experssion = "30+2+3*7/8-2";
        //创建2个栈，数栈和符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        int index = 0; //用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';//保存每次扫描得到的char
        String keepNum = "";
        //开始扫描
        while (true){
            //依次得到expression的每一个字符
            ch = experssion.substring(index, index + 1).charAt(0);
            //判断ch是什么，然后做相应处理
            if (operStack.isOper(ch)){//如果是符号
                //判断当前的符号栈是否为空
                if (!operStack.isEmpty()){//如果不为空（符号栈有操作符）
                    //进行比较
                    //如果当前的操作符的优先级小于或者等于栈中的操作符
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())){
                        //从数栈中pop出2个数
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        //将栈中的操作符出栈
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //把运算结果入数栈
                        numStack.push(res);
                        //把当前操作符入符号栈
                        operStack.push(ch);
                    }else { //当前的操作符的优先级大于栈中的操作符
                        operStack.push(ch);
                    }
                }else {//如果为空直接入符号栈
                    operStack.push(ch);
                }
            }else{//如果是数，直接入数栈
//                numStack.push(Integer.parseInt(ch+""));
//                numStack.push(ch - 48);
                //1、当处理多位数时，不能发现是一个数就立即入栈。
                //2、在处理数，需要向expression的表达式的index后再看一位，如果是符号才入栈
                //3、定义一个字符串，用于拼接多位数

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

                //判断ch是否已经是expression的最后一位，就直接入栈
                if (index == experssion.length() - 1){
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈

                    if (operStack.isOper(experssion.substring(index+1,index+2).charAt(0))){ //如果后一位是操作符
                        //入栈
                        numStack.push(Integer.parseInt(keepNum));
                        //清空keepNum!!!
                        keepNum = "";
                    }
                }
            }
            //让index+1，并判断是否扫描到expression最后
            index++;
            if (index == experssion.length()){//表示扫描到最后时
                break;
            }
        }
        //扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运算
        while (true){
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
            if (operStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);
            numStack.push(res);//入栈
        }
        //将数栈的最后数pop出就是结果
        System.out.println("表达式"+experssion + "=" + numStack.pop() );
    }
}
//定义一个ArrayStack2表示栈
class ArrayStack2{

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

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

    //栈满
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty(){
        return top == -1;
    }

    //入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满~~");
            return;
        }
//        top++;
//        stack[top] = value;
        stack[++top] = value;
    }

    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空~~");
        }
//        int value = stack[top];
//        top--;
//        return value;
        return stack[top--];
    }

    //遍历栈[遍历时需要从栈顶开始显示数据]
    public void list(){
        if (isEmpty()){
            System.out.println("栈空~");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.println("stack[" + i + "]=" + stack[i]);
        }
    }
    //返回运算符的优先级，假定优先级使用数字表示，数字越大，优先级越高
    public int priority(int oper){
        if (oper == '*' || oper == '/'){//乘法除法优先级1
            return 1;
        }else if (oper == '+' || oper == '-'){
            return 0;
        }else{
            return -1;
        }
    }
    //判断是否是运算符
    public boolean isOper(char val){
        return val == '*' || val == '/' || val == '+' || val == '-';
    }

    //计算方法
    public int cal(int num1, int num2, int oper){
        int res = 0; // 用于存放计算的结果
        switch (oper){
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case  '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 /num1;
                break;
        }
        return res;
    }

    //返回当前栈的栈顶的值,不是真正的pop
    public int peek(){
        return stack[top];
    }
}

 

 

 

 

 

 

package com.zengwen.stack;

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

public class PolandNotation {

    public static void main(String[] args) {
//        (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - ,
//      为了方便，逆波兰表达式中数字和符号使用空格隔开
        //先定义一个逆波兰表达式
        String suffixExpression = "3 4 + 5 × 6 -";
        //思路
        //1. 先将逆波兰表达式装入到ArrayList中
        //2. 将ArrayList传递给一个方法（方法里面遍历ArrayList，配合栈完成计算）
        List<String> list = getListString(suffixExpression);
        System.out.println(calculate(list));

    }

    // 将一个逆波兰表达式依次将数据和运算符放入ArrayList中
    public static List<String> getListString(String suffixExpression){
        // 将suffixExpression 分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    //完成对逆波兰表达式的运算
    /**
     * 1)从左至右扫描(对list的遍历)，将3和4压入堆栈；
     * 2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
     * 3)将5入栈；
     * 4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
     * 5)将6入栈；
     * 6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果29
     */
    public static int calculate(List<String> ls){
        //创建一个栈，只需要一个数栈即可
        Stack<String> stack = new Stack<>();
        //遍历list
        for (String item : ls) {
            //这里使用正则表达式来取出数
            if (item.matches("\\d+")){//匹配的是多位数
                //入栈
                stack.push(item);
            }else{
                //pop出2个数并运算,再入栈
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;//存放结果的变量
                if (item.equals("+")){//如果是+运算
                    res = num1 + num2;
                }else if (item.equals("-")){//如果是-运算
                    res = num2 - num1;
                }else if (item.equals("*") || item.equals("×") ){//如果是*运算
                    res = num1 * num2;
                }else if (item.equals("/")){//如果是/运算
                    res = num2 / num1;
                }else {
                    throw new RuntimeException("运算符有误~~");
                }
                //把结果入栈
                stack.push(res + "");
            }
        }
        // 最后留在stack中的数据就是运算结果
        return Integer.parseInt(stack.pop());
    }
}

 5.8 中缀表达式转换为后缀表达式

 

1 + ( ( 2 + 3 ) × 4 ) - 5

出栈结果：

- 5 + x 4 + 3 2 1 逆序--> (逆波兰表达式) 1 2 3 + 4 x + 5 -

 

 

package com.zengwen.stack;

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

public class PolandNotation {

    public static void main(String[] args) {

        //完成中缀表达式转后缀表达式的功能
        //1.   (中缀表达式)1+((2+3)×4)-5  ==>>  (逆波兰表达式)123+4x+5-
        //2.   (中缀表达式)1+((2+3)×4)-5  ==>>  对应的List=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
        String expression = "1+((2+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList);
        //3.中缀表达式对应的List=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]  转成后缀表达式对应的List=[1, 2, 3, +, 4, *, +, 5, -]
        List<String> parseSuffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的List=" + parseSuffixExpressionList );
        int calculate = calculate(parseSuffixExpressionList);
        System.out.println(calculate);

    }
    //对应的list [1, +, (, (, 2, +, 3, ), ×, 4, ), -, 5]  转成后缀表达式对应的list[1, 2, 3, +, 4, x, +, 5, -]
    public static List<String> parseSuffixExpressionList(List<String> ls){
        //初始化2个栈
        Stack<String> s1 = new Stack<>();//符号栈
        //因为s2在整个转化中，没有pop操作，这里不用栈结构，直接使用List<String>方便
        List<String> s2 = new ArrayList<>();//存放中间结果的list2

        //遍历ls
        for (String item : ls) {
            //如果是一个数直接加入s2
            if (item.matches("\\d+")){//遇到操作数时，直接加入s2
                s2.add(item);
            }else if (item.equals("(")){//如果是左括号“(”，则直接压入s1
                s1.push(item);
            }else if (item.equals(")")){//如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());//弹出s1栈顶的运算符，并压入s2
                }
                s1.pop();//将“(”弹出s1，消除小括号
            }else{
                //若item的优先级小于等于栈顶运算符的优先级，，将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较；
                while (s1.size() != 0 && (Operaion.getValue(item) <= Operaion.getValue(s1.peek()))){
                    s2.add(s1.pop());
                }
                //需要将item压入栈
                s1.push(item);
            }
        }
        //扫描完毕 将s1中剩余的运算符依次弹出并压入s2
        while (s1.size() != 0){
            s2.add(s1.pop());
        }
        return s2;//直接按顺序输出
    }


    //将中缀表达式转成对应的list
    public static List<String> toInfixExpressionList(String s){
        //定义一个List，存放中缀表达式的内容
        List<String> ls = new ArrayList<>();
        int i = 0;//相当于一个指针，用于遍历s
        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置空
                while (i < s.length() && ((c=s.charAt(i)) >= 48) && ((c=s.charAt(i)) <= 57)){
                    str += c;//拼接
                    i++;//i需要后移
                }
                ls.add(str);
            }
        }while (i < s.length());
        return ls;
    }




    //完成对逆波兰表达式的运算
    /**
     * 1)从左至右扫描(对list的遍历)，将3和4压入堆栈；
     * 2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
     * 3)将5入栈；
     * 4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
     * 5)将6入栈；
     * 6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果29
     */

    public static int calculate(List<String> ls){
        //创建一个栈，只需要一个数栈即可
        Stack<String> stack = new Stack<>();
        //遍历list
        for (String item : ls) {
            //这里使用正则表达式来取出数
            if (item.matches("\\d+")){//匹配的是多位数
                //入栈
                stack.push(item);
            }else{
                //pop出2个数并运算,再入栈
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;//存放结果的变量
                if (item.equals("+")){//如果是+运算
                    res = num1 + num2;
                }else if (item.equals("-")){//如果是-运算
                    res = num2 - num1;
                }else if (item.equals("*") || item.equals("×") ){//如果是*运算
                    res = num1 * num2;
                }else if (item.equals("/")){//如果是/运算
                    res = num2 / num1;
                }else {
                    throw new RuntimeException("运算符有误~~");
                }
                //把结果入栈
                stack.push(res + "");
            }
        }
        // 最后留在stack中的数据就是运算结果
        return Integer.parseInt(stack.pop());
    }

}

//编写一个类Operation 可以返回一个运算符对应的优先级
class Operaion{
    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("不存在该运算符");
                break;
        }
        return result;
    }
}