AVLTree

二叉平衡树 BST树+节点平衡操作（节点平衡 任意节点左右字输的高度不超过1）

AVL树为了维护节点平衡引入了的四种节点旋转操作：

1.左孩子的左子树太高了

// 右旋转操作
child  = node->left;
node->left = child->right;
child->right = node;

 2.右孩子的右子树太高了

// 左旋转操作
child = node->right;
node->right = child->left;
child->left = node;

3.左孩子的右子树太高了

左-右旋转 左平衡操作

4.右孩子的左孩子太高了

右-左旋转 右平衡操作

#include <iostream>
#include <algorithm>

using namespace std;

// AVL树的实现
class AVLTree
{
private:
    struct Node
    {
        int key_;
        Node* left_;
        Node* right_;
        int height_;
        Node(int key) : key_(key), left_(nullptr), right_(nullptr), height_(1) {}
    };

    Node* root_;
public:
    AVLTree() : root_(nullptr) {}
    // 右旋转操作
    Node* rightRotate(Node* node)
    {
        Node* child = node->left_;
        node->left_ = child->right_;
        child->right_ = node;
        // 高度更新
        node->height_ = max(getHeight(node->left_), getHeight(node->right_)) + 1;
        child->height_ = max(getHeight(child->left_), getHeight(child->right_)) + 1;
        return child;
    }

    // 左旋转操作
    Node* leftRotate(Node* node)
    {
        Node* child = node->right_;
        node->right_ = child->left_;
        child->left_ = node;
        // 高度更新
        node->height_ = max(getHeight(node->left_), getHeight(node->right_)) + 1;
        child->height_ = max(getHeight(child->left_), getHeight(child->right_)) + 1;
        return child;
    }

    // 左平衡操作
    Node* leftBalance(Node* node)
    {
        node->left_ = leftRotate(node->left_);
        return rightRotate(node);
    }

    // 右平衡操作
    Node* rightBalance(Node* node)
    {
        node->right_ = rightRotate(node->right_);
        return leftRotate(node);
    }

    // AVL树的插入操作
public:
    Node* insert(Node* node, int key)
    {
        if (node == nullptr)
        {
            return new Node(key);
        }
        if (key < node->key_)
        {
            node->left_ = insert(node->left_, key);
            // 检查是否需要平衡
            if (getHeight(node->left_) - getHeight(node->right_) > 1)
            {
                if(getHeight(node->left_->left_) > getHeight(node->left_->right_))
                    // 左孩子的左子树太高
                    return rightRotate(node);
                else
                    // 左孩子的右子树太高
                    return leftBalance(node);
            }
        }
        else if(key > node->key_)
        {
            node->right_ = insert(node->right_, key);
            // 检查是否需要平衡
            if (getHeight(node->right_) - getHeight(node->left_) > 1)
            {
                if(getHeight(node->right_->right_) > getHeight(node->right_->left_))
                    // 右孩子的右子树太高
                    return leftRotate(node);
                else
                    // 右孩子的左子树太高
                    return rightBalance(node);
            }
        }
        // 因为子树中增加了新的节点，在递归回溯时检测更新节点高度
        node->height_ = max(getHeight(node->left_), getHeight(node->right_)) + 1;
        // 否则，key已经存在于树中，不需要插入
        return node;
    }

    void insert(int key)
    {
        root_ = insert(root_, key);
    }

private:
    // 获取节点的高度
    int getHeight(Node* node)
    {
        // 空节点高度为0
        return node == nullptr ? 0 : node->height_;
    }

    // 遍历并打印AVL树
public:
    void inorderTraversal(Node* node)
    {
        if (node == nullptr)
        {
            return;
        }
        inorderTraversal(node->left_);
        cout << node->key_ << " ";
        inorderTraversal(node->right_);
    }
public:
    Node* getRoot() { return root_; }

    // AVL树的删除操作
    Node* remove(Node* node, int key)
    {
        if (node == nullptr)
        {
            return nullptr;
        }
        if (key < node->key_)
        {
            node->left_ = remove(node->left_, key);

        }
        else if(key > node->key_)
        {
            node->right_ = remove(node->right_, key);
        }
        else
        {
            if(node->left_ != nullptr && node->right_ != nullptr)
            {
                
            }
        }   
    }

    // AVL树的查找操作
};

int main()
{
    AVLTree tree;
    // 插入一些测试数据
    tree.insert(10);
    tree.insert(20);
    tree.insert(30);
    tree.insert(40);
    tree.insert(50);
    tree.insert(25);

    tree.inorderTraversal(tree.getRoot());

    cout << "Test data inserted successfully." << endl;
    return 0;
}