平衡二叉树打造高效存储与检索，让信息管理轻松便捷

2023-12-29 05:39:34

平衡二叉树是一种独特的二叉搜索树，它具有非常重要的特点，那就是：任意节点的左右子树的高度差最多为1，这使得它在数据存储和检索方面具有卓越的效率。

平衡二叉树的诞生是为了解决二叉搜索树在某些情况下搜索效率低下的问题。在最坏的情况下，二叉搜索树可能会退化为一条链，此时搜索效率会非常低下。而平衡二叉树通过保持树的高度平衡，有效地避免了退化为链的情况，从而保证了搜索效率。

实现平衡二叉树最常用的算法是AVL算法，也是我们今天手写演示的重点。AVL算法的运作原理很简单，它通过在树中插入或删除节点时对树进行调整，以保证树的高度始终保持平衡。

在我们的手写代码中，我们将实现一个简单的BalancedBinaryTree类，该类包含了平衡二叉树的常用操作，包括插入、删除和搜索。同时，我们还提供了一个辅助类AVLNode，用于表示树中的节点。

平衡二叉树在实际应用中非常广泛，例如在数据库索引、文件系统和内存管理等领域。可以说，平衡二叉树是一种非常重要的数据结构，它能够大大提高数据的存储和检索效率。

让我们看看平衡二叉树的代码实现：

public class BalancedBinaryTree {

    private AVLNode root;

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

    private AVLNode insert(AVLNode node, int key, String value) {
        if (node == null) {
            return new AVLNode(key, value);
        }

        if (key < node.key) {
            node.left = insert(node.left, key, value);
        } else if (key > node.key) {
            node.right = insert(node.right, key, value);
        } else {
            node.value = value;
        }

        updateHeight(node);
        return balance(node);
    }

    public String search(int key) {
        AVLNode node = search(root, key);
        return node == null ? null : node.value;
    }

    private AVLNode search(AVLNode node, int key) {
        if (node == null) {
            return null;
        }

        if (key < node.key) {
            return search(node.left, key);
        } else if (key > node.key) {
            return search(node.right, key);
        } else {
            return node;
        }
    }

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

    private AVLNode delete(AVLNode node, int key) {
        if (node == null) {
            return null;
        }

        if (key < node.key) {
            node.left = delete(node.left, key);
        } else if (key > node.key) {
            node.right = delete(node.right, key);
        } else {
            if (node.left == null) {
                return node.right;
            } else if (node.right == null) {
                return node.left;
            } else {
                AVLNode successor = findSuccessor(node.right);
                node.key = successor.key;
                node.value = successor.value;
                node.right = delete(node.right, successor.key);
            }
        }

        updateHeight(node);
        return balance(node);
    }

    private AVLNode findSuccessor(AVLNode node) {
        if (node.left == null) {
            return node;
        }

        return findSuccessor(node.left);
    }

    private void updateHeight(AVLNode node) {
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
    }

    private int getHeight(AVLNode node) {
        return node == null ? 0 : node.height;
    }

    private AVLNode balance(AVLNode node) {
        int balanceFactor = getBalanceFactor(node);

        if (balanceFactor > 1) {
            if (getBalanceFactor(node.left) < 0) {
                node.left = leftRotate(node.left);
            }
            return rightRotate(node);
        } else if (balanceFactor < -1) {
            if (getBalanceFactor(node.right) > 0) {
                node.right = rightRotate(node.right);
            }
            return leftRotate(node);
        }

        return node;
    }

    private int getBalanceFactor(AVLNode node) {
        return getHeight(node.left) - getHeight(node.right);
    }

    private AVLNode leftRotate(AVLNode node) {
        AVLNode rightChild = node.right;
        node.right = rightChild.left;
        rightChild.left = node;

        updateHeight(node);
        updateHeight(rightChild);

        return rightChild;
    }

    private AVLNode rightRotate(AVLNode node) {
        AVLNode leftChild = node.left;
        node.left = leftChild.right;
        leftChild.right = node;

        updateHeight(node);
        updateHeight(leftChild);

        return leftChild;
    }

    private static class AVLNode {

        private int key;
        private String value;
        private AVLNode left;
        private AVLNode right;
        private int height;

        public AVLNode(int key, String value) {
            this.key = key;
            this.value = value;
            this.height = 1;
        }
    }
}