小学生四则运算-

1.

PSP

2.项目要求

• 能自动生成小学四则运算题目
• 除了整数以外，还要支持真分数的四则运算

• 解题思路

  • 了解四则运算的大概思路，即：生成四则运算式子；用户输入结果；程序检验用户输入的结果是否正确；若用户输入的结果错误，即把正确答案输入。
  • 用数组和随机函数随机生成四则运算式子；
  • 了解逆波兰式，即将中缀表示式转换成后缀表达式，以便计算机对式子进行运算；
  • 检验结果并输出；

   

  设计实现及代码说明

  　　1、NiBoLanShi.java

  　　对四则运算式子从中缀表达式转换成后缀表达式，以便计算机计算。

•   1 package jjj.arithmetic.methods;
    2 
    3 import java.util.List;
    4 import java.math.BigDecimal;
    5 import java.util.ArrayList;
    6 import java.util.Stack;
    7 
    8 public class NiBoLanShi {
    9     public static String cal(String str) {
   10         //对表达式进行预处理，并简单验证是否是正确的表达式
   11         //存放处理后的表达式
   12         List<String> list = new ArrayList<>();
   13         char[] arr = str.toCharArray();
   14 
   15         //存放数字临时变量
   16         StringBuffer tmpStr = new StringBuffer();
   17         for (char c : arr) {
   18             //如果是数字或小数点，添加到临时变量中
   19             if (c>="0" && c<="9") {
   20                 tmpStr.append(c);
   21             }else if(c==".") {
   22                 if(tmpStr.indexOf(".")>0) {
   23                     throw new RuntimeException("非法字符");
   24                 }
   25                 tmpStr.append(c);
   26             }
   27 
   28             //如果是加减乘除或者括号，将数字临时变量和运算符依次放入List中
   29             else if (c=="+" || c=="-" || c=="*" || c=="/" || c=="(" || c==")") {
   30                 if (tmpStr.length() > 0) {
   31                     list.add(tmpStr.toString());
   32                     tmpStr.setLength(0);
   33                 }
   34                 list.add(c + "");
   35             }
   36             else if (c==" ") {
   37                 continue;
   38             }
   39             else {
   40                 throw new RuntimeException("非法字符");
   41             }
   42         }
   43         if (tmpStr.length() > 0) {
   44             list.add(tmpStr.toString());
   45         }
   46 
   47         //初始化后缀表达式
   48         List<String> strList = new ArrayList<>();
   49 
   50         //运算过程中，使用了两次栈结构，
   51         //第一次是将中缀表达式转换成后缀表达式，第二次是计算后缀表达式的值
   52         Stack<String> stack = new Stack<>();
   53 
   54         //声明临时变量，存放栈元素
   55         String tmp;
   56 
   57         //将中缀表达式转换成后缀表达式
   58         for (String s : list) {
   59             //如果是左括号直接入栈
   60             if (s.equals("(")) {
   61                 stack.push(s);
   62             }
   63 
   64             //如果是右括号，执行出栈操作，依次添加到后缀表达式中，直到出栈元素为左括号，左括号和右括号都不添加到后缀表达式中
   65             else if (s.equals(")")) {
   66                 while (!(tmp = stack.pop()).equals("(")) {
   67                     strList.add(tmp);
   68                 }
   69             }
   70 
   71             //如果是加减乘除，弹出所遇优先级大于或等于该运算符的栈顶元素（栈中肯定没有右括号，认为左括号的优先级最低），然后将该运算符入栈
   72             else if (s.equals("*") || s.equals("/")) {
   73                 while(!stack.isEmpty()) {
   74                     //取出栈顶元素
   75                     tmp = stack.peek();//取出但不移除
   76                     if (tmp.equals("*") || tmp.equals("/")) {
   77                         stack.pop();
   78                         strList.add(tmp);
   79                     }
   80                     else {
   81                         break;
   82                     }
   83                 }
   84                 stack.push(s);
   85             }
   86             else if (s.equals("+") || s.equals("-")) {
   87                 while(!stack.isEmpty()) {
   88                     //取出栈顶元素
   89                     tmp = stack.peek();
   90                     if (!tmp.equals("(")) {
   91                         stack.pop();
   92                         strList.add(tmp);
   93                     }
   94                     else {
   95                         break;
   96                     }
   97                 }
   98                 stack.push(s);
   99             }
  100 
  101             //如果是数字，直接添加到后缀表达式中
  102             else {
  103                 strList.add(s);
  104             }
  105         }
  106 
  107         //最后依次出栈，放入后缀表达式中
  108         while (!stack.isEmpty()) {
  109             strList.add(stack.pop());
  110         }
  111 
  112         //计算后缀表达式的值
  113         Stack<BigDecimal> newStack = new Stack<>();
  114         for (String s : strList) {
  115             //若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符的左边
  116             //运算后的结果再进栈，直到后缀表达式遍历完毕
  117             if (s.equals("*") || s.equals("/") || s.equals("+") || s.equals("-")) {
  118                 BigDecimal b1 = newStack.pop();
  119                 BigDecimal b2 = newStack.pop();
  120                 switch (s) {
  121                 case "+":
  122                     newStack.push(b2.add(b1));
  123                     break;
  124                 case "-":
  125                     newStack.push(b2.subtract(b1));
  126                     break;
  127                 case "*":
  128                     newStack.push(b2.multiply(b1));
  129                     break;
  130                 case "/":
  131                     newStack.push(b2.divide(b1, 9, BigDecimal.ROUND_HALF_UP));
  132                     break;
  133                 }
  134             }
  135 
  136             //如果是数字，入栈
  137             else {
  138                 newStack.push(new BigDecimal(s));
  139             }
  140         }
  141 
  142         //最后，栈中仅有一个元素，就是计算结果
  143         return newStack.peek().toString();
  144     }
  145 }