AVL 트리(균형 이진 트리)에 대한 자세한 설명 | C/C++ 구현

자연

균형 요소의 개념은 BST 트리를 기반으로 도입되었으며, 어떤 노드의 왼쪽 및 오른쪽 하위 트리 사이의 높이 차이가 1을 초과하지 않아야 합니다.

회전이 필요한 네 가지 상황

• 왼쪽 자식 왼쪽 자식 트리가 너무 큽니다: 오른 손잡이
• 오른쪽 자식 오른쪽 자식 트리가 너무 큽니다: 왼손잡이
• 왼쪽 자식의 오른쪽 하위 트리가 너무 높습니다. 먼저 왼쪽 자식을 왼쪽으로 회전한 다음 현재 노드를 오른쪽으로 회전합니다(왼쪽 균형).
• 오른쪽 자식의 왼쪽 하위 트리가 너무 높습니다. 먼저 오른쪽 자식으로 오른쪽으로 돌린 다음 현재 노드로 왼쪽으로 돌립니다(오른쪽 균형).

#include <iostream>
#include <cmath>
#include <algorithm>

using namespace std;

// 定义节点类型
template<typename T>
struct Node {
    Node(T data = T()) : data_(data), left_(nullptr), right_(nullptr), height_(1) {}
    T data_;
    Node* left_;
    Node* right_;
    int height_; // 记录节点的高度
};

// AVL树
template<typename T>
class AVLTree {
public:
    AVLTree() : root_(nullptr) {}
    // 插入
    void insert(const T& val) {
        root_ = insert(root_,val);
    }
    // 删除
    void remove(const T& val) {
        root_ = remove(root_,val);
    }
private:
    Node<T>* root_; // 根节点
    // 返回节点的高度
    int height(Node<T> *node) {
        return node == nullptr ? 0 : node->height_;
    }
    // 右旋
    Node<T>* rightRotate(Node<T>* node);
    // 左旋
    Node<T>* leftRotate(Node<T>* node);
    // 左平衡
    Node<T>* leftBalance(Node<T>* node);
    // 右平衡
    Node<T>* rightBalance(Node<T>* node);
    // 插入
    Node<T>* insert(Node<T>* node, const T& val);
    // 删除
    Node<T>* remove(Node<T>* node, const T& val);
};

// 右旋
template<typename T>
Node<T>* AVLTree<T>::rightRotate(Node<T>* node) {
    // 节点旋转
    Node<T>* child = node->left_;
    node->left_ = child->right_;
    child->right_ = node;
    // 高度更新
    node->height_ = max(height(node->left_), height(node->right_)) + 1;
    child->height_ = max(height(child->left_), height(child->right_)) + 1;
    // 返回旋转后的子树的新根节点
    return child;
}

// 左旋
template<typename T>
Node<T>* AVLTree<T>::leftRotate(Node<T>* node) {
    // 节点旋转
    Node<T> *child = node->left_;
    node->right_ = child->left_;
    child->left_ = node;
    // 高度更新
    node->height_ = max(height(node->left_), height(node->right_)) + 1;
    child->height_ = max(height(child->left_), height(child->right_)) + 1;
    // 返回旋转后的子树的新根节点
    return child;
}

// 左平衡 先对node的左子树左旋，再对node右旋
template<typename T>
Node<T>* AVLTree<T>::leftBalance(Node<T> *node) {
    node->left_ = leftRotate(node->left_);
    return rightRotate(node);
}

// 右平衡 先对node的右子树右旋，再对node左旋
template<typename T>
Node<T>* AVLTree<T>::rightBalance(Node<T> *node) {
    node->right_ = rightRotate(node->right_);
    return leftRotate(node);
}

// 插入
template<typename T>
Node<T>* AVLTree<T>::insert(Node<T> *node, const T &val) {
    // 递归结束 找到插入的位置
    if (node == nullptr) return new Node<T>(val);

    if (node->data_ > val) {
        node->left_ = insert(node->left_,val);
        // 判断是否失衡
        if (height(node->left_) - height(node->right_) > 1) {
            if (height(node->left_->left_) >= height(node->left_->right_)) {
                // 左孩子的左子树太高
                node = rightRotate(node);
            } else {
                // 左孩子的右子树太高
                node = leftBalance(node);
            }
        }
    } else if (node->data_ < val) {
        node->right_ = insert(node->right_,val);
        if (height(node->right_) - height(node->left_) > 1) {
            if (height(node->right_->right_) >= height(node->right_->left_)) {
                node = leftRotate(node);
            } else {
                node = rightBalance(node);
            }
        }
    } else {
        // 找到相同节点 不需要向下递归 直接向上回溯
    }

    // 因为子树添加了新的节点 所以在递归的时候需要更新节点高度
    node->height_ = max(height(node->left_), height(node->right_)) + 1;

    return node;
}

// 删除操作 从叶子节点中选出一个节点 进行替换
template<typename T>
Node<T>* AVLTree<T>::remove(Node<T> *node, const T &val) {
    if (node == nullptr) {
        return nullptr;
    }

    if (node->data_ > val) {
        node->left_ = remove(node->left_,val);
        if (height(node->right_) - height(node->left_) > 1) {
            if (height(node->right_->right_) >= height(node->right_->left_)) {
                node = leftRotate(node);
            } else {
                node = rightBalance(node);
            }
        }
    } else if (node->data_ < val) {
        node->right_ = remove(node->right_,val);
        if (height(node->left_) - height(node->right_) > 1) {
            if (height(node->left_->left_) >= height(node->left_->right_)) {
                node = rightRotate(node);
            } else {
                node = leftBalance(node);
            }
        }
    } else {
        // 找到节点
        // 如果有两个孩子
        if (node->left_ != nullptr && node->right_ != nullptr) {
            // 谁高删谁的节点
            if (height(node->left_) >= height(node->right_)) {
                Node<T>* pre = node->left_;
                while (pre->right_ != nullptr) {
                    pre = pre->right_;
                }
                node->data_ = pre->data_;
                node->left_ = remove(node->left_,pre->data_);
            } else {
                Node<T>* pre = node->right_;
                while (pre->left_ != nullptr) {
                    pre = pre->left_;
                }
                node->data_ = pre->data_;
                node->right_ = remove(node->right_,pre->data_);
            }
        } else {
            // 如果只有一个孩子
            if (node->left_ != nullptr) {
                Node<T>* left = node->left_;
                delete node;
                return left;
            } else if (node->right_ != nullptr) {
                Node<T>* right = node->right_;
                delete node;
                return right;
            } else {
                delete node;
                return nullptr;
            }
        }
    }

    // 更新节点高度
    node->height_ = max(height(node->left_), height(node->right_)) + 1;
    return node;
}

성능 분석

• 노드를 AVL 트리에 삽입하려면 균형을 복원하기 위해 최대 두 번의 회전이 필요합니다.

노드를 삽입하면 노드가 위치한 하위 트리의 높이가 1 증가하지만 회전은 새 노드가 위치한 하위 트리를 1 감소시키므로 AVL 트리에 노드를 삽입하려면 최대 2 회전만 하면 됩니다.

• 노드의 AVL 트리 삭제는 균형을 복원하기 위해 최대 O(logN) 회전이 필요합니다.

노드를 삭제하면 노드가 위치한 서브트리가 1 감소하고, 회전은 노드가 위치한 서브트리를 1 감소하므로 최악의 경우 O(logN) 회전이 필요합니다.

노드 X를 삭제한 후 R4의 균형계수는 -2가 되어 R4는 왼손잡이, R3의 균형계수는 2가 되어 R3은 오른손잡이, R2의 균형계수는 -2가 되어 R2는 왼손잡이가 된다. R1의 밸런스 팩터는 2가 되고 R1은 오른 손잡이

삭제할 노드의 루트 노드에서 부모 노드까지의 밸런스 팩터가 -1과 +1이 번갈아 가면서 노드가 삭제되고 회전이 트리거되면 로그 회전이 필요합니다.