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 ythe 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
Root of AVL Tree (25)

/*************************************************************
Author : qmeng
MailTo : qmeng1128@163.com
QQ     : 1163306125
Blog   : http://blog.csdn.net/Mq_Go/
Create : 2018-03-04 22:56:03
Version: 1.0
**************************************************************/
#include <cstdio>
#include <iostream>
using namespace std;
struct Node{
    int value;
    Node *left;
    Node *right;
    Node(){
        left = right = NULL;
    }
};

int height(Node* root){
    if(root == NULL)return -1;
    else {
        int l = height(root->left);
        int r = height(root->right);
        return l>r ? l+1 : r+1; 
    }
}

Node* LL(Node* k1){
    Node* k2;
    k2 = k1->left;
    k1->left = k2->right;
    k2->right = k1;
    return k2;
}
Node* RR(Node* k1){
    Node* k2;
    k2 = k1->right;
    k1->right = k2->left;
    k2->left = k1;
    return k2;
}
Node* LR(Node* k3){
    k3->left = RR(k3->left);
    return LL(k3);
}
Node* RL(Node* k3){
    k3->right = LL(k3->right);
    return RR(k3);
}
Node* Insert(Node* root,int value){
    if(root == NULL){
        Node* node = new Node;
        node->value = value;
        return node;
    }else if(value < root->value){
        root->left = Insert(root->left,value);
        if(height(root->left) - height(root->right)==2){
            if(value < root->left->value)root = LL(root);
            else root = LR(root);
        }
        return root;    
    }else{
        root->right = Insert(root->right, value);
        if (height(root->right) - height(root->left) == 2){
            if (value > root->right->value)root = RR(root);
            else root = RL(root);
        }
        return root;
    }
}
int main(){
    int n;
    cin >> n;

    Node* root = NULL;
    for (int i = 0; i < n; i++)
    {
        int value;
        cin >> value;
        root = Insert(root, value);
    }

    cout << root->value;
    return 0;
}