算数表达式求值(中缀表达式转后缀表达式并求值)

中缀表达式转后缀表达式的规则：
1.遇到操作数：直接输出（添加到后缀表达式中）
2.栈为空时，遇到运算符，直接入栈
3.遇到左括号：将其入栈
4.遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
5.遇到其他运算符：加减乘除：弹出所有优先级大于或者等于该运算符的栈顶元素，然后将该运算符入栈(如果此时栈顶的运算符为"(",则将这个运算符也压入栈中)
6.最终将栈中的元素依次出栈，输出

具体代码实现：

第一步：中缀表达式转后缀表达式

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

 第二步：后缀表达式求值

在这里，我的程序没有使用上一步获取的转换后的字符串，而是继续接收用户额输入，如果使用上一步的结果，则程序会变得更简单一些

求值的步骤：

(1)设置一个栈，开始时，栈为空，然后从左到右扫描后缀表达式

(2)若遇操作数，则进栈；若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的 放到运算符左边，运算后的结果再进栈

(3)直到后缀表达式扫描完毕。此时，栈中仅有一个元素，即为运算的结果，弹出栈即可得到结果。

具体代码实现：

package data.struct.algorithm;

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

class Stackfix2 {
    private int maxSize;
    private int stackArr[];
    private int top;

    public Stackfix2(int maxSize) {
        this.maxSize = maxSize;
        stackArr = new int[maxSize];
        top = -1;
    }

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

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

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

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

    public boolean isFull() {
        return top == maxSize - 1;
    }
}

class Postfix {
    private Stackfix2 theStackfix2;
    private String input;

    public Postfix(String in) {
        input = in;
    }

    public int doCalculate() {
        int num1;
        int num2;
        int inresult;
        char ch;
        int j;
        theStackfix2 = new Stackfix2(20);
        for (j = 0; j < input.length(); j++) {
            ch = input.charAt(j);
            // 如果字符为整数，则进行类型强制转换，并压入栈中
            if (ch >= '0' && ch <= '9') {
                theStackfix2.push((int) (ch - '0'));
            } else {
                // 测试用例最最关键的位置，考虑计算过程中的操作数的位置
                // 先弹出栈的元素是第二个操作数，后弹出栈的是第一个操作数
                num2 = theStackfix2.pop();
                num1 = theStackfix2.pop();
                switch (ch) {
                case '+':
                    inresult = num1 + num2;
                    break;
                case '-':
                    inresult = num1 - num2;
                    break;
                case '*':
                    inresult = num1 * num2;
                    break;
                case '/':
                    inresult = num1 / num2;
                    break;
                default:
                    inresult = 0;
                    break;
                }
                theStackfix2.push(inresult);
            }
        }
        return theStackfix2.pop();
    }
}

public class PostfixValue {

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

        while (true) {
            System.out.println("Enter a Postfix:");
            System.out.flush();
            String input;
            int result;
            input = getString();
            Postfix parse = new Postfix(input);
            result = parse.doCalculate();
            System.out.println("Postfix求值的结果是：" + result);
        }
    }

    public static String getString() throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader bufr = new BufferedReader(isr);
        return bufr.readLine();
    }

}