7-12 平衡二叉树的根（AVL树，C++）

将给定的一系列数字插入初始为空的AVL树，请你输出最后生成的AVL树的根结点的值。

输入格式:

输入的第一行给出一个正整数N（≤20），随后一行给出N个不同的整数，其间以空格分隔。

输出格式:

在一行中输出顺序插入上述整数到一棵初始为空的AVL树后，该树的根结点的值。

输入样例1:

5
88 70 61 96 120

输出样例1:

70

输入样例2:

7
88 70 61 96 120 90 65

输出样例2:

88

思路：

这题就是要实现AVL树，直接模拟就行，虽然很麻烦，题主也尝试过STL容器去做，但是STL里面的如set等容器都是基于红黑树实现的，所以没法直接完成。

---

AVL 树

AVL 树是一种自平衡的二叉搜索树，通过在插入节点时进行旋转操作来保持树的平衡性，从而确保树的高度保持在 O(log N) 的水平，提高了查找、插入和删除操作的效率。

在代码中，首先定义了 AVL 树的节点结构 Node，每个节点包含一个整数数据 Data 和指向左右子树的指针 Left 和 Right。然后实现了计算树高度的函数 getHeight，用于计算以当前节点为根的子树的高度。

接着实现了四种旋转操作：LL（左旋转）、RR（右旋转）、LR（左右旋转）和 RL（右左旋转），用于在插入节点后调整树的平衡性。

最后，插入节点的函数 Insert，在插入节点的过程中根据需要进行旋转操作，以保持 AVL 树的平衡性。在主函数中，通过循环输入待插入的节点数据，并调用 Insert 函数完成节点的插入。最后输出根节点的数据。

那LL（左旋转）、RR（右旋转）、LR（左右旋转）和 RL（右左旋转）又是什么呢？

---

左旋和右旋是在 AVL 树中用于保持树的平衡性的重要操作。它们的目的是通过旋转子树的节点来调整树的结构，使得树的左右子树的高度差不超过 1，从而确保整棵树的高度保持在 O(log N) 的水平，来提高树的查找、插入和删除操作的效率。

左旋转（LL旋转）

左旋转是针对某个节点的右子树过高的情况进行的操作。具体步骤如下：

1. 将当前节点的右子树的左子树（如果存在）作为当前节点的右子树。
2. 将当前节点的右子树替换为其原左子树。
3. 更新节点的父节点的指针，使得原右子树的根节点成为当前节点的父节点的左子树。

这样一来，原先右子树过高的节点被左旋转后，高度被调整到合理范围内，使得树保持平衡。

右旋转（RR旋转）

右旋转是针对某个节点的左子树过高的情况进行的操作。具体步骤如下：

1. 将当前节点的左子树的右子树（如果存在）作为当前节点的左子树。
2. 将当前节点的左子树替换为其原右子树。
3. 更新节点的父节点的指针，使得原左子树的根节点成为当前节点的父节点的右子树。

通过右旋转，原先左子树过高的节点被调整到合理范围内，保持了树的平衡性。

左右旋转（LR旋转）和右左旋转（RL旋转）

左右旋转和右左旋转是一种组合操作，它们用于处理某个节点的子树中出现了“左-右”和“右-左”两种情况的不平衡情况。具体步骤和逻辑需要根据具体情况来进行，主要是通过先进行一次左旋转或右旋转，然后再进行一次右旋转或左旋转来实现树的平衡。

总的来说，左旋和右旋是 AVL 树中维持平衡的基本操作，它们通过调整树的结构来确保树的高度保持在合理范围内，从而提高了树的性能。

#include <iostream>
#include <cstdlib>

using namespace std;

// 定义AVL树节点结构
struct Node {
    int Data;      // 节点存储的数据
    Node* Left;    // 指向左子树的指针
    Node* Right;   // 指向右子树的指针
};

// 计算树的高度
int getHeight(Node* T) {
    if (!T) return 0; // 如果节点为空，则返回高度0
    int leftHeight = getHeight(T->Left) + 1;  // 计算左子树的高度并加上当前节点
    int rightHeight = getHeight(T->Right) + 1; // 计算右子树的高度并加上当前节点
    return max(leftHeight, rightHeight);  // 返回左右子树中较大的高度
}

// 左旋转(LL旋转)
Node* LL(Node* T) {
    Node* T1 = T->Right;   // T的右子树
    T->Right = T1->Left;     // 将T的右子树指向T1的左子树
    T1->Left = T;            // 将T1的左子树指向T
    return T1;               // 返回旋转后的根节点
}

// 右旋转(RR旋转)
Node* RR(Node* T) {
    Node* T1 = T->Left;    // T的左子树
    T->Left = T1->Right;     // 将T的左子树指向T1的右子树
    T1->Right = T;           // 将T1的右子树指向T
    return T1;               // 返回旋转后的根节点
}

// 左右旋转(LR旋转)
Node* LR(Node* T) {
    Node* T1 = T->Left, *T2 = T->Left->Right; // T1为T的左子树，T2为T1的右子树
    T1->Right = T2->Left;    // 将T1的右子树指向T2的左子树
    T->Left = T2->Right;     // 将T的左子树指向T2的右子树
    T2->Right = T;           // 将T2的右子树指向T
    T2->Left = T1;           // 将T2的左子树指向T1
    return T2;               // 返回旋转后的根节点
}

// 右左旋转(RL旋转)
Node* RL(Node* T) {
    Node* T1 = T->Right, *T2 = T->Right->Left; // T1为T的右子树，T2为T1的左子树
    T1->Left = T2->Right;    // 将T1的左子树指向T2的右子树
    T->Right = T2->Left;     // 将T的右子树指向T2的左子树
    T2->Left = T;            // 将T2的左子树指向T
    T2->Right = T1;          // 将T2的右子树指向T1
    return T2;               // 返回旋转后的根节点
}

// 插入节点并保持AVL平衡
Node* Insert(Node* T, int x) {
    if (!T) {
        // 创建新节点
        Node* T = new Node;
        T->Data = x;
        T->Left = T->Right = NULL;
        return T;
    } 
    else if (x > T->Data) {
        // 插入到右子树
        T->Right = Insert(T->Right, x);
        if ((getHeight(T->Right) - getHeight(T->Left)) >= 2) {
            // 右子树高度大于左子树，需要进行旋转操作
            if (x > T->Right->Data)
                T = LL(T);
            else T = RL(T);
        }
    } 
    else if (x < T->Data) {
        // 插入到左子树
        T->Left = Insert(T->Left, x);
        if ((getHeight(T->Left) - getHeight(T->Right)) == 2) {
            // 左子树高度大于右子树，需要进行旋转操作
            if (x < T->Left->Data) T = RR(T);
            else T = LR(T);
        }
    }
    return T;
}

int main() {
    int n, x;
    Node* T = NULL;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> x;
        T = Insert(T, x); // 插入节点
    }
    cout << T->Data;  // 输出根节点的数据
    return 0;
}