数据结构与算法-二叉排序树

引言

        在计算机科学中，数据结构和算法是构建高效程序的核心要素。其中，二叉排序树（Binary Search Tree, BST）作为一种基于二叉树的特殊数据结构，因其在搜索、插入和删除操作上的优秀性能而被广泛应用。本文将详细解析二叉排序树的定义、性质、操作方法以及实际应用场景。

一、什么是二叉排序树？

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

1. 每个节点包含一个键（key），这个键用于确定节点在树中的位置。
2. 左子树中所有节点的键值均小于其父节点的键值。
3. 右子树中所有节点的键值均大于其父节点的键值。
4. 左右子树也必须各自为二叉排序树。

二、二叉排序树的操作方法

1. 查找操作：从根节点开始，如果目标键等于当前节点的键，则查找成功；若目标键小于当前节点键值，则在左子树中递归查找；若目标键大于当前节点键值，则在右子树中递归查找。

2. 插入操作：同样从根节点开始，如果树为空则直接创建新节点作为根节点；否则按照查找过程找到合适的位置插入新的节点，保持二叉排序树的性质不变。

3. 删除操作：删除节点的过程相对复杂，需要考虑三种情况：要删除的节点无子节点、仅有一个子节点或有两个子节点。在保证二叉排序树特性的前提下，调整树的结构以完成删除。

三、二叉排序树的特性与优缺点

• 优点：

  • 查找、插入和删除操作的时间复杂度在理想情况下均可达到O(log n)，其中n代表树中节点的数量，这是因为每次比较都能排除一半的数据。
  • 能够自动保持数据有序，便于进行范围查询。

• 缺点：

  • 当数据分布不均匀时，二叉排序树可能退化成链表形态，导致查找效率降低到O(n)。
  • 插入和删除操作可能导致树频繁地不平衡，从而影响整体性能。

四、改进型二叉排序树

为了克服二叉排序树在最坏情况下的性能问题，出现了许多改进型的二叉排序树，例如：

• 自平衡二叉排序树（如AVL树、红黑树等）：通过引入额外的平衡条件和旋转操作来确保树的高度始终保持在对数级别，从而维持高效的查找、插入和删除性能。

五、二叉排序树的实际应用

二叉排序树广泛应用于软件开发和计算机科学领域，包括但不限于：

• 数据库索引：部分数据库系统利用自平衡二叉排序树实现索引结构，提高数据查询速度。
• 文件系统：某些文件系统使用类似二叉排序树的数据结构组织目录结构，快速定位文件。
• 内存管理：操作系统内核在分配和回收内存时，可能会用到具有排序性质的二叉树结构。

六、二叉排序树的代码实践  

1.节点类

//节点
class Node {
    int value;
    Node lift;
    Node right;

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

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }

    //    二叉排序树添加节点方法
    public void add(Node node) {
        if (node == null) {
            return;
        }
//        判断传入的节点值与当前节点大小的关系
        if (node.value < this.value) {   //小于该节点
//            如果当前节点左子节点为空直接添加在其左子节点
            if (this.lift == null) {
                this.lift = node;
            } else {
//                递归向左
                this.lift.add(node);
            }
        } else {    //大于该节点
//            如果当前节点右子节点为空直接添加在其右子节点
            if (this.right == null) {
                this.right = node;
            } else {
//                递归向右
                this.right.add(node);
            }
        }
    }

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

    //    中序查找删除的节点
    public Node search(int value) {
        if (this.value == value) {
            return this;
        } else if (value < this.value) {
            if (this.lift == null) {
                return null;
            }
            return this.lift.search(value);
        } else {
            if (this.right == null) {
                return null;
            }
            return this.right.search(value);
        }
    }

    //    查找删除节点的父节点
    public Node searchParent(int value) {
        if ((this.lift != null && this.lift.value == value) ||
                (this.right != null && this.right.value == value)) {
            return this;    //该节点就是删除节点的父节点
        } else {
            if (value < this.value && this.lift != null) {   //向左递归
                return this.lift.searchParent(value);
            } else if (value >= this.value && this.right != null) {  //向右递归
                return this.right.searchParent(value);
            }
        }
        return null;  //没有父节点
    }
}

2.二叉树类添加节点 

class BinarySortTree {
    private Node root;

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

    //    中序遍历
    public void infixOrder() {
        if (root == null) {
            return;
        }
        root.infixOrder();
    }
}

3.删除节点 

    //    查找删除节点
    public Node search(int value) {
        if (root == null) {
            return null;
        }

        return root.search(value);
    }

    //    查找删除节点的父节点
    public Node searchParent(int value) {
        if (root == null) {
            return null;
        }

        return root.searchParent(value);
    }

//    返回以node为根节点的二插排序树的最小节点值
//    删除node为根节点的二叉排序树的最小节点

    /**
     * @param node 传入节点 当做二叉树的根节点
     * @return 以node为根节点二插排序树最小节点值
     */
    public int delRightTreeMin(Node node) {
        Node target = node;
//        循环找左节点就会找到最小值
        while (target.lift != null) {
            target = target.lift;
        }
        deleteNode(target.value);
        return target.value;
    }

    /**
     * @param node 传入节点 当做二叉树的根节点
     * @return 以node为根节点二插排序树最大节点值
     */
    public int delLiftTreeMax(Node node) {
        Node target = node;
        while (target.right != null) {
            target = target.right;
        }
        deleteNode(target.value);
        return target.value;
    }

    //    删除节点
    public void deleteNode(int value) {
        if (root == null) {
            return;
        } else {
//            先找到要删除的节点
            Node targetNode = search(value);
            if (targetNode == null) {
                return;
            }
//            如果发现当前二插排序树没有左子节点且没有右子节点就直接删除该节点
            if (root.lift == null && root.right == null) {
                root = null;
                return;
            }
//            找到要删除节点的父节点
            Node parentNode = searchParent(value);
//            如果删除的节点为叶子节点
            if (targetNode.lift == null && targetNode.right == null) {
//                判断targetNode是parentNode的左子节点还是右子节点
                if (parentNode.lift != null && parentNode.lift.value == value) {
                    parentNode.lift = null;
                } else if (parentNode.right != null && parentNode.right.value == value) {
                    parentNode.right = null;
                }
//                非叶子节点
            } else if (targetNode.lift != null && targetNode.right != null) {    //有两颗子树
//                int minValue = delRightTreeMin(targetNode.right);
//                targetNode.value = minValue;
//                  这里可以有两种方案
                int maxValue = delLiftTreeMax(targetNode.lift);
                targetNode.value = maxValue;
            } else {  //有一颗子树的节点
                if (targetNode.lift != null) {  //要删除的是左子节点
                    if (parentNode != null) {
//                    targetNode 是 parentNode 的左子节点
                        if (parentNode.lift.value == value) {
                            parentNode.lift = targetNode.lift;
                        } else {
                            root = targetNode.lift;
                        }
                    } else {
                        parentNode.right = targetNode.lift;
                    }
                } else {  //要删除的是右子节点
                    if (parentNode != null) {
                        if (parentNode.lift.value == value) {
                            parentNode.lift = targetNode.right;
                        } else {
                            root = targetNode.right;
                        }
                    } else {
                        parentNode.right = targetNode.right;
                    }
                }
            }
        }
    }

七、总结        

        二叉排序树作为一种基础且实用的数据结构，在处理动态集合、提供快速访问、维护数据有序等方面展现出显著优势。尽管在极端情况下存在性能下降的问题，但通过对二叉排序树进行优化和改进，可以使其成为现代计算机科学诸多领域的基石之一。熟练掌握并灵活运用二叉排序树原理及其实现方法，对于提升编程能力和解决实际工程问题至关重要。