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

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)");
}

输出结果：