逆波兰计算器（一）—— 中缀表达式转后缀表达式

我们将使用栈的知识来完成一个逆波兰计算器功能

中缀表达式是一个通用的算术或逻辑公式表示方法，是人们常用的算术表示方法，如 (3+4)×5-6

后缀表达式(逆波兰表达式) 运算符位于操作数之后，在计算机看来是比较简单易懂的结构，适合计算机运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式。

例如 (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

转换思路分析：

1.具体步骤如下：

1. 初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；
2. 从左至右扫描中缀表达式；
3. 遇到操作数时，将其压入 s2；
4. 遇到运算符时，比较其与 s1 栈顶运算符的优先级：
   1.如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
   2.否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
   3.否则，若优先级比栈顶运算符的低，将 s1 栈顶的运算符弹出并压入到 s2 中；再次转到(4.1步骤)与 s1 中新的栈顶运算符相比较；
5. 遇到括号时：
   (1) 如果是左括号“(”，则直接压入 s1
   (2) 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
6. 重复步骤 2 至 5，直到表达式的最右边
7. 将 s1 中剩余的运算符依次弹出并压入 s2
8. 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

2.举例说明

将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：

因此结果为 1 2 3 + 4 × + 5 -

代码实现中缀表达式转为后缀表达式

注释详细标注

1.将中缀表达式转成对应的 List

因为在扫描中缀表达式时，针对一个List来操作要比对String操作更方便，所以我们首先将中缀表达式转成对应的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;
}

2.编写一个类 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("不存在该运算符");
                break;
        }
        return result;
    }
}

3.将得到的中缀表达式对应的 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){
            if(item.matches("\\d+")){// 如果是一个数 加入s2
                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(); // 将 ( 弹出，消除小括号
            }else  {  // 遇到运算符
                //当 item 的优先级小于等于 s1 栈顶运算符, 将 s1 栈顶的运算符弹出并加入到 s2 中，
                // 再次转到(4.1)与 s1 中新的栈顶运算符相比较
                // 方法Operation.getValue()获取优先级
                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 void main(String[] args) {
        String s = "1+((2+3)*4)-5";
        List<String> ls = toInfixExpressionList(s);
        System.out.println("中缀表达式："+ls);
        List<String> s2 = parseSuffixExpreesionList(ls);
        System.out.println("后缀表达式："+s2);
    }

运行结果：

本文是我自学韩老师Java数据结构做的一些笔记，供我自己复习用，同时分享给大家，有不懂的地方欢迎在评论区讨论！