深入剖析二叉排序树：高效的数据查询与动态添加-优快云博客

引言

二叉排序树（Binary Sort Tree，简称BST）是一种特殊的二叉树，它能够高效地支持数据的查询、插入和删除操作。与数组和链表相比，二叉排序树在动态数据管理场景中表现出色。本文将深入探讨二叉排序树的基本概念、构建方法、遍历方式以及删除操作，并通过代码示例和实际案例帮助读者全面掌握二叉排序树的核心知识。

主体部分

1. 二叉排序树的基本概念

二叉排序树是一种二叉树，满足以下性质：

对于任意节点，其左子树中的所有节点的值都小于该节点的值。
对于任意节点，其右子树中的所有节点的值都大于该节点的值。
没有重复的节点值（或者可以根据需求将重复值放在左子树或右子树）。

示例：
给定数列 (7, 3, 10, 12, 5, 1, 9)，构建的二叉排序树如下：

        7
       / \
      3   10
     / \    \
    1   5    12
         \
          9

2. 二叉排序树的构建

2.1 数组与二叉排序树的对比

数组的优缺点：

未排序数组：
- 优点：插入速度快（直接添加到末尾）。
- 缺点：查找速度慢（需要遍历整个数组）。
排序数组：
- 优点：查找速度快（可以使用二分查找）。
- 缺点：插入速度慢（需要移动大量元素以保持有序）。

链表的优缺点：

优点：插入速度快（不需要移动元素）。
缺点：查找速度慢（需要遍历链表）。

二叉排序树的优势：

查找、插入和删除操作的平均时间复杂度为 O(log n)，在动态数据管理场景中表现优异。

2.2 构建二叉排序树的代码实现

代码实现：

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

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

    // 添加节点
    public void add(Node node) {
        if (node == null) return;
        if (node.value < this.value) {
            if (this.left == null) {
                this.left = node;
            } else {
                this.left.add(node);
            }
        } else {
            if (this.right == null) {
                this.right = node;
            } else {
                this.right.add(node);
            }
        }
    }

    // 前序遍历
    public void preOrder() {
        System.out.println(this);
        if (this.left != null) this.left.preOrder();
        if (this.right != null) this.right.preOrder();
    }

    // 中序遍历
    public void infixOrder() {
        if (this.left != null) this.left.infixOrder();
        System.out.println(this);
        if (this.right != null) this.right.infixOrder();
    }
}

class BinarySortTree {
    private Node root;

    // 添加节点
    public void add(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }

    // 前序遍历
    public void preOrder() {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("二叉树为空");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空");
        }
    }
}

public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] arr = {7, 3, 10, 12, 5, 1, 9};
        BinarySortTree binarySortTree = new BinarySortTree();
        for (int i : arr) {
            binarySortTree.add(new Node(i));
        }

        System.out.println("前序遍历二叉排序树：");
        binarySortTree.preOrder();

        System.out.println("中序遍历二叉排序树：");
        binarySortTree.infixOrder();
    }
}

运行结果：

前序遍历二叉排序树：
7
3
1
5
10
9
12

中序遍历二叉排序树：
1
3
5
7
9
10
12

3. 二叉排序树的删除操作

二叉排序树的删除操作分为三种情况：

删除叶子节点：直接删除。
删除只有一个子树的节点：用其子树替换该节点。
删除有两个子树的节点：找到右子树的最小节点（或左子树的最大节点），替换待删除节点。

3.1 删除叶子节点

步骤：

找到待删除节点及其父节点。
判断待删除节点是父节点的左子节点还是右子节点。
将父节点的对应子节点设置为 null。

3.2 删除只有一个子树的节点

步骤：

找到待删除节点及其父节点。
判断待删除节点的子树是左子树还是右子树。
将父节点的对应子节点指向待删除节点的子树。

3.3 删除有两个子树的节点

步骤：

找到待删除节点及其右子树的最小节点。
将最小节点的值赋给待删除节点。
删除右子树的最小节点。

代码实现：

// 查找节点
public Node search(int value) {
    if (this.value == value) {
        return this;
    } else if (value < this.value) {
        return this.left == null ? null : this.left.search(value);
    } else {
        return this.right == null ? null : this.right.search(value);
    }
}

// 查找父节点
public Node searchParent(int value) {
    if ((this.left != null && this.left.value == value) ||
        (this.right != null && this.right.value == value)) {
        return this;
    } else {
        if (value < this.value && this.left != null) {
            return this.left.searchParent(value);
        } else if (value > this.value && this.right != null) {
            return this.right.searchParent(value);
        } else {
            return null;
        }
    }
}

// 删除节点
public void delNode(int value) {
    Node targetNode = search(value);
    if (targetNode == null) return;

    Node parent = searchParent(value);
    // 删除叶子节点
    if (targetNode.left == null && targetNode.right == null) {
        if (parent.left == targetNode) {
            parent.left = null;
        } else {
            parent.right = null;
        }
    }
    // 删除只有一个子树的节点
    else if (targetNode.left == null || targetNode.right == null) {
        Node child = targetNode.left != null ? targetNode.left : targetNode.right;
        if (parent.left == targetNode) {
            parent.left = child;
        } else {
            parent.right = child;
        }
    }
    // 删除有两个子树的节点
    else {
        Node minNode = targetNode.right;
        while (minNode.left != null) {
            minNode = minNode.left;
        }
        int temp = minNode.value;
        delNode(minNode.value);
        targetNode.value = temp;
    }
}

测试：

public static void main(String[] args) {
    int[] arr = {7, 3, 10, 12, 5, 1, 9};
    BinarySortTree binarySortTree = new BinarySortTree();
    for (int i : arr) {
        binarySortTree.add(new Node(i));
    }

    System.out.println("删除节点3前的前序遍历：");
    binarySortTree.preOrder();

    binarySortTree.delNode(3);
    System.out.println("删除节点3后的前序遍历：");
    binarySortTree.preOrder();
}

运行结果：

删除节点3前的前序遍历：
7
3
1
5
10
9
12

删除节点3后的前序遍历：
7
5
1
10
9
12

结论

二叉排序树是一种高效的数据结构，能够支持动态数据的查询、插入和删除操作。通过本文的深入剖析和代码示例，读者可以掌握二叉排序树的核心概念和操作方法。在实际应用中，二叉排序树常用于数据库索引、文件系统等场景。

在接下来的文章中，我们将继续探讨更高级的树结构（如红黑树、平衡二叉树等），敬请期待！

系列文章

如果你对平衡二叉树或其他树结构有任何疑问，欢迎在评论区留言讨论！