2023年9月26号

今天完成了周一课堂测试的一部分，我使用了二叉树的思想进行四则运算式子的存储和计算。

 首先，二叉树的结构类：

import java.util.Random;

public class Tree {
    private String str;
    private Tree lchild;
    private Tree rchild;
    public Tree(String str){
        this.str=str;
    }
    public Tree(String str,Tree lchild,Tree rchild){
        this.str = str;
        this.rchild = rchild;
        this.lchild = lchild;
    }

    public void setChild(Tree lchild, Tree rchild){
        this.lchild = lchild;
        this.rchild = rchild;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public Tree getRchild() {
        return rchild;
    }

    public void setRchild(Tree rchild) {
        this.rchild = rchild;
    }

    public Tree getLchild() {
        return lchild;
    }

    public void setLchild(Tree lchild) {
        this.lchild = lchild;
    }

    //判断是否有左右孩子
    public boolean hasChild(){
        if(lchild == null && rchild == null)
            return false;
        else
            return true;
    }

    //获取结果，并检验减法和除法的情况是否合理
    public String getResult(){
        Random ra=new Random();
        if(hasChild()){
            switch(str){
                case "+":
                    return String.valueOf(Integer.parseInt(getLchild().getResult()) + Integer.parseInt(getRchild().getResult()));
                case "-":
                    if(Integer.parseInt(getLchild().getResult())<Integer.parseInt(getRchild().getResult())){
                        int t=ra.nextInt(2);
                        if(t==0) str="+";
                        else str="*";
                        return this.getResult();
                    }
                    return String.valueOf(Integer.parseInt(getLchild().getResult()) - Integer.parseInt(getRchild().getResult()));
                case "*":
                    return String.valueOf(Integer.parseInt(getLchild().getResult()) * Integer.parseInt(getRchild().getResult()));
                case "/":
                    if(getRchild().getResult().equals("0")){
                        while(str.equals("/")){
                            str = String.valueOf(tools.getOperator());
                        }
                        return this.getResult();
                    }
                    else if(Integer.parseInt(getLchild().getResult()) % Integer.parseInt(getRchild().getResult()) != 0){
                        while(str.equals("/")){
                            str = String.valueOf(tools.getOperator());
                        }
                        return this.getResult();
                    }
                    else
                        return String.valueOf(Integer.parseInt(getLchild().getResult()) / Integer.parseInt(getRchild().getResult()));
            }
        }
        return str;
    }

    //加括号
    public String toString(){
        String Lstr = "", Rstr = "", Str = "";
        if(hasChild()){
            if(getRchild().hasChild()){//在运算符为-，*，/时需要添加括号，其余不进行添加括号操作
                if(str.equals("/")){
                    Rstr = getRchild().toString();
                }
                else if(str.equals("*") || str.equals("-")){
                    if(getRchild().str.equals("+") || getRchild().str.equals("-")){
                        Rstr = getRchild().toString();
                    }
                    else{
                        Rstr = getRchild().toString().substring(1, getRchild().toString().length()-1);
                    }
                }
                else{
                    Rstr = getRchild().toString().substring(1, getRchild().toString().length()-1);
                }
            }
            else{
                Rstr = getRchild().str;
            }
            if(getLchild().hasChild()){//和右孩子同理，但此时减号不用添加括号
                if(str.equals("*") || str.equals("/")){
                    if(getLchild().str.equals("+") || getLchild().str.equals("-")){
                        Lstr = getLchild().toString();
                    }
                    else{
                        Lstr = getLchild().toString().substring(1, getLchild().toString().length()-1);
                    }
                }
                else{
                    Lstr = getLchild().toString().substring(1, getLchild().toString().length()-1);
                }
            }
            else{
                Lstr = getLchild().str;
            }
            Str = "(" + Lstr + str + Rstr + ")";
        }
        else{
            //若没有孩子，说明是数字节点，直接返回数字
            Str = str;
        }
        return Str;
    }
}

然后是对于该树类的一些操作：

import java.util.ArrayList;

public class doTree {
    private Tree root;
    private int num;
    private ArrayList<Tree> arr = new ArrayList<Tree>();
    public doTree(int num){
        this.num=num;
    }
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Tree getRoot() {
        return root;
    }

    public void setRoot(Tree root) {
        this.root = root;
    }

    //验证表达式是否正确并进行计算
    public String TestProblem(){
        return root.getResult();
    }

    //获取最终的式子（需在验证式子正确后进行）
    public String toString(){
        String str= root.toString();
        str=str.substring(1,str.length()-1);
        return str;
    }

    //计算二叉树的深度
    public int Deepth(){
        int n=this.num;
        int deep=2;
        while(n/2>0){
            deep++;
            n/=2;
        }
        return deep;
    }

    //创建树
    public void CreateTree(int Max){
        Tree lchild, rchild, lnode, rnode;

        if(num == 1){
            lchild = new Tree(String.valueOf(tools.getNumber(Max)), null, null);
            rchild = new Tree(String.valueOf(tools.getNumber(Max)), null, null);
            root = new Tree(String.valueOf(tools.getOperator()), lchild, rchild);
        }
        else{
            int num1 = 0;
            int n = Deepth() - 3;
            boolean[] place = tools.getChildPlace(num);
            root = new Tree(String.valueOf(tools.getOperator()), null, null);
            arr.add(root);

            for(int i = 0; i < n; i++){
                for(int j = 0; j < (int)Math.pow(2, i); j++, num1++){
                    lchild = new Tree(String.valueOf(tools.getOperator()), null, null);
                    rchild = new Tree(String.valueOf(tools.getOperator()), null, null);
                    arr.get(j + num1).setChild(lchild, rchild);
                    arr.add(lchild);
                    arr.add(rchild);
                }
            }

            for(int i = 0; i < place.length; i++){
                if(place[i]){
                    lnode  = new Tree(String.valueOf(tools.getNumber(10)), null, null);
                    rnode  = new Tree(String.valueOf(tools.getNumber(10)), null, null);
                    if(i%2 == 0){
                        lchild = new Tree(String.valueOf(tools.getOperator()), lnode, rnode);
                        arr.add(lchild);
                        arr.get(num1).setLchild(lchild);
                    }
                    else{
                        rchild = new Tree(String.valueOf(tools.getOperator()), lnode, rnode);
                        arr.add(rchild);
                        arr.get(num1).setRchild(rchild);
                    }
                }
                else{
                    if(i%2 == 0){
                        lchild = new Tree(String.valueOf(tools.getNumber(10)), null, null);
                        arr.get(num1).setLchild(lchild);
                    }
                    else{

                        rchild = new Tree(String.valueOf(tools.getNumber(10)), null, null);
                        arr.get(num1).setRchild(rchild);
                    }
                }
                num1 = num1 + i%2;
            }
        }
    }
}