中缀表达式转化为后缀表达式的主要过程：

1：如果遇到数字，则直接输出；

2：如果遇到左括号，则将左括号放入栈中；

3：如果遇到右括号，则将栈中的操作符输出，直到遇到左括号，将左括号弹出；

4：如果遇到操作符 c：

   i：若栈为空，则直接将 c 压入栈中，并结束步骤4；

   ii：若栈顶的操作符 t 优先级不小于 c，则将 t 出栈，重复 i 和 ii;

   iii：将 c 压入栈中；

5：依次输出栈中剩余的操作符。

下面是用Java实现将中缀表达式转化为后缀表达式的代码：

（注：程序中没有对输入表达式是否合法的判断！！！）

import java.util.Scanner;

/**
 * 将中缀表达式转化为后缀表达式
 */
public class Main {

    public static void main(String[] args) {
        System.out.println("中缀表达式 -> 后缀表达式");
        System.out.println("1：[a-b]表示数字；\n2：操作符包括：+，-，*，/，(，)。");

        while (true){
            //获取中缀表达式
            System.out.println("\n请输入您要转化的中缀表达式：");
            Scanner sc = new Scanner(System.in);
            String nifix = sc.nextLine();

            //输入“#”则退出
            if(nifix.equals("#")){
                return;
            }

            Process proc = new Process(nifix);
            System.out.println("中缀表达式：" + proc.getNifix());
            System.out.println("后缀表达式：" + proc.getPostfix());
        }
    }
}
/**
 * 将中缀表达式转化为后缀表达式的过程
 */
public class Process {

    private static final int MAX = 100;//表达式长度上限

    private int top;//栈顶指针
    private char[] stack;//栈
    private String postfix;//生成的后缀表达式
    private String nifix;//中缀表达式

    public Process(String nifix){
        this.nifix = nifix;
        top = -1;
        stack = new char[MAX];
        postfix = "";
        toPostfix();
    }

    public String getPostfix(){
        return postfix;
    }

    public String getNifix(){
        return nifix;
    }


    /**
     * 中缀表达式转化为后缀表达式的主要过程
     * @return
     */
    private String toPostfix(){
        //将中缀表达式转化为字符数组
        char[] chars = toCharList(nifix);

        //逐个读取
        for (char a : chars){
            read(a);
        }

        //读取栈中剩余的操作符
        while (top >= 0){
            postfix += stack[top--];
        }

        return postfix;
    }


    /**
     * 读取一个字符
     * @param a 读取的字符
     */
    private void read(char a){
        //如果遇到数字，则直接输出
        if(Judge.isDigit(a)){
            postfix += a;
            return;
        }

        //如果遇到左括号，则将左括号放入栈中
        if(a == '('){
            stack[++top] = a;
            return;
        }

        //如果遇到右括号，则将栈中的操作符输出，直到遇到左括号
        if(a == ')'){
            while (stack[top] != '('){
                postfix += stack[top--];
            }
            top--;//弹出‘（’
        }

        //如果遇到操作符，则按优先级进行入栈出栈操作
        if (Judge.isOperator(a)){
            operator(a);
        }
    }


    /**
     * 对操作符的入栈出栈操作
     * @param a 操作符
     */
    private void operator(char a){
        //若栈中为空，则将 a 放入栈中
        if (top == -1){
            stack[++top] = a;
            return;
        }

        //从栈中取出所有比a优先级高的操作符
        while (top >= 0 && stack[top] != '(' && Judge.priority(stack[top], a)){
            postfix += stack[top--];
        }

        //将a压入栈中
        stack[++top] = a;
    }


    /**
     * 将字符串转化为字符数组
     * @param str 字符串
     * @return 字符数组
     */
    private char[] toCharList(String str){
        char[] chars = new char[str.length()];
        for (int i=0 ; i<str.length() ; i++){
            chars[i] = str.charAt(i);
        }
        return chars;
    }
}
/**
 * 辅助类，用于各种判断
 */
public class Judge {

    /**
     * 比较a,b两个操作符的优先级
     * @param a 操作符
     * @param b 操作符
     * @return a=>b：true； a<b：false
     */
    public static boolean priority(char a, char b){
        if(a == '+' || a == '-'){
            if(b == '+' || b == '-'){
                return true;
            } else {
                return false;
            }
        } else {
            return true;
        }
    }


    /**
     * 判断字符 a 是不是数字,[a-z]表示数字
     * @param a 要判断的字符
     * @return
     */
    public static boolean isDigit(char a){
        return (a >= 'a' && a <= 'z');
    }


    /**
     * 判断字符 a 是否为操作符,（+，-，*，/）
     * @param a 要判断的字符
     * @return
     */
    public static boolean isOperator(char a){
        return (a == '+' || a == '-' || a == '*' || a == '/');
    }
}

执行结果：

Java后缀怎么求值_中缀表达式