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<iostream>
using namespace std;
class node{
public:
  int val;
  node *left, *right;
  node(){left=NULL; right=NULL;}
};

node* rightRoate(node* root){
  node* temp=root->left;
  root->left=temp->right;
  temp->right=root;
  return temp;
}

node* leftRoate(node* root){
  node* temp=root->right;
  root->right=temp->left;
  temp->left=root;
  return temp;
}

node* leftRightRoate(node* root){
   root->left=leftRoate(root->left);
   return rightRoate(root);
}



node* rightLeftRoate(node* root){
   root->right=rightRoate(root->right);
   return leftRoate(root);
}

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

node* insert(node* root, int val){
  if(root==NULL){
    node *newnode=new node();
    newnode->val=val;
    return newnode;
  }
  if(root->val>val){ 
    root->left=insert(root->left, val);
    if(getHeight(root->left)-getHeight(root->right)>1){
      if(getHeight(root->left->left)>getHeight(root->left->right)) root=rightRoate(root);
      else root=leftRightRoate(root);
    }
  }
  else {
    root->right=insert(root->right, val);
    if(getHeight(root->right)-getHeight(root->left)>1){
      if(getHeight(root->right->right)>getHeight(root->right->left)) root=leftRoate(root);
      else root=rightLeftRoate(root);
    }
  }
  return root;
}


 
int main(){
  node *root=NULL;
  int i, n, t;
  scanf("%d", &n);
  for(i=0; i<n; i++){
    scanf("%d", &t);
    root=insert(root, t);
  }
  printf("%d
", root->val);
  return 0;
}

#include<iostream>
#include<vector>
using namespace std;
struct Node{
  int val, height;
  Node *left, *right;
  Node(int v){val = v; left=right=NULL; height=1;}
};

int getHeight(Node *root){
  return root==NULL ? 0 : root->height;
}

void updateHeight(Node *root){
  int l = getHeight(root->left), r = getHeight(root->right);
  root->height = l>r ? l+1 : r+1;
}

int getBalanceFactor(Node* root){
  return getHeight(root->left) - getHeight(root->right);
}

void leftRoate(Node* &root){
  Node *temp = root->right;
  root->right = temp->left;
  temp->left = root;
  updateHeight(root);
  updateHeight(temp);
  root = temp;
}

void rightRoate(Node* &root){
  Node *temp = root->left;
  root->left = temp->right;
  temp->right = root;
  updateHeight(root);
  updateHeight(temp);
  root = temp;
}

void insertNode(Node* &root, int val){
  if(root==NULL){
    root = new Node(val);
    return;
  }
  if(val<root->val){
    insertNode(root->left, val);
    updateHeight(root);//插入新节点后不要忘记更新根节点的高度
    if(getBalanceFactor(root)==2){//调节不平衡的二叉树
      if(getBalanceFactor(root->left)==1) rightRoate(root);
      else{
        leftRoate(root->left);
        rightRoate(root);
      }
    }
  }else{
    insertNode(root->right, val);
    updateHeight(root);
    if(getBalanceFactor(root)==-2){
      if(getBalanceFactor(root->right)==-1) leftRoate(root);
      else{
        rightRoate(root->right);
        leftRoate(root);
      }
    }
  }
}
int main(){
  int n, i;
  scanf("%d", &n);
  Node *root=NULL;
  for(i=0; i<n; i++){
    int val;
    scanf("%d", &val);
    insertNode(root, val);
  }
  printf("%d
", root->val);
  return 0;
}