算术表达式系列之中缀表达式转后缀表达式

package data.struct.algorithm;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

//定义栈，用于存放转换过程中的操作符
class StackFix {
    // 栈的大小
    private int maxSize;
    // 数组模拟栈
    private char stackArr[];
    // 栈顶指针
    private int top;

    // 构造函数初始化栈
    public StackFix(int s) {
        maxSize = s;
        stackArr = new char[maxSize];
        top = -1;
    }

    // 进栈
    public void push(char value) {
        stackArr[++top] = value;
    }

    // 出栈
    public char pop() {
        return stackArr[top--];
    }

    // 显示栈顶元素
    public char peek() {
        return stackArr[top];
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }
}

// 转换类
class InTranstoPost {
    private StackFix theStackFix;
    private String input;
    private String output = "";

    // 初始化
    public InTranstoPost(String in) {
        input = in;
        int stackSize = input.length();
        theStackFix = new StackFix(stackSize);
    }

    // 主要转换功能函数
    public String doTran() {
        for (int j = 0; j < input.length(); j++) {
            // 获取一个输入字符串的一个字符
            char ch = input.charAt(j);
            switch (ch) {

            case '+':
            case '-':
                // 如果字符为'+'或者'-',若栈空，则直接让该字符进栈，否则，弹出栈顶元素进行判断，参数1为运算符的优先级
                gotOper(ch, 1);
                break;
            case '*':
            case '/':
                // 如果字符为'*'或者'/',若栈空，则直接让该字符进栈，否则，弹出栈顶元素进行判断，参数2为运算符的优先级
                gotOper(ch, 2);
                break;
            case '(':
                // 如果字符为'(',则压入栈中
                theStackFix.push(ch);
                break;
            case ')':
                // 如果字符为')',则弹出栈顶元素，如果栈顶元素为'(',则结束循环，输出转换结果，否则依次弹出栈顶元素并输出，
                // 直到碰到'('
                gotRbracket(ch);
                break;
            default:
                // 字符为操作数，不入栈，直接输出
                output = output + ch;
                break;
            }
        }
        // 判断输入的字符串的每一个字符的循环结束，依次弹出栈中的元素，并输出
        while (!theStackFix.isEmpty()) {
            output = output + theStackFix.pop();
        }
        return output;
    }

    // 该函数用于字符为')'时的相应操作
    public void gotRbracket(char ch) {
        while (!theStackFix.isEmpty()) {
            char chx = theStackFix.pop();
            if (chx == '(') {
                break;
            } else {
                output = output + chx;
            }
        }
    }

    // 非')'字符的其他操作符的处理
    public void gotOper(char opThis, int prec1) {
        while (!theStackFix.isEmpty()) {
            char opTop = theStackFix.pop();
            if (opTop == '(') {
                theStackFix.push(opTop);
                break;
            } else {
                int prec2;
                if (opTop == '+' || opTop == '-') {
                    prec2 = 1;
                } else {
                    prec2 = 2;
                }
                if (prec2 < prec1) {
                    theStackFix.push(opTop);
                    break;
                } else {
                    output = output + opTop;
                }
            }
        }
        // 栈空，字符直接压入栈中
        theStackFix.push(opThis);
    }
}

// 主函数
public class InfixToPostFix {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {

        // 定义两个字符串，一个接收键盘输入，一个用于代表转换后的字符串
        String input, output;
        while (true) {
            System.out.println("Enter a InFix:");
            System.out.flush();
            // getString()函数，从键盘获取输入的中缀表达式字符串
            input = getString();
            // 输入的字符串为空，结束判断
            if (input.equals("")) {
                break;
            }
            // 进行转换
            InTranstoPost tran = new InTranstoPost(input);
            output = tran.doTran();
            System.out.println("Thr Postfix is " + output);
        }
    }

    // 键盘获取输入的方式，常用做法
    public static String getString() throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader bufr = new BufferedReader(isr);
        String s = bufr.readLine();
        return s;
    }
}