:结对项目--四则运算

成员:林莉  宫丽君

经过课上同学的讲解，知道用中缀表达式转化为后缀表达式这种方法可以提高效率,做法如下：

Cal c1=new Cal();
String inBefore = "1+2*3";
String[] in = inBefore.split("") ; 7 public void testSolveOrder() {
    HashMap<String, Integer> precedence = new HashMap<String, Integer>();
    precedence.put("(", 0);
    precedence.put(")", 0);
    precedence.put("+", 1);
    precedence.put("-", 1);
    precedence.put("*", 2);
    precedence.put("/", 2);
    assertEquals("123*+", c1.SolveOrder(in, precedence));
    fail("Not yet implemented");
}

根据后缀（逆波兰式）计算

public double calculateOut(String[] out) {
    //假设满足逆波兰式的输出不为空却长度不为零
    assert (out != null && out.length != 0);
    //操作数栈
    Stack<Double> stack = new Stack<Double>();
    for (int i = 0; i < out.length; i++) {
        if (isNumber(out[i])) {
            stack.push(Double.parseDouble(out[i]));
        } else {
            double v1 = stack.pop();
            double v2 = stack.pop();
            double result = eval(out[i], v2, v1);
            stack.push(result);
        }
    }
    return stack.pop();
}

想要产生括号且必须得成对出现，由于是四位数计算，所以穷举出括号的方式获取括号，rand（）%5+1生成1-5之间的随机整数，然后选择括号类型。

switch(rand()%5)
    {
        
    case 1:    s = "("+itos(n1)+ope[op1]+itos(n2)+")"+ope[op2]+itos(n3)+ope[op3]+itos(4);break;
    case 2:    s = "("+itos(n1)+ope[op1]+itos(n2)+ope[op2]+itos(n3)+")"+ope[op3]+itos(4);break;
    case 3:    s = itos(n1)+ope[op1]+"("+itos(n2)+ope[op2]+itos(n3)+")"+ope[op3]+itos(4);break;
    case 4:    s = itos(n1)+ope[op1]+"("+itos(n2)+ope[op2]+itos(n3)+ope[op3]+itos(4)+")";break;
    case 5: s = "("+itos(n1)+ope[op1]+itos(n2)+")"+ope[op2]+"("+itos(n3)+ope[op3]+itos(4)+")";break;

    }

测试是否是数字：

@Test
public void testIsNumber() {
    assertEquals("1", "1");
    assertEquals("0", "+");
}

测试单步计算结果：

@Test
public void testEval() {
    assertEquals("5", c1.eval("+", 3, 2));
    assertEquals("6", c1.eval("*", 3, 2));
    assertEquals("1", c1.eval("-", 3, 2));
    assertEquals("2", c1.eval("/", 6, 3));
}

部分代码如下：

// 中缀转后缀
public String[] SolveOrder(String[] in, HashMap<String, Integer> precedence) {
        // 符合逆波兰式（后缀）的输出
        int kk=in.length;
        String out[] = new String[kk];
        int p = 0 ;
        // 操作符
        Stack<String> ops = new Stack<String>();
        for (int i = 0; i < in.length; i++) {
            String s = in[i];
            // 碰见数值 就放进out数组末尾
            if (!precedence.containsKey(in[i])) {
                out[p] = s ;
                p ++ ;
                continue;
            }
            //如果优先级比栈顶的大
            if (ops.isEmpty() || (precedence.get(s) > precedence.get(ops.peek()))) {
                    ops.push(s);
                    //break;
            }else{
                        //如果栈顶的比目前的运算符优先级小或者相等 一直出栈到没有或者栈顶    小于当前运算符
                while (true ) {
                    ops.pop();// 出栈得运算符
                    out[p] = s ;
                    p ++ ;
                    if(ops.empty())  break ;//如果栈空了  break
                    if(precedence.get(ops.peek()) < precedence.get(s)){
                        break ;//栈顶小于当前的了  break
                    }
                }
                out[p] = s ;
                p ++ ;
            }
        }
        // 若操作符栈不为空，就依次将剩余的操作符放入out数组
        while (!ops.isEmpty()) {
            out[p] = ops.peek() ;
            p ++ ;
            ops.pop() ;
        }
        return out;
    }

    // 优先级的定义
    public HashMap<String, Integer> priorityInfo() {
        HashMap<String, Integer> precedence = new HashMap<String, Integer>();
        precedence.put("(", 0);
        precedence.put(")", 0);
        precedence.put("+", 1);
        precedence.put("-", 1);
        precedence.put("*", 2);
        precedence.put("/", 2);
        return precedence;
    }

    public double calculateOut(String[] out) {
        // 假设满足逆波兰式的输出不为空却长度不为零
        int kk=out.length;
        System.out.println("转换成后缀表达式是");
        for(int o=0;o<kk;o++){
            System.out.print(out[o]);
        }
        System.out.println();
        assert (out != null && out.length != 0);
        // 操作数栈
        Stack<Double> stack = new Stack<Double>();
        for (int i = 0; i < out.length; i++) {
            if (isNumber(out[i])) {
                stack.push(Double.parseDouble(out[i]));
            } else {
                double v1 = stack.pop();
                double v2 = stack.pop();
                double result = eval(out[i], v2, v1);
                stack.push(result);
            }
        }
        return stack.pop();
    }

    // 判别是否是数字
    public boolean isNumber(String s) {
        if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/"))
            return false;
        return true;
    }

    public static double eval(String op, double val1, double val2) {
        if (op.equals("+"))
            return val1 + val2;
        if (op.equals("-"))
            return val1 - val2;
        if (op.equals("/"))
            return val1 / val2;
        if (op.equals("*"))
            return val1 * val2;
        throw new RuntimeException("Invalid operator");
    }
    public static void main(String[] args) {
        System.out.println("请输入要计算的算式：");
        Scanner sc = new Scanner(System.in);
        String inBefore = sc.nextLine();
        String[] in = inBefore.split("") ;
        int kk=in.length;
        System.out.println("您输入的算式是");
        for(int o=0;o<kk;o++){
            System.out.print(in[o]);
        }
        System.out.println();
        Cal cc = new Cal() ;
        HashMap<String, Integer> precedence = cc.priorityInfo();
        String[] out = cc.SolveOrder(in, precedence);
        System.out.println("所输入的算式结果为:" + cc.calculateOut(out));

}