AVL树之Java实现解说

后端

2024-01-28 23:40:01

认识 AVL 树：一种自平衡二叉搜索树

在计算机科学领域，AVL 树是二叉搜索树家族中一颗璀璨的明珠。它由 G.M. Adelson-Velsky 和 E.M. Landis 于 1962 年发明，自此以后，它便凭借其卓越的平衡性和高效的查询性能而闻名遐迩。

AVL 树的本质

AVL 树是一种特殊的二叉搜索树，其中每个节点都满足以下两个关键特性：

平衡因子： 一个节点的平衡因子是其左子树和右子树的高度差。对于 AVL 树，这个值必须始终在 -1 和 1 之间。
自平衡： 如果一个节点的平衡因子超出范围，AVL 树会通过旋转操作自动重新平衡自身，从而保持其结构。

AVL 树的实现

在 Java 中，我们可以使用以下类来实现 AVL 树：

public class AVLTree<T extends Comparable<T>> {

    // AVL 树的根节点
    private Node<T> root;

    // 插入一个新元素
    public void insert(T value) {
        root = insert(root, value);
    }

    // 递归插入函数
    private Node<T> insert(Node<T> node, T value) {
        // 空节点，创建新节点
        if (node == null) {
            return new Node<T>(value);
        }

        // 递归插入
        if (value.compareTo(node.value) < 0) {
            node.left = insert(node.left, value);
        } else if (value.compareTo(node.value) > 0) {
            node.right = insert(node.right, value);
        } else {
            // 值已存在，不插入
            return node;
        }

        // 更新节点高度
        node.height = Math.max(height(node.left), height(node.right)) + 1;

        // 检查平衡因子是否超出范围
        int balanceFactor = getBalanceFactor(node);
        if (balanceFactor > 1) {
            // 左单旋或右左双旋
            if (value.compareTo(node.left.value) < 0) {
                return leftRotate(node);
            } else {
                node.left = rightRotate(node.left);
                return leftRotate(node);
            }
        } else if (balanceFactor < -1) {
            // 右单旋或左右双旋
            if (value.compareTo(node.right.value) > 0) {
                return rightRotate(node);
            } else {
                node.right = leftRotate(node.right);
                return rightRotate(node);
            }
        }

        // 平衡因子在范围内，返回节点
        return node;
    }

    // 左单旋
    private Node<T> leftRotate(Node<T> node) {
        // 保存右子树的根节点
        Node<T> newRoot = node.right;

        // 将右子树的左子树作为当前节点的右子树
        node.right = newRoot.left;

        // 将右子树的根节点作为当前节点的父节点
        newRoot.left = node;

        // 更新高度
        node.height = Math.max(height(node.left), height(node.right)) + 1;
        newRoot.height = Math.max(height(newRoot.left), height(newRoot.right)) + 1;

        // 返回新的根节点
        return newRoot;
    }

    // 右单旋
    private Node<T> rightRotate(Node<T> node) {
        // 保存左子树的根节点
        Node<T> newRoot = node.left;

        // 将左子树的右子树作为当前节点的左子树
        node.left = newRoot.right;

        // 将左子树的根节点作为当前节点的父节点
        newRoot.right = node;

        // 更新高度
        node.height = Math.max(height(node.left), height(node.right)) + 1;
        newRoot.height = Math.max(height(newRoot.left), height(newRoot.right)) + 1;

        // 返回新的根节点
        return newRoot;
    }

    // 获取平衡因子
    private int getBalanceFactor(Node<T> node) {
        return height(node.left) - height(node.right);
    }

    // 获取节点高度
    private int height(Node<T> node) {
        return node == null ? 0 : node.height;
    }

    // AVL 树节点类
    private static class Node<T> {
        private T value;
        private Node<T> left;
        private Node<T> right;
        private int height;

        public Node(T value) {
            this.value = value;
            this.height = 1;
        }
    }
}