MyDC总结

需要补全的代码如下

public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);
        while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator
            if () {
                //从栈中弹出操作数2

                //从栈中弹出操作数1

                //根据运算符和两个操作数调用evalSingleOp计算result;

                //计算result入栈;

            } else//如果是操作数
            //操作数入栈;

        }

        return result;
    }

思路

• 如果是运算符，调用isOperator

这是isOperator：

private boolean isOperator(String token) {
        return (token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/"));
    }

这个函数boolean 型，参数可以直接传字符串，所以在if() 中填入 isOperator(token)即可。

• 从栈中弹出操作数2

弹栈使用stack.pop()，所以填入op2 = stackpop()。

• 从栈中弹出操作数1

方法同上。

• 根据运算符和两个操作数调用evalSingleOp计算result

首先看下evalSingleOp以确定传入的参数

private int evalSingleOp(char operation, int op1, int op2)

那么，由上可以看出，需要传入char型运算符、int型操作数1、int型操作数2。operation就是运算符，需要传token，但是token是字符串，所以使用string.charAt(0)，把token转换成token.charAt(0)。至于op1、op2本身就是int型。

综上得出，需要填入

result=evalSingleOp(token.charAt(0), op1, op2);

• 计算result入栈

stack.push(result);

• 如果是操作数，操作数入栈

这里只能让int型入栈，但是输入的token 是字符串，所以必须要使用Integer.parseInt(string) 转化成int型。

故填入

stack.push(Integer.parseInt(token));

完整代码

• [git链接](

需要补全的代码如下

public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);
        while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator
            if () {
                //从栈中弹出操作数2

                //从栈中弹出操作数1

                //根据运算符和两个操作数调用evalSingleOp计算result;

                //计算result入栈;

            } else//如果是操作数
            //操作数入栈;

        }

        return result;
    }

思路

• 如果是运算符，调用isOperator

这是isOperator：

private boolean isOperator(String token) {
        return (token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/"));
    }

这个函数boolean 型，参数可以直接传字符串，所以在if() 中填入 isOperator(token)即可。

• 从栈中弹出操作数2

弹栈使用stack.pop()，所以填入op2 = stackpop()。

• 从栈中弹出操作数1

方法同上。

• 根据运算符和两个操作数调用evalSingleOp计算result

首先看下evalSingleOp以确定传入的参数

private int evalSingleOp(char operation, int op1, int op2)

那么，由上可以看出，需要传入char型运算符、int型操作数1、int型操作数2。operation就是运算符，需要传token，但是token是字符串，所以使用string.charAt(0)，把token转换成token.charAt(0)。至于op1、op2本身就是int型。

综上得出，需要填入

result=evalSingleOp(token.charAt(0), op1, op2);

• 计算result入栈

stack.push(result);

• 如果是操作数，操作数入栈

这里只能让int型入栈，但是输入的token 是字符串，所以必须要使用Integer.parseInt(string) 转化成int型。

故填入

stack.push(Integer.parseInt(token));

完整代码

• git链接

• MyDC

/**
 * Created by radish608 on 17-5-3.
 */

import java.util.StringTokenizer;
import java.util.Stack;

public class MyDC {
    /**
     * constant for addition symbol
     */
    private final char ADD = '+';
    /**
     * constant for subtraction symbol
     */
    private final char SUBTRACT = '-';
    /**
     * constant for multiplication symbol
     */
    private final char MULTIPLY = '*';
    /**
     * constant for division symbol
     */
    private final char DIVIDE = '/';
    /**
     * the stack
     */
    private Stack<Integer> stack;

    public MyDC() {
        stack = new Stack<Integer>();
    }

    public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);
        while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator
            if (isOperator(token)) {
                //从栈中弹出操作数2
                op2 = stack.pop();
                //从栈中弹出操作数1
                op1 = stack.pop();
                //根据运算符和两个操作数调用evalSingleOp计算result;
                result=evalSingleOp(token.charAt(0), op1, op2);
                //计算result入栈;
                stack.push(result);
            } else//如果是操作数
            //操作数入栈;
            stack.push(Integer.parseInt(token));
        }

        return result;
    }

    private boolean isOperator(String token) {
        return (token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/"));
    }

    private int evalSingleOp(char operation, int op1, int op2) {
        int result = 0;

        switch (operation) {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }

        return result;
    }
}

• MyDCTester

/**
 * Created by radish608 on 17-5-3.
 */

import java.util.Scanner;

public class MyDCTester {

    public static void main(String[] args) {
        String expression, again;

        int result;

        try {
            Scanner in = new Scanner(System.in);

            do {
                MyDC evaluator = new MyDC();
                System.out.println("Enter a valid postfix expression: ");
                expression = in.nextLine();

                result = evaluator.evaluate(expression);
                System.out.println();
                System.out.println("That expression equals " + result);
                System.out.print("Evaluate another expression [Y/N]? ");
                again = in.nextLine();
                System.out.println();
            }
            while (again.equalsIgnoreCase("y"));
        } catch (Exception IOException) {
            System.out.println("Input exception reported");
        }
    }
}

运行结果

• 用例：

1 2 + 8 2 - 7 4 - / *

• 截图：
  
  

)

• MyDC

/**
 * Created by radish608 on 17-5-3.
 */

import java.util.StringTokenizer;
import java.util.Stack;

public class MyDC {
    /**
     * constant for addition symbol
     */
    private final char ADD = '+';
    /**
     * constant for subtraction symbol
     */
    private final char SUBTRACT = '-';
    /**
     * constant for multiplication symbol
     */
    private final char MULTIPLY = '*';
    /**
     * constant for division symbol
     */
    private final char DIVIDE = '/';
    /**
     * the stack
     */
    private Stack<Integer> stack;

    public MyDC() {
        stack = new Stack<Integer>();
    }

    public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);
        while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator
            if (isOperator(token)) {
                //从栈中弹出操作数2
                op2 = stack.pop();
                //从栈中弹出操作数1
                op1 = stack.pop();
                //根据运算符和两个操作数调用evalSingleOp计算result;
                result=evalSingleOp(token.charAt(0), op1, op2);
                //计算result入栈;
                stack.push(result);
            } else//如果是操作数
            //操作数入栈;
            stack.push(Integer.parseInt(token));
        }

        return result;
    }

    private boolean isOperator(String token) {
        return (token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/"));
    }

    private int evalSingleOp(char operation, int op1, int op2) {
        int result = 0;

        switch (operation) {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }

        return result;
    }
}

• MyDCTester

/**
 * Created by radish608 on 17-5-3.
 */

import java.util.Scanner;

public class MyDCTester {

    public static void main(String[] args) {
        String expression, again;

        int result;

        try {
            Scanner in = new Scanner(System.in);

            do {
                MyDC evaluator = new MyDC();
                System.out.println("Enter a valid postfix expression: ");
                expression = in.nextLine();

                result = evaluator.evaluate(expression);
                System.out.println();
                System.out.println("That expression equals " + result);
                System.out.print("Evaluate another expression [Y/N]? ");
                again = in.nextLine();
                System.out.println();
            }
            while (again.equalsIgnoreCase("y"));
        } catch (Exception IOException) {
            System.out.println("Input exception reported");
        }
    }
}

运行结果

• 用例：

1 2 + 8 2 - 7 4 - / *

• 截图：