A1123 Is It a Complete AVL Tree (30 分| AVL树| 完全二叉树| 层次遍历，附详细注释，逻辑分析)

原创

nkgines 2022-08-23 17:18:32 博主文章分类：PAT（甲级） ©著作权

文章标签 A1123 AVL树层次遍历 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者nkgines的原创作品，请联系作者获取转载授权，否则将追究法律责任

写在前面

思路分析

判断是不是完全二叉树

出现1个孩⼦为空的结点之后是否还会出现孩子结点不为空的结点，如果出现就不是完全⼆叉树

AVL树共四种情况，发现树不平衡的结点记为A结点， A发现树不不平衡的情况有四种：

新结点插入到A的左子树的左子树-右旋
新结点插入到A的左子树的右子树-A的左子树左旋，然后对A右旋
新结点插入到A的右子树的左子树-A的右子树右旋，然后对A左旋
新结点插入到A的右子树的右子树-左旋

知识盲点，学习ing

难度较大，代码量较大

测试用例

input:
5
88 70 61 63 65

output:
70 63 88 61 65
YES

input:
8
88 70 61 96 120 90 65 68

output:
88 65 96 61 70 90 120 68

ac代码

#include <iostream>
#include <vector>
#include <queue>

using namespace std;
struct node
{
    int val;
    struct node *left, *right;
};

node* leftRotate(node *tree)
{
    node *tmp = tree->right;
    tree->right = tmp->left;
    tmp->left = tree;

    return tmp;
}

node* rightRotate(node *tree)
{
    node *tmp = tree->left;
    tree->left = tmp->right;
    tmp->right = tree;
    return tmp;
}
node* leftRightRotate(node *tree)
{
    tree->left = leftRotate(tree->left);
    return rightRotate(tree);
}
node* rightLeftRotate(node *tree)
{
    tree->right = rightRotate(tree->right);
    return leftRotate(tree);
}
int getHeight(node *tree)
{
    if(tree == NULL) return 0;
    int l = getHeight(tree->left);
    int r = getHeight(tree->right);

    return max(l, r)+1;
}
node* inserts(node *tree, int val)
{
    if(tree == NULL)
    {
        tree = new node();
        tree->val = val;
    }
    else if(tree->val > val)
    {
        tree->left = inserts(tree->left, val);
        int l = getHeight(tree->left), r = getHeight(tree->right);

        if(l-r>=2)
        {
            if(val < tree->left->val)
                tree = rightRotate(tree);
            else
                tree = leftRightRotate(tree);
        }
    }
    else
    {
        tree->right = inserts(tree->right, val);
        int l=getHeight(tree->left), r = getHeight(tree->right);
        if(r-l >= 2)
        {
            if(val>tree->right->val)
                tree = leftRotate(tree);
            else
                tree = rightLeftRotate(tree);
        }
    }

    return tree;
}
int isComplete = 1, after = 0;
vector<int> levelOrder(node *tree)
{
    vector<int> v;
    queue<node *> queues;
    queues.push(tree);

    while(!queues.empty())
    {
        node *tmp = queues.front();
        queues.pop();
        v.push_back(tmp->val);
        if(tmp->left != NULL)
        {
            if(after) isComplete = 0;
            queues.push(tmp->left);
        }
        else
            after = 1;
        if(tmp->right != NULL)
        {
            if(after) isComplete = 0;
            queues.push(tmp->right);
        }
        else
            after = 1;
    }

    return v;
}

int main()
{
    int n, tmp;
    scanf("%d", &n);

    node *tree = NULL;
    for(int i=0; i<n; i++)
    {
        scanf("%d", &tmp);
        tree = inserts(tree, tmp);
    }
    vector<int> v = levelOrder(tree);
    for(int i=0; i<v.size(); i++)
    {
        if(i!=0) printf(" ");
        printf("%d", v[i]);
    }
    printf("\n%s", isComplete ? "YES" : "NO");

    return 0;
}