平衡树模版

平衡树是一种保持二叉搜索树平衡的数据结构。其中AVL树是最常见的平衡树之一。以下是一个简单的AVL树模板的C++实现：

#include <iostream>
#include <algorithm>

using namespace std;

struct Node {
    int key;
    int height;
    Node* left;
    Node* right;

    Node(int k) : key(k), height(1), left(nullptr), right(nullptr) {}
};

class AVLTree {
private:
    Node* root;

    int getHeight(Node* node) {
        if (node == nullptr) {
            return 0;
        }
        return node->height;
    }

    int getBalanceFactor(Node* node) {
        if (node == nullptr) {
            return 0;
        }
        return getHeight(node->left) - getHeight(node->right);
    }

    Node* rightRotate(Node* node) {
        Node* newRoot = node->left;
        node->left = newRoot->right;
        newRoot->right = node;
        node->height = 1 + max(getHeight(node->left), getHeight(node->right));
        newRoot->height = 1+ max(getHeight(newRoot->left), getHeight(newRoot->right));
        return newRoot;
    }

    Node* leftRotate(Node* node) {
        Node* newRoot = node->right;
        node->right = newRoot->left;
        newRoot->left = node;
        node->height = 1 + max(getHeight(node->left), getHeight(node->right));
        newRoot->height = 1 + max(getHeight(newRoot->left), getHeight(newRoot->right));
        return newRoot; 
    }

    Node* insertHelper(Node* node, int key) {
        if (node == nullptr) {
            return new Node(key);
        }

        if (key < node->key) {
            node->left = insertHelper(node->left, key);
        } else if (key > node->key) {
            node->right = insertHelper(node->right, key);
        } else {
            return node;
        }

        node->height = 1 + max(getHeight(node->left), getHeight(node->right));

        int balanceFactor = getBalanceFactor(node);

        if (balanceFactor > 1 && key < node->left->key) {
            return rightRotate(node);
        }

        if (balanceFactor < -1 && key > node->right->key) {
            return leftRotate(node);
        }

        if (balanceFactor > 1 && key > node->left->key) {
            node->left = leftRotate(node->left);
            return rightRotate(node);
        }

        if (balanceFactor < -1 && key < node->right->key) {
            node->right = rightRotate(node->right);
            return leftRotate(node);
        }

        return node;
    }

    Node* removeHelper(Node* node, int key) {
        if (node == nullptr) {
            return nullptr;
        }

        if (key < node->key) {
            node->left = removeHelper(node->left, key);
        } else if (key > node->key) {
            node->right = removeHelper(node->right, key);
        } else {
            if (node->left == nullptr && node->right == nullptr) {
                delete node;
                return nullptr;
            } else if (node->left == nullptr) {
                Node* temp = node->right;
                delete node;
                return temp;
            } else if (node->right == nullptr) {
                Node* temp = node->left;
                delete node;
                return temp;
            } else {
                Node* minRightNode = findMin(node->right);
                node->key = minRightNode->key;
                node->right = removeHelper(node->right, minRightNode->key);
            }
        }

        node->height = 1 + max(getHeight(node->left), getHeight(node->right));

        int balanceFactor = getBalanceFactor(node);

        if (balanceFactor > 1 && getBalanceFactor(node->left) >= 0) {
            return rightRotate(node);
        }

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

        if (balanceFactor < -1 && getBalanceFactor(node->right) <= 0) {
            return leftRotate(node);
        }

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

        return node;
    }

    Node* findMin(Node* node) {
        if (node == nullptr) {
            return nullptr;
        }
        while (node->left != nullptr) {
            node = node->left;
        }
        return node;
    }

public:
    AVLTree() : root(nullptr) {}

    void insert(int key) {
        root = insertHelper(root, key);
    }

    void remove(int key) {
        root = removeHelper(root, key);
    }

    void inorderTraversal() {
        inorderHelper(root);
    }

    void inorderHelper(Node* node) {
        if (node == nullptr) {
            return;
        }

        inorderHelper(node->left);
        cout << node->key << " ";
        inorderHelper(node->right);
    }
};

int main() {
    AVLTree avlTree;

    avlTree.insert(50);
    avlTree.insert(30);
    avlTree.insert(70);
    avlTree.insert(20);
    avlTree.insert(40);
    avlTree.insert(60);
    avlTree.insert(80);
    
    cout << "Inorder traversal: ";
    avlTree.inorderTraversal();
    cout << endl;

    avlTree.remove(30);
  
    cout << "Inorder traversal after removing 30: ";
    avlTree.inorderTraversal();
    cout << endl;

    return 0;
}

在这个示例中，我们定义了一个`Node`结构体来表示树的节点，包括键值`key`、高度`height`和左右子节点`left`和`right`。然后，我们定义了一个`AVLTree`类，其中包含了一些基本的操作，如`insert`插入节点，`remove`删除节点和`inorderTraversal`中序遍历等。通过计算节点的高度和平衡因子，我们根据不同情况进行旋转操作来保持树的平衡。最后，在主函数中我们演示了如何使用AVL树进行插入和删除操作，并进行中序遍历输出结果。