AVL树自平衡，白话讲解

调节过程

AVL树：一个平衡因子小于等于1的BST树

平衡调节：小三角形为新插入的节点，圆形为节点，长方形为以h为长度的h个节点

以下都是对于根节点而言的平衡

一.左左

1. 先将b"提"起来
2. 将b的节点的右子树给a的左子树

二.右右

1. 先将b"提"起来
2. 将b的节点的左子树给a的右子树

三.左右

1. 把c单独拉外面去
2. 将c的左子树分给b的右子树，c的右子树分给a的左子树
3. c左右子树分别为b，a

四.右左

1. 把c单独拉外面去
2. 将c的右子树分给b的左子树，c的左子树分给a的右子树
3. c左右子树分别为a，b

例题

1066 Root of AVL Tree

分数 25

An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. Figures 1-4 illustrate the rotation rules.

Now given a sequence of insertions, you are supposed to tell the root of the resulting AVL tree.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤20) which is the total number of keys to be inserted. Then N distinct integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the root of the resulting AVL tree in one line.

Sample Input 1:

5
88 70 61 96 120

Sample Output 1:

70

Sample Input 2:

7
88 70 61 96 120 90 65

Sample Output 2:

88

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

c++代码实现

#include <iostream>
#include <algorithm>
using namespace std;

struct TreeNode {
    int data, lefthight, righthight;
    TreeNode* lchild, * rchild;
};

// 构建 AVL 树
void insert(TreeNode*& root, int i) {
    if (root == nullptr) {
        root = new TreeNode;
        root->data = i;
        root->lchild = root->rchild = nullptr;
        root->lefthight = root->righthight = 0;
    } else {
        if (i >= root->data) {
            insert(root->rchild, i);
            root->righthight = max(root->rchild->lefthight, root->rchild->righthight) + 1;
        } else {
            insert(root->lchild, i);
            root->lefthight = max(root->lchild->lefthight, root->lchild->righthight) + 1;
        }
    }
    // 当某个节点的左子树高度减右子树高度大于1时，进行平衡处理
    if (root->lefthight - root->righthight == 2) {
        if (root->lchild->data > i) { // 左左
            TreeNode* a = root;
            TreeNode* b = root->lchild;
            root = b;
            a->lchild = b->rchild;
            a->lefthight = b->righthight;
            b->rchild = a;
            b->righthight++;
        } else { // 左右
            TreeNode* a = root;
            TreeNode* b = root->lchild;
            TreeNode* c = root->lchild->rchild;
            root = c;
            a->lchild = c->rchild;
            a->lefthight = c->lefthight;
            b->rchild = c->lchild;
            b->righthight = c->lefthight;
            c->lchild = b;
            c->rchild = a;
            c->lefthight = b->lefthight + 1;
            c->righthight = a->righthight + 1;
        }
    } else if (root->lefthight - root->righthight == -2) { // 当某个节点的左子树高度减右子树高度小于-1时，进行平衡处理
        if (i >= root->rchild->data) { // 右右
            TreeNode* a = root;
            TreeNode* b = root->rchild;
            root = b;
            a->rchild = b->lchild;
            a->righthight = b->lefthight;
            b->lchild = a;
            b->lefthight++;
        } else { // 右左
            TreeNode* a = root;
            TreeNode* b = root->rchild;
            TreeNode* c = root->rchild->lchild;
            root = c;
            a->rchild = c->lchild;
            a->righthight = c->lefthight;
            b->lchild = c->rchild;
            b->lefthight = c->righthight;
            c->lchild = a;
            c->rchild = b;
            c->lefthight = a->lefthight + 1;
            c->righthight = b->righthight + 1;
        }
    }
}

int main() {
    int n, m;
    cin >> n;
    TreeNode* root = nullptr;
    for (int i = 0; i < n; i++) {
        cin >> m;
        insert(root, m);
    }
    cout << root->data;
    return 0;
}