使用堆栈思路 实现逆波兰表达式

package com;/** * 使用堆栈实现逆波兰表达式 */public class InverseClass {    private char[] list;//放置最开始输入的，被拆分之后的内容    private char[] sign;//放置运算符    private char[] rpnList;//放置逆波兰表达式    public void putint(String str) {        if (str.equals("") || str == null) {            return;        }       //获得输入内容后，将字符串内的空格都给消掉        str.replaceAll(" ", "");        //将输入的字符串转换成字符放在list数组中        list = new char[str.length()];        list = str.toCharArray();        System.out.println("原表达式" + str);        setRPN(list);    }    //读取list,转化为逆波兰表达式,将中缀表达式转化为后缀表达式    private void setRPN(char[] list) {        int length = list.length;        //创建指针        char x;        //初始化其他两个数组，长度限定        sign = new char[length + 1];        rpnList = new char[length + 1];        //指符号数组top        sign[0] = '#';        //在下面的运算符中，rpn没加一个，rpnlen将指向下一位，而sign指向的是当前sign的最高位        //指向sign最高位，运算符位        int signtop = 0;        //指向rpn最高位        int rpntop = 0;        for (int i = 0; i < length; i++) {            x = list[i];            switch (x) {                case '(':                    //直接放入符号数组                    sign[signtop] = '(';                    signtop++;                    break;                case ')':                    //匹配出栈                    while (sign[signtop] != '(') {                        //依次将括号内容转入到rpnList中                        rpnList[rpntop] = sign[signtop];                        //RPN加位                        rpntop++;                        //运算符号位减位                        signtop--;                    }                    //将‘（’设置为空                    signtop--;                    break;                //接下来是算数运算符，加减乘除，当后一个优先级不高于前一个优先级，不出                case '+':                case '-':                    //这时候符号数组有可能里面含有（                    for (int j = signtop; j >= 0; j--) {                        if (sign[j] == '(' || signtop == 0) {                            break;                        } else {                            //此时栈里面的 +-优先级比较低，进来的优先级没有原来栈里的优先级高，直接输出栈里的元素，                            //直接栈顶元素搞到rpnlist                            rpnList[rpntop] = sign[j];                            rpntop++;                            signtop--;                        }                    }                    //处理好了原来栈顶元素，现在的元素添加进去                    signtop++;                    sign[signtop] = x;                    break;                case '*':                case '/':                    for (int j = signtop; j >= 0; j--) {                        //运算符优先,*/的运算符优先于= -                        if (sign[j] == '(' || signtop == 0 || sign[j] == '+' || sign[j] == '-') {                            break;                        } else {                            //此时 +-优先级比较低，进来的优先级优先级高，直接把当前元素输到表达式                            //把现在栈顶元素拿出来                            rpnList[rpntop] = sign[j];                            rpntop++;                            signtop--;                        }                    }                    signtop++;                    sign[signtop] = x;                    break;                default:    //遇到非运算符   ,直接输出表达式                    rpnList[rpntop] = x;                    rpntop++;            }        }        //最终，处理符号数组中的元素,把符号栈里面的元素拿出来        while (signtop > 0) {            rpnList[rpntop] = sign[signtop];            signtop--;            rpntop++;        }        System.out.println(rpnList.length);        printResult();    }    private void printResult() {        System.out.println("生成的逆波兰表达式：");        for (int i = 0; i < rpnList.length; i++) {            System.out.print(rpnList[i] + " ");        }    }}

main方法调用：

public static void main(String[] args) {
// TODO Auto-generated method stub
InverseClass inverseClass=new InverseClass();
inverseClass.putint("((2+1)*(3-1))/(2-1)");
}

输出结果：