Java实现二叉排序树（原创代码，包含插入、删除、查找）

二叉排序树 BST，也称二叉查找树。

二叉排序树的特点：

1. 若左子树非空，则左子树上所有节点值均小于根节点的值。
2. 若右子树非空，则右子树上所有节点值均大于根节点的值。

每一颗子树都是一颗二叉排序树。如下图：

下面我们直接上代码：

package com.tree.binaryTree;

//二叉排序树
public class BinaryTree {
    public static void main(String[] args) {
        TreeNode treeNode = new TreeNode();
        treeNode.insert(50);
        treeNode.insert(25);
        treeNode.insert(70);
        treeNode.insert(21);
        treeNode.insert(35);
        treeNode.insert(60);
        treeNode.insert(84);
        treeNode.insert(13);
        treeNode.insert(30);
        treeNode.insert(40);
        treeNode.insert(56);
        treeNode.insert(67);
        treeNode.insert(86);
        treeNode.insert(32);
        treeNode.insert(38);
        treeNode.insert(58);

        treeNode.delete(35);
        treeNode.delete(50);
    }
}

class Node {
    int value;
    Node left;
    Node right;

    public Node(int value) {
        this.value = value;
    }
}

class TreeNode {
    Node root;

    /**
     * 插入节点
     */
    public void insert(int value) {
        if (root == null) {
            root = new Node(value);
            return;
        }
        Node node = root;
        while (true) {
            if (node.value > value) {
                if (node.left == null) {
                    node.left = new Node(value);
                    return;
                } else {
                    node = node.left;
                }
            } else {
                if (node.right == null) {
                    node.right = new Node(value);
                    return;
                } else {
                    node = node.right;
                }
            }
        }
    }

    /**
     * 寻找节点
     */
    public boolean search(int value) {
        Node node = root;
        while (node != null && value != node.value) {
            if (node.value > value) {
                node = node.left;
            } else {
                node = node.right;
            }
        }
        return node != null;
    }

    public void delete(int value) {
        Node node = root;
        Node temp = node;
        while (node != null) {
            //保存当前节点
            if (node.value == value) {
                //若node节点为尾巴节点，直接将node赋值为null
                if (node.left == null && node.right == null) {
                    if(temp.left == node){
                        temp.left = null;
                        return;
                    }else if(temp.right == node){
                        temp.right = null;
                        return;
                    }else {
                        root = null;
                        return;
                    }
                }
                //若node节点左子节点为空
                if (node.left == null) {
                    Node min = findMin(node.right);
                    if (min == node.right) {
                        node.value = min.value;
                        node.right = min.right;
                    } else {
                        node.value = min.left.value;
                        min.left = min.left.right;
                    }
                    return;
                }
                //若node节点左子节点不为空
                Node max = findMax(node.left);
                if (max == node.left) {
                    node.value = max.value;
                    node.left = max.left;
                } else {
                    node.value = max.right.value;
                    max.right = max.right.left;
                }
                return;
            } else {
                //往下找到value值对应的节点
                if (node.value > value) {
                    temp = node;
                    node = node.left;
                } else {
                    temp = node;
                    node = node.right;
                }
            }
        }
    }

    /**
     * 找到左子树的最大节点的前一个节点
     */
    public Node findMax(Node node) {
        if (node.right == null) {
            return node;
        }
        Node temp = null;
        while (node.right != null) {
            temp = node;
            node = node.right;
        }
        return temp;
    }

    /**
     * 找到右子树的最小节点的前一个节点
     */
    public Node findMin(Node node) {
        if (node.left == null) {
            return node;
        }
        Node temp = null;
        while (node.left != null) {
            temp = node;
            node = node.left;
        }
        return temp;
    }

}

树的原型为：

删除后为：

在测试过程中遇到任何问题可以debug一下，如果解决不了可以在评论区留言，我会帮助你解决问题，欢迎大家积极评论！