Java 代码实现二分查找树（递归）

Java 二分查找树（BST）简介

二分查找树是一种特殊的二叉树，它具有以下特性：

• 左子树上的所有节点值都小于根节点的值。
• 右子树上的所有节点值都大于根节点的值。
• 所有左子树和右子树都是二分查找树。

Java 代码实现二分查找树（递归）

在 Java 中，我们可以使用递归来实现二分查找树。以下代码是一个简单的 Java 二分查找树的实现：

public class BinarySearchTree {

    private Node root;

    public void insert(int value) {
        root = insert(root, value);
    }

    private Node insert(Node node, int value) {
        if (node == null) {
            return new Node(value);
        } else if (value < node.value) {
            node.left = insert(node.left, value);
        } else if (value > node.value) {
            node.right = insert(node.right, value);
        }

        return node;
    }

    public boolean search(int value) {
        return search(root, value);
    }

    private boolean search(Node node, int value) {
        if (node == null) {
            return false;
        } else if (value == node.value) {
            return true;
        } else if (value < node.value) {
            return search(node.left, value);
        } else {
            return search(node.right, value);
        }
    }

    public void delete(int value) {
        root = delete(root, value);
    }

    private Node delete(Node node, int value) {
        if (node == null) {
            return null;
        } else if (value < node.value) {
            node.left = delete(node.left, value);
        } else if (value > node.value) {
            node.right = delete(node.right, value);
        } else {
            if (node.left == null) {
                return node.right;
            } else if (node.right == null) {
                return node.left;
            } else {
                node.value = findMin(node.right).value;
                node.right = delete(node.right, node.value);
            }
        }

        return node;
    }

    public int findMin() {
        return findMin(root).value;
    }

    private Node findMin(Node node) {
        if (node == null) {
            return null;
        } else if (node.left == null) {
            return node;
        } else {
            return findMin(node.left);
        }
    }

    public int findMax() {
        return findMax(root).value;
    }

    private Node findMax(Node node) {
        if (node == null) {
            return null;
        } else if (node.right == null) {
            return node;
        } else {
            return findMax(node.right);
        }
    }

    public void printTree() {
        printTree(root);
    }

    private void printTree(Node node) {
        if (node == null) {
            return;
        }

        System.out.println(node.value);
        printTree(node.left);
        printTree(node.right);
    }

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        bst.insert(10);
        bst.insert(5);
        bst.insert(15);
        bst.insert(2);
        bst.insert(7);
        bst.insert(12);
        bst.insert(20);

        System.out.println("二分查找树：");
        bst.printTree();

        System.out.println("\n查找 15：");
        System.out.println(bst.search(15));

        System.out.println("\n删除 10：");
        bst.delete(10);
        bst.printTree();

        System.out.println("\n最小值：");
        System.out.println(bst.findMin());

        System.out.println("\n最大值：");
        System.out.println(bst.findMax());
    }

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

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

Java 二分查找树的时间复杂度分析

在 Java 中，二分查找树的时间复杂度如下：

• 插入：O(log n)
• 删除：O(log n)
• 搜索：O(log n)
• 查找最小值：O(log n)
• 查找最大值：O(log n)

Java 中二分查找树的实践案例

二分查找树在 Java 中有许多实际应用，包括：

• 排序：二分查找树可以用于对数据进行快速排序。
• 搜索：二分查找树可以用于在数据集合中快速搜索特定元素。
• 统计：二分查找树可以用于计算数据集合中的统计信息，例如最小值、最大值、中值等。
• 数据压缩：二分查找树可以用于对数据进行压缩。

总结

二分查找树是一种高效的数据结构，它具有许多实际应用。在 Java 中，我们可以使用递归来实现二分查找树。本文介绍了 Java 中二分查找树的基本原理、Java 实现代码、时间复杂度分析，以及 Java 中二分查找树的相关实践案例。如果您想了解如何在 Java 中使用递归来实现二分查找树，那么这篇文章非常适合您。