Java实现中缀表达式转换成逆波兰表达式（后缀表达式）

实现基本步骤

1.  用数组接收输入的原始表达式。
2.  用两个栈来进行操作，一个栈用来存放运算符，另一个栈用来存放输出的逆波兰表达式。
3.  依次遍历原始表达式，再根据遍历的元素分别进行操作。
4.  如果遍历为数字，直接输出到逆波兰表达式栈中。
5.  如果遍历为“（”，入运算符栈里。
6.  如果遍历为“）”，则依次把运算符栈栈顶的运算符加入逆波兰表达式栈中，直到出现“（”，接着从栈中删除“（”，逆波兰表达式中不存在括号。
7.  如果遍历为除括号外的其他运算符（+，-，*，/）， 当其优先级高于除“（”以外的栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止，然后将其自身压入栈中（先出后入），弹出的运算符加入逆波兰表达式栈中。
8.  遍历原始表达式结束后，将运算符栈中的所有运算符出栈，依次入逆波兰表达式栈中。
9.   最后，依次遍历输出存放逆波兰表达式的数组，就得到了逆波兰表达式。

Java代码实现

import java.util.Scanner;

public class RPN {
    private char[] list;//存放自己输入的表达式(中缀表达式)
    private char[] sign;//存放运算符的栈
    private char[] rpnList;//存放逆波兰表达式的栈
    private int rpnTop,signTop;//指向栈顶的数组下标
    RPN(){
        rpnTop=signTop=0;//初始化下标
    }

    //控制台输入表达式
    public void push(){
        Scanner in=new Scanner(System.in);
        System.out.println("请输入表达式");
        String s=in.nextLine();
        s.replaceAll(" ", "");//去除空格
        list=s.toCharArray();//将输入的字符串转换成字符数组
        System.out.println("你输入的表达式是：");
        for(int i=0;i= 0; j--){
                        //判断运算符栈里的栈顶如果为左括号，或者栈为空，就不做操作退出循环
                        if(sign[j] == '('||signTop == 0){
                            break;
                        }
                        else{ //其他情况的运算符栈的栈顶元素优先级都不低于当前运算符，要执行出栈操作
                            //出栈，再入存放逆波兰表达式的栈里
                            rpnList[rpnTop] = sign[j];
                            signTop--;
                            rpnTop++;
                        }
                    }
                    //入栈
                    signTop++;
                    sign[signTop] =list[i];
                    break;
                //遍历到乘法或者除法，则检查栈顶元素优先级，如果其优先级不低于当前操作符（左括号除外），则弹出栈顶元素
                case '*':
                case '/':
                    for(int j = signTop; j >= 0; j--){
                        //运算符栈的栈顶元素除了这几种情况外，都不进行弹栈操作（加减的运算优先级比乘除低）
                        if(sign[j] == '('||sign[j] == '+'||sign[j] == '-'||signTop == 0){
                            break;
                        }
                        else{
                            //出栈，再入存放逆波兰表达式的栈里
                            rpnList[rpnTop] = sign[j];
                            signTop--;
                            rpnTop++;
                        }
                    }
                    //入栈
                    signTop++;
                    sign[signTop] = list[i];
                    break;
                //遍历到数字，直接入逆波兰表达式栈即可
                default:
                    rpnList[rpnTop] = list[i];
                    rpnTop++;
            }
        }
        //遍历完后，如果运算符栈里还存有运算符，依次出栈，再入逆波兰表达式栈里
        while(signTop>0){
            rpnList[rpnTop] = sign[signTop];
            signTop--;
            rpnTop++;
        }


    }

    //输出逆波兰表达式
    public void print(){
        System.out.println("输出的逆波兰表达式：");
        for(int i=0;i48&&rpnList[i]<58){
                a[top]=rpnList[i]-'0';
                top++;
            }
            if(rpnList[i]==43){
                float s=a[top-1]+a[top-2];
                top--;
                a[top-1]=s;
            }
            if(rpnList[i]==45){
                float s=a[top-2]-a[top-1];
                top--;
                a[top-1]=s;
            }
            if(rpnList[i]==42){
                float s=a[top-1]*a[top-2];
                top--;
                a[top-1]=s;

            }
            if(rpnList[i]==47){
                float s=a[top-2]/a[top-1];
                top--;
                a[top-1]=s;
            }
        }
        System.out.println("逆波兰表达式的值：");
        System.out.println(a[--top]);


    }

    public static void main(String[] args) {
        RPN rp=new RPN();
        rp.push();
        rp.rpn();
        rp.print();
        rp.count();
    }
}

运行结果