자바 판 접미사 표현 식 을 접미사 표현 식 으로 변환 하고 결 과 를 구하 십시오.

기초 지식
평소에 우리 가 말 하 는 산술 표현 식,예 를 들 어 9+(3-1)*3+10/2 는 접미사 표현 식 이지 만 컴퓨터 는 접미사 표현 식 의 값 을 계산 할 수 없습니다.이것 은 컴퓨터 가 좌우 괄호 와 연산 자 를 가 진 우선 순위 라 는 혼합 연산 을 할 수 없 기 때 문 입 니 다.접미사 표현 식(역 폴란드 식)의 사용 은 상기 문 제 를 해결 했다.상술 한 산술 표현 식 의 접미사 표현 식 은 9,3,1-3*+10,2/+입 니 다.
알고리즘 사상
어떻게 상술 한 접미사 표현 식 의 결 과 를 계산 합 니까?정 답:왼쪽 에서 오른쪽으로 상기 접미사 표현 식 을 스 캔 한 다음:1.숫자 를 만 나 스 택 에 들 어 갑 니 다.2.연산 자 를 만 나 스 택 꼭대기 에 있 는 두 요 소 를 스 택 에서 나 온 다음 에 결 과 를 계산 하고 계 산 된 결 과 를 스 택 에 들 어 갑 니 다.3.스 택 에 한 요소 만 있 을 때 까지 1,2 단 계 를 반복 합 니 다.
사례 코드
접미사 표현 식:9+(3-1)*3+10/2 를 예 로 들 면
접미사 표현 식 및 최종 결과 코드 구하 기:

import java.util.ArrayList;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** *             */
public class Operators {
    public ArrayList<String> getHouZuiBDS(String expression) {
        //        ：9+(3-1)*3+10/2        9 3 1 - 3 * + 10 2 / +
        //   ：      s，       ，             
        //                    ，    。           
        //                              
        Stack<String> expStack = new Stack<String>();
        ArrayList<String> newExp = new ArrayList<String>();
        //        ，                       
        String[] split = expression.split(" ");
        for (int i = 0; i < split.length; i++) {
            String s = split[i];
            if ("(".equals(s)) {
                expStack.push(s);
            } else if (")".equals(s)) {
                String pop;
                while (!expStack.isEmpty()) {
                    pop = expStack.pop();
                    if (pop.equals("(")) {
                        break;
                    } else {
                        newExp.add(pop);
                    }
                }
            } else if ("+".equals(s) || "-".equals(s) || "*".equals(s)
                    || "/".equals(s)) {
                if (expStack.isEmpty()) {
                    expStack.push(s);
                } else {
                    String top = expStack.peek();
                    if (comparePro(s, top)) {
                        //         s          top    ，s  
                        expStack.push(s);
                    } else {
                        //         s           top    ，  s          
                        while (!expStack.isEmpty()) {
                            String pop = expStack.peek();
                            if (!comparePro(s, pop)) {
                                newExp.add(expStack.pop());
                            } else {
                                break;
                            }
                        }
                        expStack.push(s);
                    }
                }
            } else {
                //    
                newExp.add(s);
            }
        }
        while (!expStack.isEmpty()) {
            newExp.add(expStack.pop());
        }
        return newExp;
    }

    /** *      ， inputOper       sTopOperator  false，    true * * @param inputOper *       * @param sTopOperator *       */
    public boolean comparePro(String inputOper, String sTopOperator) {
    //           ，          
        if ("(".equals(sTopOperator)) {
            return true;
        }
        //              “+” “-”，        “*” “/” ，          
        if (("*".equals(inputOper) || "/".equals(inputOper))
                && ("+".equals(sTopOperator) || "-".equals(sTopOperator))) {
            return true;
        }
        return false;
    }
/** *              */
    public int getResult(ArrayList<String> expression) {
        Stack<Integer> resStack = new Stack<Integer>();
        for (String str : expression) {
            if (str.matches("\\d+")) {
                resStack.push(Integer.valueOf(str));
            } else {
                if (resStack.isEmpty()) {
                    return -1;
                }
                //    ，         
                int tem1 = resStack.pop();
                int tem2 = resStack.pop();
                int temRes = 0;
                switch (str) {
                case "+":
                    temRes = tem2 + tem1;
                    break;

                case "-":
                    temRes = tem2 - tem1;
                    break;
                case "*":
                    temRes = tem2 * tem1;
                    break;
                case "/":
                    temRes = tem2 / tem1;
                    break;
                }
                resStack.push(temRes);
            }
        }
        if (resStack.size() == 1) {
            return resStack.pop();
        } else {
            return -1;
        }
    }
}

주 함수 코드:

package      ;

import java.util.ArrayList;

/** *       */
public class Compute {

    public static void main(String[] args) {
        Operators op = new Operators();
        String expression = "9 + ( 3 - 1 ) * 3 + 10 / 2";
        ArrayList<String> res = op.getHouZuiBDS(expression);
        System.out.print("     ：");
        for (String string : res) {
            System.out.print(string+" ");
        }
        int result = op.getResult(res);
        System.out.println();
        System.out.println("    ："+result);
    }
}

결과:
접미사 표현 식:9,3,1-3*+10,2/+계산 결과:20