前缀、中缀、后缀表达式

package com.ztesoft.zsmart.datastruct.stack;

import java.util.Stack;

public class InfixToPrefixExp {

    public static String ops = "()*/%+-";

    public static void main(String[] args) {
        System.out.println(infix2prefix("1+((2+3)*4)-5"));
    }

    /**
     * 中缀表达式转换为前缀表达式: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param exp
     * @return <br>
     */
    public static String infix2prefix(String exp) {
        StringBuffer result = new StringBuffer();
        // 把表达式入栈
        Stack<Character> expStack = exp2Stack(exp);

        // 初始化两个栈 一个操作符栈 一个中间结果栈
        Stack<String> s1 = new Stack<String>();
        Stack<String> s2 = new Stack<String>();
        // 从右向左扫描表达式
        while (!expStack.isEmpty()) {
            String expPart = read(expStack);
            // 判断是否为操作数
            if (!isOperator(expPart)) {
                s2.push(expPart);
            }
            else {
                opInStack(s1, s2, expPart);
            }

        }

        // 将s1中剩余操作符入s2
        while (!s1.isEmpty()) {
            s2.push(s1.pop());
        }

        // 处理结果
        while (!s2.isEmpty()) {
            result.append(s2.pop());
        }

        return result.toString();
    }

    /**
     * 操作符入栈: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param s1
     * @param s2
     * @param ch <br>
     */
    public static void opInStack(Stack<String> s1, Stack<String> s2, String ch) {
        // 遇到括号时：
        if ("(".equals(ch) || ")".equals(ch)) {
            // 如果是左括号直接入s1
            if (")".equals(ch)) {
                s1.push(ch);
            }
            else {
                // 如果是右括号 则依次弹出s1栈顶运算符，并压入s2 直到遇到右括号为至 此时一对括号废弃
                String ch1 = "";
                do {
                    ch1 = s1.pop();

                    if (")".equals(ch1)) {
                        break;
                    }
                    else {
                        s2.push(ch1);
                    }
                }
                while (true);
            }
        }
        else {
            // 如果s1为空或是栈顶为右括号) 则直接入操作数栈
            if (s1.isEmpty() || s1.lastElement().equals(")")) {
                s1.push(ch);
            }
            else {
                String s1Top = s1.lastElement();
                if (compareOpLevel(ch, s1Top)) { // 若优先级比栈顶运算符的较高或相等，也将运算符压入S1；
                    s1.push(ch);
                }
                else {
                    do {
                        s1Top = s1.pop();
                        s2.push(s1Top);

                        s1Top = s1.lastElement();
                        if (compareOpLevel(ch, s1Top)) { // 若优先级比栈顶运算符的较高或相等，也将运算符压入S1；
                            s1.push(ch);
                            break;
                        }
                    }
                    while (true);
                }
            }
        }
    }

    /**
     * 从栈中读取操作数 或是操作操作符 : <br>
     * 操作数由一个或是多个数据组成 操作符由一个字符组成
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param stack
     * @return <br>
     */
    public static String read(Stack<Character> stack) {
        StringBuffer sb = new StringBuffer();
        char ch;

        do {
            ch = stack.pop();
            sb.append(ch);
            if (!stack.isEmpty()) {
                char ch_next = stack.lastElement();
                if (isOperator(ch_next) || isOperator(ch)) {
                    break;
                }
            }
            else {
                break;
            }

        }
        while (!stack.isEmpty());
        return sb.toString();
    }

    /**
     * 判断当前字符是不是操作符: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param op
     * @return <br>
     */
    public static boolean isOperator(Character ch) {
        return ops.indexOf(ch.toString()) > -1;
    }

    /**
     * 判断当前字符是不是操作符: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param op
     * @return <br>
     */
    public static boolean isOperator(String exp) {
        return exp.length() == 1 && ops.indexOf(exp.toString()) > -1;
    }

    /**
     * 把表达式入栈: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param exp
     * @return <br>
     */
    public static Stack<Character> exp2Stack(String exp) {
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < exp.length(); i++) {
            stack.push(exp.charAt(i));
        }
        return stack;
    }

    /**
     * 判断运算符优先级 Description: <br>
     * 
     * @author wang.jun<br>
     * @taskId <br>
     * @param op1
     * @param op2
     * @return <br>
     */
    public static boolean compareOpLevel(String op1, String op2) {
        if (ops.indexOf(op1) < ops.indexOf(op2)) {
            return true;
        }
        return false;
    }

}