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 688

  1 #include<iostream>  2 #include<vector>

#include<algorithm>
#include<queue>
#include<stack>
using namespace std;

class Node{
public:
    int value;
    bool vis;
    Node *left, *right;
    Node(){left = NULL; right = NULL; vis = true;}
};


Node* roateLeft(Node* root) {
    Node* t = root->right;
    root->right = t->left;
    t->left = root;
    return t;
}

Node* roateRight(Node* root){
    Node* t = root->left;
    root->left = t->right;
    t->right = root;
    return t;
}

Node* roateRightLeft(Node* root){
    root->right = roateRight(root->right);
    return roateLeft(root);
}

Node* roateLeftRight(Node* root){
    root->left = roateLeft(root->left);
    return roateRight(root);
}

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

Node* build(Node* root, int value){
    if(root == NULL) {
        root = new Node();
        root->value = value;
    } else if(root->value > value){
        root->left = build(root->left, value);
        if(getHeight(root->left) - getHeight(root->right) == 2) {
            if(value < root->left->value) root = roateRight(root);
            else root = roateLeftRight(root);
        }
    }else{
        root->right = build(root->right, value);
        if(getHeight(root->right) - getHeight(root->left) == 2) {
            if(value < root->right->value) root = roateRightLeft(root);
            else root = roateLeft(root);
        }
    }
    return root;
}

int main(){
   Node* root = NULL;
　　　　int n, i;
　　　　cin>>n;
　　　　for(i = 0; i < n; i++){
　　　　　　int temp;
　　　　　　cin>>temp;
　　　　　　root = build(root, temp);
　　　　}
　　　　cout<<root->val;
return 0;}