C/Visual C - Ocupando código en C++ de árbol balanceado

#include <iostream>

// Estructura para representar un nodo del árbol AVL

struct Node {

    int data;

    int height;

    Node* left;

    Node* right;

};

// Función para obtener la altura de un nodo

int getHeight(Node* node) {

    if (node == nullptr) {

        return 0;

    }

    return node->height;

}

// Función para obtener el factor de equilibrio de un nodo

int getBalanceFactor(Node* node) {

    if (node == nullptr) {

        return 0;

    }

    return getHeight(node->left) - getHeight(node->right);

}

// Función para actualizar la altura de un nodo

void updateHeight(Node* node) {

    int leftHeight = getHeight(node->left);

    int rightHeight = getHeight(node->right);

    node->height = std::max(leftHeight, rightHeight) + 1;

}

// Función para realizar una rotación simple a la derecha

Node* rotateRight(Node* node) {

    Node* newRoot = node->left;

    node->left = newRoot->right;

    newRoot->right = node;

    updateHeight(node);

    updateHeight(newRoot);

    return newRoot;

}

// Función para realizar una rotación simple a la izquierda

Node* rotateLeft(Node* node) {

    Node* newRoot = node->right;

    node->right = newRoot->left;

    newRoot->left = node;

    updateHeight(node);

    updateHeight(newRoot);

    return newRoot;

}

// Función para balancear un nodo

Node* balanceNode(Node* node) {

    updateHeight(node);

    int balanceFactor = getBalanceFactor(node);

    if (balanceFactor > 1) {

        if (getBalanceFactor(node->left) < 0) {

            node->left = rotateLeft(node->left);

        }

        return rotateRight(node);

    }

    if (balanceFactor < -1) {

        if (getBalanceFactor(node->right) > 0) {

            node->right = rotateRight(node->right);

        }

        return rotateLeft(node);

    }

    return node;

}

// Función para insertar un nodo en el árbol AVL

Node* insertNode(Node* root, int data) {

    if (root == nullptr) {

        Node* newNode = new Node;

        newNode->data = data;

        newNode->height = 1;

        newNode->left = nullptr;

        newNode->right = nullptr;

        return newNode;

    }

    if (data < root->data) {

        root->left = insertNode(root->left, data);

    } else {

        root->right = insertNode(root->right, data);

    }

    return balanceNode(root);

}

// Función para imprimir el árbol AVL en orden

void printInOrder(Node* root) {

    if (root == nullptr) {

        return;

    }

    printInOrder(root->left);

    std::cout << root->data << " ";

    printInOrder(root->right);

}

int main() {

    Node* root = nullptr;

    // Insertar nodos en el árbol AVL

    root = insertNode(root, 10);

    root = insertNode(root, 20);

    root = insertNode(root, 30);

    root = insertNode(root, 40);

    root = insertNode(root, 50);

    root = insertNode(root, 25);

    // Imprimir el árbol AVL en orden

    std::cout << "Árbol AVL en orden: ";

    printInOrder(root);

    std::cout << std::endl;

    return 0;

}