1066 Root of AVL Tree （25 分）

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

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
struct Node
{
    int data;
    Node *l;
    Node *r;
    int high;
    Node()
    {
        l=NULL;
        r=NULL;
        high=0;
    }
};
int height(Node* root)
{
    if(root==NULL)return -1;
    else return root->high;
}
Node* fr(Node *root)
{
    Node *lson=root->l;
    root->l=lson->r;
    lson->r=root;
    root->high=max(height(root->l),height(root->r))+1;
    lson->high=max(height(lson->l),height(lson->r))+1;
    return lson;
}
Node* fl(Node *root)
{
    Node *rson=root->r;
    root->r=rson->l;
    rson->l=root;
    root->high=max(height(root->l),height(root->r))+1;
    rson->high=max(height(rson->l),height(rson->r))+1;
    return rson;
}
Node* flr(Node *root)
{
    root->l=fl(root->l);
    return fr(root);
}
Node* frl(Node *root)
{
    root->r=fr(root->r);
    return fl(root);
}
Node* _insert(Node *root,int val)
{
    if(root==NULL)
    {
        root=new Node;
        root->data=val;
        root->l=NULL;
        root->r=NULL;
    }else if(val<root->data)
    {
        root->l=_insert(root->l,val);
        if(fabs(height(root->l)-height(root->r))==2)
        {
            if(val<root->l->data)root=fr(root);
            else root=flr(root);
        }
    }else
    {
        root->r=_insert(root->r,val);
        if(fabs(height(root->l)-height(root->r))==2)
        {
            if(val>root->r->data)root=fl(root);
            else root=frl(root);
        }
    }
    root->high=max(height(root->l),height(root->r))+1;
    return root;
}
int main()
{
    int n;
    scanf("%d",&n);
    int a[25];
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    Node *root;
    root=NULL;
    for(int i=0;i<n;i++)
    {
        root=_insert(root,a[i]);
    }
    printf("%d\n",root->data);
    return 0;
}