二叉树的遍历、查找和删除

/**
 * @Description 定义一个二叉树
 * @auther Eleven
 * @create 2020-04-05 19:27
 **/
public class BinaryTree {

    TreeNode rootNode;

    public void setRootNode(TreeNode rootNode) {
        this.rootNode = rootNode;
    }

    public TreeNode getRootNode() {
        return rootNode;
    }

    public void fontShow() {
        if(rootNode !=null){
            rootNode.fontShow();
        }
    }

    public void middleShow() {
        if(rootNode !=null) {
            rootNode.middleShow();
        }
    }

    public void afterShow() {
        if(rootNode !=null) {
            rootNode.afterShow();
        }
    }

    public TreeNode fontSearch(int i) {
            return rootNode.fontSearch(i);
    }

    public void deleteNode(TreeNode deleteNode) {
        if (deleteNode == rootNode){
            rootNode=null;
            return;
        }
        rootNode.deleteNode(deleteNode);
    }
}

/**
 * @Description 二叉树树点数据
 * @auther Eleven
 * @create 2020-04-05 19:27
 **/
public class TreeNode {
    //节点数
    int data;
    //左节点
    TreeNode leftNode;
    //右节点
    TreeNode rightNode;

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

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

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    //前序遍历
    public void fontShow() {
        //先遍历自己
        System.out.println(this.data);
        //再遍历左节点
        if(leftNode !=null){
          leftNode.fontShow();
        }
        //遍历右节点
        if(rightNode!=null){
            rightNode.fontShow();
        }
    }

    //中序遍历
    public void middleShow() {
        //遍历左侧
        if(leftNode!=null){
            leftNode.middleShow();
        }
        //遍历自己
        System.out.println(this.data);
        if(rightNode!=null){
            rightNode.middleShow();
        }
    }

    //后序遍历
    public void afterShow() {
        //遍历左侧
        if(leftNode!=null){
            leftNode.afterShow();
        }
        if(rightNode!=null){
            rightNode.afterShow();
        }
        //遍历自己
        System.out.println(this.data);
    }

    /**
     * 前序查找
     * @param i
     * @return
     */
    public TreeNode fontSearch(int i) {
        TreeNode target = null ;
        if (this.data  == i ){
            return this;
        }
        if (leftNode!=null){
            target =  leftNode.fontSearch(i);
        }
        if (target==null){
            if (rightNode!=null){
                target = rightNode.fontSearch(i);
            }
        }
        return target;
    }


    /**
     * 删除树节点
     * @param deleteNode
     */
    public void deleteNode(TreeNode deleteNode) {
        if (this.leftNode!=null && this.leftNode == deleteNode){
            this.leftNode=null;
            return;
        }
        if (this.rightNode!=null && this.rightNode == deleteNode ){
            this.rightNode=null;
            return;
        }
        if (this.leftNode != null){
            this.leftNode.deleteNode(deleteNode);
        }
        if (this.rightNode !=null){
            this.rightNode.deleteNode(deleteNode);
        }
    }
}

/**
 * @Description 测试类
 * @auther Eleven
 * @create 2020-04-05 19:27
 **/
public class Test {

    public static void main(String[] args) {
        //首先创建一个树对象
        BinaryTree binaryTree = new BinaryTree();
        //定义一个root节点
        TreeNode root = new TreeNode(1);
        //把节点设置到树中
        binaryTree.setRootNode(root);
        //定义一个左节点
        TreeNode leftNode = new TreeNode(2);
        //设置为根节点的子节点
        root.setLeftNode(leftNode);
        //定义一个右节点
        TreeNode rightNode = new TreeNode(3);
        //设置为根节点的子节点
        root.setRightNode(rightNode);

        //定义左自己节点的二级节点
        TreeNode leftNode4Left = new TreeNode(4);
        TreeNode leftNode4Right = new TreeNode(5);

        leftNode.setLeftNode(leftNode4Left);
        leftNode.setRightNode(leftNode4Right);

        //定义右自己节点的二级节点
        TreeNode rightNode4Left = new TreeNode(6);
        TreeNode rightNode4Right = new TreeNode(7);

        rightNode.setLeftNode(rightNode4Left);
        rightNode.setRightNode(rightNode4Right);

        /**
         * 树的遍历是以每个树节点未操作位，进行操作的
         */
        //前序遍历
        binaryTree.fontShow();
        System.out.println("------------万恶分隔线----------------------");
        //中序遍历
        binaryTree.middleShow();
        System.out.println("------------万恶分隔线----------------------");
        //后序遍历
        binaryTree.afterShow();
        System.out.println("------------查找某个元素----------------------");
        /**
         * 树的查找是以每个树节点未操作位，进行操作的
         */
        //前序查找
        TreeNode node =  binaryTree.fontSearch(10);
        System.out.println(node);
        System.out.println("------------删除节点 before----------------------");
        //删除节点
        binaryTree.fontShow();
        binaryTree.deleteNode(rightNode4Right);
        System.out.println("------------删除节点 after----------------------");
        binaryTree.fontShow();

    }
}