软件工程概论作业

设计思路：

1、定义类node，变量有node类型root ，left，right以及string类型weight

2、初始化函数（以一个新节点为当前节点，根节点为null），设置一个计数器flag=0

2、1初始化weight值，随机数字或符号（若i>=3则必为数将算式限定在10个数以内）

2、11若weight值为符号则i++且调用此初始化函数，（以left为当前节点，本函数中节       点为根节点。）

2、12若weight为符号则i++且调用此初始化函数，（以right为当前节点，本函数中节点为根节点。）

3、遍历函数 void inOrderTraverse(Node node)

3、1判断node函数是否为空，为空则return

3、2输出左括号

3、3 inOrderTraverse(node.left);

3、4输出本节点权值

3、5 inOrderTraverse(node.right);

3、6输出右括号

4、求值函数int evaluateExpTree(Node)

4、1 设lvalue和rvalue并初始化为0

4、2 如果节点为操作数，返回该值

4、3如果节点不是运算符

4、31递归计算左子树值为lvalue

4、32递归计算右子树值为rvalue

4、33根据节点计算符计算

5、判断答案是否正确

实验代码：

package demo;
import java.util.Random;
import java.util.Scanner;

class Node
    {
        public Node root;
        public Node left;
        public Node right;
        public String weight;

        public void setroot(Node r) {root=r;}//根植

        public void setleft(Node l)    {left=l;}//左子树

        public void setright(Node r) {right=r;}//右子树

        public void setweight(String w) {weight=w;}//判断运算符号

        public String getweight() {return weight;}
    }

public  class show{

    //控制式子长度
    static int flag=0;
    static    String length="";

    static void setTree(Node zz,Node root)//初始化树
    {

        zz.left=new Node();
        zz.right=new Node();
        zz.setroot(root);
        int panding=new Random().nextInt(2);

        if(panding==1)
        {
            //生成符号

            int fuhao=new Random().nextInt(4);
            if(fuhao==0) zz.setweight("+");
            if(fuhao==1) zz.setweight("-");
            if(fuhao==2) zz.setweight("*");
            if(fuhao==3) zz.setweight("*");
            setTree(zz.left,zz);
            setTree(zz.right,zz);
        }
        if(panding==0)
        {
            int num=new Random().nextInt(100);
            zz.setweight(""+num);
            flag++;

        }

    }

    static     void inOrderTraverse(Node zz)//遍历生成算式
    {

        if(zz.weight==null) return;
        else{
            length=length+"(";
            inOrderTraverse(zz.left);
            length=length+zz.getweight();
            inOrderTraverse(zz.right);
            length=length+")";

        }

    }
    static    int evaluateExpTree(Node zz)//求值
    {
        int lvalue=0,rvalue=0;
        int ans=0;
        if(zz.left.getweight()!=null){
            lvalue=evaluateExpTree(zz.left);
            rvalue=evaluateExpTree(zz.right);
        }
        else
        {    

            ans=Integer.parseInt(zz.getweight());
        }

        if(zz.weight.charAt(0)==‘+‘) ans=lvalue+rvalue;
        if(zz.weight.charAt(0)==‘-‘) ans=lvalue-rvalue;
        if(zz.weight.charAt(0)==‘*‘) ans=lvalue*rvalue;
        if(zz.weight.charAt(0)==‘/‘) ans=lvalue/rvalue;

        return ans;
    }

    public static  void main(String args[])
    {
            int j=0;
            System.out.println("请在等号后输入结果：");
            Scanner zhi=new Scanner(System.in);
            int []b=new int[30];
            for(int i=0;i<30;i++)
            {
                Node initial = new Node();
                Node ltree=new Node();
                Node rtree=new Node();
                initial.setweight("+");

                initial.setleft(ltree);
                initial.setright(rtree);
                //判断数字位数，超过则重新出题
                while(flag==0||flag>4)
                {
                    flag=0;setTree(ltree,initial);
                }
                flag=0;
                while(flag==0||flag>4)
                {
                    flag=0;setTree(rtree,initial);
                }

                inOrderTraverse(initial);
                length=length+"=";
                System.out.println(length);
                b[i]=zhi.nextInt();
                if(b[i]==evaluateExpTree(initial))
                {
                j++;
                System.out.println("结果正确");

                }
                else System.out.println("结果错误，正确结果为："+evaluateExpTree(initial));
                length="";
                flag=0;

            }

                System.out.println("做对了"+j+"道题");
    }

}

结果截图：

结对照片