c++实现平衡二叉树

下面是一个简单的C++平衡二叉树的实现示例：

#include <iostream>
#include <cmath>

template<typename T>
struct TreeNode {
    T data;
    TreeNode<T>* left;
    TreeNode<T>* right;

    TreeNode(T val) : data(val), left(nullptr), right(nullptr) {}
};

template<typename T>
class AVLTree {
private:
    TreeNode<T>* root;

    int height(TreeNode<T>* node) {
        if (!node) {
            return 0;
        }
        return 1 + std::max(height(node->left), height(node->right));
    }

    int balanceFactor(TreeNode<T>* node) {
        if (!node) {
            return 0;
        }
        return height(node->left) - height(node->right);
    }

    TreeNode<T>* rotateRight(TreeNode<T>* node) {
        TreeNode<T>* newRoot = node->left;
        node->left = newRoot->right;
        newRoot->right = node;
        return newRoot;
    }

    TreeNode<T>* rotateLeft(TreeNode<T>* node) {
        TreeNode<T>* newRoot = node->right;
        node->right = newRoot->left;
        newRoot->left = node;
        return newRoot;
    }

    TreeNode<T>* insertHelper(TreeNode<T>* node, T val) {
        if (!node) {
            return new TreeNode<T>(val);
        }

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

        int balance = balanceFactor(node);

        // Left Left Case
        if (balance > 1 && val < node->left->data) {
            return rotateRight(node);
        }

        // Right Right Case
        if (balance < -1 && val > node->right->data) {
            return rotateLeft(node);
        }

        // Left Right Case
        if (balance > 1 && val > node->left->data) {
            node->left = rotateLeft(node->left);
            return rotateRight(node);
        }

        // Right Left Case
        if (balance < -1 && val < node->right->data) {
            node->right = rotateRight(node->right);
            return rotateLeft(node);
        }

        return node;
    }

    void inorderHelper(TreeNode<T>* node) {
        if (!node) {
            return;
        }
        inorderHelper(node->left);
        std::cout << node->data << " ";
        inorderHelper(node->right);
    }

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

    void insert(T val) {
        root = insertHelper(root, val);
    }

    void inorderTraversal() {
        inorderHelper(root);
    }
};

int main() {
    AVLTree<int> avl;
    avl.insert(10);
    avl.insert(20);
    avl.insert(30);
    avl.insert(40);
    avl.insert(50);
    avl.insert(25);

    std::cout << "Inorder Traversal of AVL Tree: ";
    avl.inorderTraversal();
    std::cout << std::endl;

    return 0;
}

这个示例实现了一个简单的平衡二叉树，包括插入和中序遍历操作。