JAVA实现二叉树

二叉树名词解释
百度百科：
二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 。
二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点 。
如图：
子树
以其中任意一个节点为例，向下延申的左右两个分支，就是子树，左侧分支叫做左子树，右侧分支叫做右子树。
结点的度
一个结点拥有子树的数目称为结点的度即分支的个数
叶子结点
也称为终端结点，没有子树的结点或者度为零的结点（向下在没有分支）
树的深度
也称为树的高度，树中所有结点的层次最大值称为树的深度

满二叉树
如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。
云里雾里的一个定义，其实就是一个二叉树，所有叶子节点在同一层级，且没有空余的分支如图：
完全二叉树
深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应时，称为完全二叉树(所有叶子节点在最后两层，且一次从左向右没有断开的)

java代码实现

/**
 * @author lixl
 * 二叉树实现增删查操作
 * 二叉树基本概念：二叉树由一个拥有左右两个分支的数据结构组成。
 * 第一个节点，叫做根节点，每一个分支都叫做子树，左侧叫做左子树，右侧叫做右子树。没有分支的节点叫做叶子节点
 * 组成规则，以根节点为起点，左侧的小于根节点，右侧大于根节点，以此规则延申到每一个父节点与子节点的规则
 * @description
 * @date 2022/1/27
 */
public class BinaryTree {

    private int size = 0;// 记录树的大小

    /**
     * 申请二叉树的根节点
     */
    private TreeNode rootNode;
	/**
     * 递归遍历所有节点，并打印
     * @param node
     */
    public void printAllNode(TreeNode node){
        System.out.println(node);
        if (node.leftNode!=null){
            printAllNode(node.leftNode);
        }
        if (node.rightNode!=null){
            printAllNode(node.rightNode);
        }
    }
    /**
     * 添加节点方法
     * @param value
     */
    public void add(int value){
        // 没有节点时候，需要创建根节点
        if (rootNode == null){
            rootNode = new TreeNode(value);
            size++;
            return;
        }
        boolean result = insertTreeNode(rootNode,value);
        if (result) {
            size++;
        }
    }


    /**
     * 寻找节点合适位置，进行添加
     * @param node
     * @param value
     */
    private boolean insertTreeNode(TreeNode node,int value){
        if (node.value > value){
            // 向左子树插入
            if (node.leftNode==null){
                TreeNode leftNode = new TreeNode(value);
                node.leftNode = leftNode;
                return true;
            }
            return insertTreeNode(node.leftNode,value);
        } else if (node.value < value){
            // 向右子树插入
            if (node.rightNode == null){
                TreeNode rightNode = new TreeNode(value);
                node.rightNode = rightNode;
                return true;
            }
            return insertTreeNode(node.rightNode,value);
        } else {
            // 不插入直接返回
            return false;
        }
    }

    /**
     * 获取匹配节点信息
     * @param value
     * @return
     */
    public int get(int value){
        return searchNode(rootNode,value).getValue();
    }

    /**
     * 寻找节点方法
     * @param node
     * @param value
     * @return
     */
    private TreeNode searchNode(TreeNode node,int value){
        if (node == null ){
            return null;// 寻找失败
        }
        if (node.value<value){
            // 寻找右侧子树
            return searchNode(node.rightNode,value);
        } else if (node.value > value){
            // 寻找左侧子树
            return searchNode(node.leftNode,value);
        } else {
            return node;
        }
    }

    /**
     * 删除节点需要分情况讨论：
     * 第一种情况删除节点为叶子节点，直接删除即可
     * 第二种情况删除节点只有左子树，或者右子树，则将左子树或者右子树替代当前删除的节点
     * 第三种情况删除节点既有左子树，又有右子树，则删除节点的时候，需要寻找被删除节点右子树中最小的节点，并用其替代当前删除节点
     * @param value
     * @return
     */
    public int delete(int value){
        if (this.size==0){
            // 空树了，不能删除了
            return -1;
        }
        TreeNode d_parentNode = null;// 用于保存被删除节点的父节点
        TreeNode currentNode = rootNode;// 申请当前节点，用于遍历寻找
        int directNum = 0; // 删除节点在父节点的位置，1：左侧 2：右侧 0：删除根节点
        while (currentNode != null){
            if (currentNode.value > value){
                // 寻找左测节点
                d_parentNode = currentNode;
                directNum = 1;
                currentNode = currentNode.leftNode;
            } else if(currentNode.value < value){
                // 寻找右侧节点
                d_parentNode = currentNode;
                directNum = 2;
                currentNode = currentNode.rightNode;
            } else {
                // 为寻找的删除节点
                break;
            }
        }
        this.size--;
        if (currentNode != null){
            if (d_parentNode==null){
                // 删除根节点
                rootNode = null;
                return value;
            } else {
                return deleteNode(currentNode, d_parentNode, directNum);
            }
        } else {
            return -1;//没有找到删除的数据
        }
    }

    /**
     * 寻找具体的删除节点的位置
     * @param node
     * @param parentNode
     * @param directNum
     * @return
     */
    private int deleteNode(TreeNode node,TreeNode parentNode,int directNum){
        int returnValue = node.value;
        if (node.leftNode == null && node.rightNode == null){
            // 删除为叶子节点
            if (directNum == 1){
                parentNode.leftNode = null;
            } else if(directNum == 2){
                parentNode.rightNode = null;
            }
        } else if(node.leftNode != null && node.rightNode == null){
            // 只有左子树
            node.value = node.leftNode.value;
            node.leftNode = null;
        } else if(node.leftNode == null && node.rightNode != null){
            // 只有右子树
            node.value = node.rightNode.value;
            node.rightNode = null;
        } else {
            // 既有左子树，又有右子树,寻找右侧子树最小节点
            if (node.rightNode.rightNode==null && node.rightNode.leftNode==null){
                node.value = node.rightNode.value;// 利用换值的方法，将待删除的元素给换掉
                node.rightNode = null;
            } else {
                TreeNode minNode = getMinTreeNode(node,node.rightNode);
                node.value = minNode.value;
            }

        }
        return returnValue;
    };

    /**
     * 寻找指定节点子树下，最小的节点，并改变节点信息
     * @param node
     * @return
     */
    private TreeNode getMinTreeNode(TreeNode parentNode,TreeNode node){
        if (node.leftNode == null){
            // 寻找过程中，将找到的目标换成它右侧的节点，保证树的完整性
            parentNode.leftNode = node.rightNode;
            return node;
        } else {
            return getMinTreeNode(node,node.leftNode);
        }
    }

    /**
     * 获取树大小的方法
     * @return
     */
    public int size(){
        return this.size;
    }

    /**
     * 树的节点类
     */
    private static class TreeNode{

        /**
         * 创建只有值的构造方法
         * @param value
         */
        public TreeNode( int value){
            this.value = value;
            this.leftNode = null;
            this.rightNode = null;
        }

        /**
         * 节点的值
         */
        private int value;

        /**
         * 左节点的指针
         */
        private TreeNode leftNode;

        /**
         * 右侧节点指针
         */
        private TreeNode rightNode;

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        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 class TestTree {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.add(8);
        binaryTree.add(5);
        binaryTree.add(13);
        binaryTree.add(4);
        binaryTree.add(7);
        binaryTree.add(9);
        binaryTree.add(15);
        binaryTree.add(10);
        int resylt = binaryTree.get(4);
        System.out.println(resylt);
        int delete2 = binaryTree.delete(10);
        int delete = binaryTree.delete(8);
        System.out.println(delete);
        int delete1 = binaryTree.delete(13);
        System.out.println(delete1);

    }
}