pat 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

avl树。

链接：http://www.cppblog.com/cxiaojia/archive/2013/07/22/187776.html

#include<iostream>
using namespace std;
#include<stdio.h>
#include<vector>
#include<map>
#include<math.h>
#include<queue>
#include<string.h>
#define MS(a,b) memset(a,b,sizeof(a))
#include<algorithm>
int n;
struct node
{
  int value,height;
  node *left,*right;
  node(int u):value(u),left(NULL),right(NULL),height(0){}
};
int high(node *t)
{
    if(t==NULL)return -1;
    else return t->height;
}
bool isbalanced(node *left,node *right)
{
  return abs(high(left)-high(right))<2;
}
node *Single_LL(node *t2)
{
    node *t1;
    t1=t2->left;
    t2->left=t1->right;
    t1->right=t2;
    t2->height=max(high(t2->left),high(t2->right))+1;
    t1->height=max(high(t1->left),high(t1->right))+1;
    return t1;
}
node *Single_RR(node *t2)
{
    node *t1;
    t1=t2->right;
    t2->right=t1->left;
    t1->left=t2;
    t2->height=max(high(t2->left),high(t2->right))+1;
    t1->height=max(high(t1->left),high(t1->right))+1;
    return t1;
}
node *Double_LR(node *t3)
{
   t3->left=Single_RR(t3->left);
   return Single_LL(t3);
}
node *Double_RL(node *t3)
{
  t3->right=Single_LL(t3->right);
  return Single_RR(t3);
}
node *insert1(int u,node *rt)
{
    if(rt==NULL)
    {
      rt=new node(u);
      return rt;
    }
  if(u>rt->value)
  {
    rt->right=insert1(u,rt->right);
    if(!isbalanced(rt->left,rt->right))
       if(u>rt->right->value)
             rt=Single_RR(rt);
       else rt=Double_RL(rt);
  }
  else
  {
     rt->left=insert1(u,rt->left);
     if(!isbalanced(rt->left,rt->right))
          if(u<rt->left->value)
             rt=Single_LL(rt);
          else rt=Double_LR(rt);
  }
   rt->height=max(high(rt->left),high(rt->right))+1;
   return rt;
}
int main()
{
    int i,num;
    scanf("%d",&n);
    node *rt=NULL;
    for(i=0;i<n;i++)
    {
      scanf("%d",&num);
      rt=insert1(num,rt);
    }
    printf("%d\n",rt->value);
    return 0;
}