Java 二叉搜索树代码

以下是一个简单的Java二叉搜索树（BST）实现。这个实现仅包括插入、查找和删除操作，并且使用递归来实现它们。

public class BinarySearchTree {
    
    // 树节点类
    private class Node {
        int data;
        Node left;
        Node right;
        
        public Node(int data) {
            this.data = data;
            left = null;
            right = null;
        }
    }
    
    private Node root;
    
    public BinarySearchTree() {
        root = null;
    }
    
    // 插入方法
    public void insert(int data) {
        root = insert(root, data);
    }
    
    private Node insert(Node node, int data) {
        if (node == null) {
            node = new Node(data);
            return node;
        }
        
        if (data < node.data) {
            node.left = insert(node.left, data);
        } else if (data > node.data) {
            node.right = insert(node.right, data);
        }
        
        return node;
    }
    
    // 查找方法
    public boolean search(int data) {
        return search(root, data);
    }
    
    private boolean search(Node node, int data) {
        if (node == null) {
            return false;
        }
        
        if (node.data == data) {
            return true;
        } else if (data < node.data) {
            return search(node.left, data);
        } else {
            return search(node.right, data);
        }
    }
    
    // 删除方法
    public void delete(int data) {
        root = delete(root, data);
    }
    
    private Node delete(Node node, int data) {
        if (node == null) {
            return null;
        }
        
        if (data < node.data) {
            node.left = delete(node.left, data);
        } else if (data > node.data) {
            node.right = delete(node.right, data);
        } else {
            if (node.left == null && node.right == null) {
                node = null;
            } else if (node.left == null) {
                node = node.right;
            } else if (node.right == null) {
                node = node.left;
            } else {
                Node temp = findMin(node.right);
                node.data = temp.data;
                node.right = delete(node.right, temp.data);
            }
        }
        
        return node;
    }
    
    private Node findMin(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        
        return node;
    }
}

这个实现仅仅是二叉搜索树的基础，实际上还有很多其他的操作和优化可以应用到BST上。