20155227 《Java程序设计》实验五 Java网络编程及安全实验报告

实验内容

任务一：

编写MyBC.java实现中缀表达式转后缀表达式的功能。
编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能。
我们如何编程实现bc? 把中缀式转化后缀式调用MyDC.java 中的evaluate方法就行了。这样问题转化为如何由中缀式求得后缀式？

由中缀式求得后缀式可以使用栈，伪代码如下：

设立一个栈，存放运算符，首先栈为空；
从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。
当栈变成空时，输出的结果即为后缀表达式。

MyBC：

import java.util.*;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Arrays;
public class MyBC {
    private static LinkedList<String> op1 = new LinkedList<>();
    private static LinkedList<String> op2 = new LinkedList<>();
    private static StringBuilder a = new StringBuilder();

    public StringBuilder houzhui(LinkedList<String> list) {
        Iterator<String> i = list.iterator();
        while (i.hasNext()) {
            String s = i.next();
            if (isOperator(s)) {
                if (op1.isEmpty()) {
                    op1.push(s);
                } else {
                    if (priority(op1.peek()) <= priority(s) && !s.equals(")")) {
                        op1.push(s);
                    } else if (!s.equals(")") && priority(op1.peek()) > priority(s)) {
                        while (op1.size() != 0 && priority(op1.peek()) >= priority(s)
                                && !op1.peek().equals("(")) {
                            if (!op1.peek().equals("(")) {
                                String operator = op1.pop();
                                a.append(operator).append(" ");
                                op2.push(operator);
                            }
                        }
                        op1.push(s);
                    } else if (s.equals(")")) {
                        while (!op1.peek().equals("(")) {
                            String operator = op1.pop();
                            a.append(operator).append(" ");
                            op2.push(operator);
                        }
                        op1.pop();
                    }
                }
            } else {
                a.append(s).append(" ");
                op2.push(s);
            }
        }
        if (!op1.isEmpty()) {
            Iterator<String> iterator = op1.iterator();
            while (iterator.hasNext()) {
                String operator = iterator.next();
                a.append(operator).append(" ");
                op2.push(operator);
                iterator.remove();
            }
        }
        return a;
    }

    private static boolean isOperator(String oper) {
        if (oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*")
                || oper.equals("(") || oper.equals(")")) {
            return true;
        }
        return false;
    }

    private static int priority(String s) {
        switch (s) {
            case "+":
                return 1;
            case "-":
                return 1;
            case "*":
                return 2;
            case "/":
                return 2;
            case "(":
                return 3;
            case ")":
                return 3;
            default:
                return 0;
        }
    }
}

我们如何实现dc?
这要用到栈。对逆波兰式求值时，不需要再考虑运算符的优先级，只需从左到右扫描一遍后缀表达式即可。求值伪代码如下：

设置一个操作数栈，开始栈为空；
从左到右扫描后缀表达式，遇操作数，进栈；

若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。

此时，栈中仅有一个元素，即为运算的结果。

MyDC：

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



public class MyDC {
    public static int evaluate(StringBuilder b) {
        LinkedList<String> mList = new LinkedList<>();
        String[] postStr = b.toString().split(" ");
        int result;
        for (String s : postStr) {
            if (fuhao(s)) {
                if (!mList.isEmpty()) {
                    int num1 = Integer.valueOf(mList.pop());
                    int num2 = Integer.valueOf(mList.pop());
                    if (s.equals("/") && num1 == 0) {
                        System.out.println("除数不能为0");
                        return 0;
                    }
                    int newNum = cal(num2, num1, s);
                    mList.push(String.valueOf(newNum));
                }
            } else {
                mList.push(s);
            }
        }
        //if (!mList.isEmpty()) {

        //System.out.println("result: "+mList.pop());

        result=Integer.parseInt(mList.pop());
        // }

        return result;
    }

    private static boolean fuhao(String a) {
        if (a.equals("+") || a.equals("-") || a.equals("/") || a.equals("*")
                || a.equals("(") || a.equals(")")) {
            return true;
        }
        return false;
    }
    /*private static int priority(String s) {

        switch (s) {

            case "+":

                return 1;

            case "-":

                return 1;

            case "*":

                return 2;

            case "/":

                return 2;

            case "(":

                return 3;

            case ")":

                return 3;

            default:

                return 0;

        }

    }*/

    private static int cal(int num1, int num2, String operator) {
        switch (operator) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                return num1 / num2;
            default:
                return 0;
        }
    }
}

    /*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;

    }

}*/

Test:

import java.util.LinkedList;
import java.util.*;

public class Test {
    public static void main(String[] args){
        LinkedList<String> list=new LinkedList<>();
        StringBuilder result1;
        int result2;
        String expression, again;
        System.out.println("请输入一个中缀表达式并以#结束");
        Scanner scanner=new Scanner(System.in);
        String s;
        while (!(s=scanner.next()).equals("#")) {
            list.add(s);
        }
        MyBC hz=new MyBC();
        result1 = hz.houzhui(list);
        System.out.println("后缀表达式： "+result1);
        MyDC evaluator = new MyDC();
        result2 = evaluator.evaluate(result1);
        System.out.println("That expression equals " + result2);
        System.out.println();

    }
}