2018-2019-20175315 实验五-20155335俞昆《网络编程与安全》实验报告

实验的步骤

任务一

1.二人一组结对编程
2.结对实现中缀表达式转后缀表达式的功能 MyBC.java
3.结对实现从上面功能中获取的表达式中实现后缀表达式求值的功能,调用MyDC.java

实验的过程简明如下

1.为什么要将中缀表达式转为后缀表达式?
中缀表达式,虽然符合我们的数学计算习惯,但是并不符合计算机运算的方式
后缀表达式严格按照从左到右进行计算的模式 符合计算机运行方式而中缀表达式需要计算机遇到符号后向后扫描一位 若为括号或优先级更高的操作符还需要向后继续扫描
2.如何定义后缀表达式?
后缀表达式(即逆波兰reverse polish)就是不需要括号就可以实现调整运算顺序的一种技法。比如:ab+cde+**,改为中缀表达式其实是(a+b)((d+e)c),且后缀表达式不含括号
3.重要的数据结构——栈
如果读入操作数,则直接放入输出字符串;如果读入一般运算符如+-/,则放入堆栈,但是放入堆栈之前必须要检查栈顶,并确定栈顶运算符的优先级比放入的运算符的优先级低;如果放入的优先级较低,则需要将栈顶的运算符放入输出字符串,如果读入(,因为左括号优先级最高,因此放入栈中,但是注意,当左括号放入栈中后,则优先级最低,如果读入),则将栈中运算符取出放入输出字符串,直到取出(为止,注意:()不输出到输出字符串顺序读完表达式,如果栈中还有操作符,则弹出,并放入输出字符串。
4.如何计算后缀表达式?
如果读入操作数,则直接放入输出字符串;如果读入一般运算符如+-
/,则放入堆栈,但是放入堆栈之前必须要检查栈顶,并确定栈顶运算符的优先级比放入的运算符的优先级低;如果放入的优先级较低,则需要将栈顶的运算符放入输出字符串,如果读入(,因为左括号优先级最高,因此放入栈中,但是注意,当左括号放入栈中后,则优先级最低,如果读入),则将栈中运算符取出放入输出字符串,直到取出(为止,注意:()不输出到输出字符串顺序读完表达式,如果栈中还有操作符,则弹出,并放入输出字符串。

实验代码如下
MyDC

import java.util.*;
import java.lang.String;
 
public class MyBC {
 
    private int priority(char c){
        if(c == '*' || c== '/')
            return 2;
        else if(c == '+' || c== '-')
            return 1;
        else
            return 0;
    }
 
    private boolean leftPirority(Character c1,char c2){
        if(c1 == null)
            return false;
        return priority(c1)>=priority(c2);
    }
    private boolean isNumber(char c){
        if('0' <= c && c<='9')
            return true;
        return false;
    }
    private boolean isLeftBracket(char c){
        if(c == '(')
            return true;
        return false;
    }
    private boolean isRightBracket(char c){
        if(c == ')')
            return true;
        return false;
    }
    private boolean isOperator(char c){
        if(c == '+' || c == '-' || c == '*' ||c == '/')
            return true;
        return false;
    }
 
 
    public String parse(String str){
        class Stack<S>{
            private LinkedList<S> list = new LinkedList<S>();
 
            public void push(S t){
                list.addLast(t);
            }
 
            public S pop(){
                return list.removeLast();
            }
 
            public S top(){
                return list.peekLast();
            }
 
            public boolean isEmpty(){
                return list.isEmpty();
            }
        }
 
        Stack<Character> stack = new Stack<>();
        StringBuilder string = new StringBuilder();
        char[] cs = str.toCharArray();
 
        for(int i=0; i<cs.length; ++i){
            char c = cs[i];
            if( isNumber(c)){
                string.append(c);
 
            }else if( isLeftBracket(c)){
                stack.push(c);
 
            }else if( isOperator(c)){
 
                while( leftPirority(stack.top(), c)){
                    string.append( stack.pop());
                }
                stack.push(c);
 
            }else if( isRightBracket(c)){
                while( !isLeftBracket( stack.top())){
                    string.append(stack.pop());
                }
                stack.pop();
            }
        }
 
        while( !stack.isEmpty()){
            string.append(stack.pop());
        }
 
        return string.toString();
    }
}

MyDC

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();
 
            if (isOperator(token)) {
                op2 = (stack.pop()).intValue();
                op1 = (stack.pop()).intValue();
                result = evalSingleOp(token.charAt(0), op1, op2);
                stack.push(new Integer(result));
            } else
                stack.push(new Integer(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;
    }
}

MyBCTester

import java.util.Scanner;
import java.lang.String;
 
public class MyBCTester  {
 
    public static void main (String[] args) {
 
        String expression, again;
 
        String result_1;
        int result_2;
 
        try
        {
            Scanner in = new Scanner(System.in);
 
            do
            {
                MyBC bc = new MyBC();
                System.out.println ("请输入一个中缀表达式: ");
                expression = in.nextLine();
 
                result_1 = bc.parse(expression);
                System.out.println();
 
                String[] b = result_1.split("");
                String x = "";
                for(int i=0;i<b.length;i++){
                    x=x+b[i]+" ";
                }
                System.out.println("后缀表达式为: " + x);
 
                MyDC dc = new MyDC();
                result_2 = dc.evaluate (x);
                System.out.println ("That expression equals " + result_2);
 
                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");
        }
    }
}

实验截图

posted on 2019-06-02 22:55  俞昆  阅读(59)  评论(0编辑  收藏

导航