TreeNode&BinaryTree二叉树

1/3，定义节点对象

package demo022801;

public class TreeNode {
    int num;
    TreeNode leftNode;
    TreeNode rightNode;

    public TreeNode(int num){
        this.num=num;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }
    //递归遍历，前序
    public void frontShow(){
        System.out.println(num);
        if (leftNode!=null){
            leftNode.frontShow();
        }
        if(rightNode!=null){
            rightNode.frontShow();
        }
    }

    public void middleShow(){
        if (leftNode!=null){
            leftNode.frontShow();
        }
        System.out.println(num);
        if(rightNode!=null){
            rightNode.frontShow();
        }
    }

    public void afterShow(){
        if (leftNode!=null){
            leftNode.afterShow();
        }
        if(rightNode!=null){
            rightNode.afterShow();
        }
        System.out.println(num);
    }

    public TreeNode frontSearch(int num){
        TreeNode target = null;
        //对比当前节点
        if(this.num==num){
            return this;
        //当前节点不是
        }else {
            //查找左节点
            if (leftNode!=null){
                target = leftNode.frontSearch(num);
            }
            if(target!=null){
                return target;
            }
            //查找右节点
            if (rightNode!=null){
                target = rightNode.frontSearch(num);
            }
        }
        return target;
    }

    public void delete(int num){
        //定义一个temp
        TreeNode parent = this;
        //检查左儿子
        if (parent.leftNode != null && parent.leftNode.num == num){
            parent.leftNode = null;
            return;
        }
        //检查右儿子
        if (parent.rightNode != null && parent.rightNode.num == num){
            parent.rightNode = null;
            return;
        }

        //重新给temp赋值
        parent = leftNode;
        //检查左孙子，调用递归
        if (parent != null){
            parent.delete(num);
        }

        //重新给temp赋值，调用递归
        parent = rightNode;
        //检查右孙子
        if (parent != null){
            parent.delete(num);
        }
    }
}

2/2，定义二叉树对象

package demo022801;

public class BinaryTree {
    TreeNode root;

    public TreeNode getRoot() {
        return root;
    }

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

    //成员方法全部调用节点方法
    public void frontShow(){
        root.frontShow();
    }

    public void middleShow(){
        root.middleShow();
    }

    public void afterShow(){
        root.afterShow();
    }

    public TreeNode frontSearch(int num){
        return root.frontSearch(num);
    }

    public void delete(int num){
        if (root.num == num){
            root = null;
        }else {
            root.delete(num);
        }
    }
}

3/3调用demo

package demo022801;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //创建一个对象，一棵树
        BinaryTree binTree = new BinaryTree();
        //创建一个根节点
        TreeNode root = new TreeNode(1);
        //给树对象赋值
        binTree.setRoot(root);
        //创建左右两个子节点
        TreeNode rootL = new TreeNode(2);
        TreeNode rootR = new TreeNode(3);
        //将创建的子节点的引用传递给根节点
        root.setLeftNode(rootL);
        root.setRightNode(rootR);
        //为第二层的左节点创建两个子节点
        rootL.setLeftNode(new TreeNode(4));
        rootL.setRightNode(new TreeNode(5));
        //为第二层的右节点创建两个子节点
        rootR.setLeftNode(new TreeNode(6));
        rootR.setRightNode(new TreeNode(7));
        //三种遍历方式
        binTree.frontShow();
        binTree.middleShow();
        binTree.afterShow();
        //三种查找方式
        TreeNode result = binTree.frontSearch(5);


        //删除一个节点
        binTree.delete(5);

    }
}