二叉搜索树（BST树）

一、BST的特征：

二叉搜索树是一种特殊的二叉树，它具有以下特性：

节点的左子树：对于每个节点，左子树中所有节点的值都小于该节点的值。
节点的右子树：对于每个节点，右子树中所有节点的值都大于该节点的值。
递归性质：每个子树也都是二叉搜索树。

这些特性使得二叉搜索树非常适合用于快速查找、插入和删除操作，其平均时间复杂度为 
O(logn)，但在最坏情况下（例如，树退化为链表时），时间复杂度为 O(n)。

二、BST的基本操作

1. 插入

插入操作从根节点开始，比较新值与当前节点的值，决定向左子树或右子树插入。

2. 查找

查找操作与插入类似，从根节点开始，逐步向下查找，直到找到目标值或到达空节点。

3. 删除

删除操作分为三种情况：

     ① 删除叶子节点（没有子节点）
     ② 删除只有一个子节点的节点
     ③ 删除有两个子节点的节点（此时通常用后继节点或前驱节点替换被删除节点）

三、BST的 Java 实现

以下是一个简单的二叉搜索树的 Java 实现，包括插入、查找和删除操作：

3.1、树的节点类

package bsttree;

/**
 * @program: Pay.java
 * @ClassName BSTNode
 * @description:
 * @author: 苏芮溪
 * @create: 2024−11-03 16:16
 * @Version 1.0
 **/
//这是一个二叉搜索树的节点类
public class BSTNode {
    int data;
    BSTNode left;
    BSTNode right;

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

3.2、BST树类

package bsttree;

/**
 * @program: Pay.java
 * @ClassName BSTTree
 * @description:
 * @author: 苏芮溪
 * @create: 2024−11-03 16:16
 * @Version 1.0
 **/
//BST树，实现插入，删除，搜索
public class BSTTree {
    private BSTNode root;



    //实现插入
    public void insertNode(int data){
            root = insertedNode(root,data);
    }

    //insertedNode
    private BSTNode insertedNode(BSTNode node,int data) {
        if(node == null) {
            return new BSTNode(data);
        }else {
            if(data < node.data) {
                node.left = insertedNode(node.left,data);
            }else if (data > node.data) {
                node.right = insertedNode(node.right,data);
            }else if (data == node.data) {
                //数据重复
                System.out.println("数据："+data+"已存在");
                return node;
            }
        }
        return node;
    }


    //实现删除
    public boolean deleteNode(int data){
            root =  deleteedNode(root,data);
            return root != null;
    }
    private BSTNode deleteedNode(BSTNode node,int data) {
        if(node == null) {
            System.out.println("树中无此元素");
            return null;
        }
        if (data > node.data) {
            node.right = deleteedNode(node.right,data);
        }else if (data < node.data) {
            node.left = deleteedNode(node.left,data);
        }else if (data == node.data) {//找到节点
            //当节点没有左子树的时候
            if (node.left == null ) {
                node = node.right;
                return node;
            }else if (node.right == null) {//当节点有左子树但是没有右子树的时候
                node = node.left;
                return node;
            }else if (node.left != null&&node.right != null) {//两个子树都有的时候
                node.data = findMinNode(node.right).data;
                //删除刚刚找到的节点
                deleteNode(node.data);
                return node;
            }
        }
        return node;
    }
    //寻找右子树的最小值
    private BSTNode findMinNode(BSTNode node) {
        if (node.left == null) {
            return node;
        }else {
            return findMinNode(node.left);
        }
    }


    //实现搜索

    public boolean searchNode(int data){
        return searchedNode(root,data);
    }
    private boolean searchedNode(BSTNode node,int data){
        if(node == null) {
            return false;//不存在
        }
        if (data < node.data) {
            return searchedNode(node.left,data);
        }else if (data > node.data) {
            return searchedNode(node.right,data);
        }else if (data == node.data) {
            return true;//找到节点
        }
        return false;
    }

    public void showFirst(BSTNode node){
        if (node!=null) {
            System.out.println(node.data);
            showFirst(node.left);
            showFirst(node.right);
        }
    }

    //无参构造
    public BSTTree() {
        root = null;
    }
    //带有根节点的构造
    public BSTTree(BSTNode root) {
        this.root = root;
    }
    //获取根节点
    public BSTNode getRoot() {
        return root;
    }
}