二叉樹的遍歷、查找和刪除

/**
 * @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();

    }
}