pat04-树4. Root of AVL Tree (25)

04-树4. Root of AVL Tree (25)

时间限制

100 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

CHEN, Yue

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

---

提交代码

平衡二叉树的建立、插入、更新。

 #include<cstdio>
 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<queue>
 #include<vector>
 using namespace std;
 int num;
 struct node{
     int v,h;
     node *l,*r;
     node(){
         l=r=NULL;
         h=;
     }
 };
 int max(int a,int b){
     if(a>b){
         return a;
     }
     else{
         return b;
     }
 }
 int GetHigh(node *h){
     if(!h){
         return ;
     }
     return h->h;
 }
 void LeftRotation(node *&h){
     node *p=h->l;
     h->l=p->r;
     p->r=h;
     h=p;
     h->r->h=max(GetHigh(h->r->l),GetHigh(h->r->r))+;
     h->h=max(GetHigh(h->l),GetHigh(h->r))+;
 }
 void RightRotation(node *&h){
     node *p=h->r;
     h->r=p->l;
     p->l=h;
     h=p;
     h->l->h=max(GetHigh(h->l->l),GetHigh(h->l->r))+;
     h->h=max(GetHigh(h->l),GetHigh(h->r))+;
 }
 void RightLeftRotation(node *&h){
     LeftRotation(h->r);
     //h->h=max(GetHigh(h->l),GetHigh(h->r))+1;
     RightRotation(h);
 }
 void LeftRightRotation(node *&h){
     RightRotation(h->l);
     //h->h=max(GetHigh(h->l),GetHigh(h->r))+1;
     LeftRotation(h);
 }
 void AVLInsert(int v,node *&h){
     if(!h){//已经到了最底层
         h=new node();
         h->v=v;
         return;
     }
     //bool can=false;
     if(v<h->v){
         AVLInsert(v,h->l);
         if(GetHigh(h->l)-GetHigh(h->r)==){
 
             //can=true;
 
             if(v<h->l->v){//左单旋
                 LeftRotation(h);
             }
             else{//左右双旋
                 LeftRightRotation(h);
             }
         }
     }
     else{
         AVLInsert(v,h->r);
         if(GetHigh(h->l)-GetHigh(h->r)==-){
 
             //can=true;
 
             if(v>h->r->v){//左单旋
                 RightRotation(h);
             }
             else{//左右双旋
                 RightLeftRotation(h);
             }
         }
     }
     //if(!can)
     h->h=max(GetHigh(h->l),GetHigh(h->r))+;  //更新树高为1或2的树的树高
 }
 /*void prefind(node *h){
     if(h){
         //cout<<11<<endl;
         cout<<h->v<<endl;
         prefind(h->l);
         prefind(h->r);
     }
 }*/
 int main(){
     //freopen("D:\\INPUT.txt","r",stdin);
     int n;
     while(scanf("%d",&n)!=EOF){
         node *h=NULL;
         int i;
         for(i=;i<n;i++){
             scanf("%d",&num);
             AVLInsert(num,h);
         }
 
         //prefind(h);    //检测
 
         printf("%d\n",h->v);
     }
     return ;
 }

模板：

 typedef struct AVLTreeNode *AVLTree;
 typedef struct AVLTreeNode{
    ElementType Data;
 4    AVLTree Left;
    AVLTree Right;
    int Height;
 };
 AVLTree AVL_Insertion ( ElementType X, AVLTree T )
 { /* 将 X 插入 AVL 树 T 中，并且返回调整后的 AVL 树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLTreeNode));
        T->Data = X;
        T->Height = ;
 　　　　T->Left = T->Right = NULL;
 } /* if (插入空树) 结束 */
 else if (X < T->Data) { /* 插入 T 的左子树 */
 　　　　T->Left = AVL_Insertion(X, T->Left);
 　　　　if (GetHeight(T->Left) - GetHeight(T->Right) ==  )
 　　　　/* 需要左旋 */
 　　　　　　if (X < T->Left->Data)
 　　　　　　　　T = SingleLeftRotation(T); /* 左单旋 */
 　　　　　　else
 　　　　　　　　T = DoubleLeftRightRotation(T); /* 左-右双旋 */
 } /* else if (插入左子树) 结束 */
 else if (X > T->Data) { /* 插入 T 的右子树 */
 　　　　T->Right = AVL_Insertion(X, T->Right);
 　　　　if (GetHeight(T->Left) - GetHeight(T->Right) == - )
 　　　　/* 需要右旋 */
 　　　　　　if (X > T->Right->Data)
30　　　　　　　　 T = SingleRightRotation(T); /* 右单旋 */
 　　　　　　else
 　　　　　　　　T = DoubleRightLeftRotation(T); /* 右-左双旋 */
 } /* else if (插入右子树) 结束 */
 /* else X == T->Data，无须插入 */
 T->Height = Max(GetHeight(T->Left),GetHeight(T->Right))+;
 /*更新树高*/
 return T;
 }
 AVLTree SingleLeftRotation ( AVLTree A )
 { /* 注意： A 必须有一个左子结点 B */
 　　/* 将 A 与 B 做如图 4.35 所示的左单旋，更新 A 与 B 的高度，返回新的根结点 B */
 　　　　AVLTree B = A->Left;
 　　　　A->Left = B->Right;
 　　　　B->Right = A;
 　　　　A->Height = Max(GetHeight(A->Left), GetHeight(A->Right))+;
 　　　　B->Height = Max(GetHeight(B->Left), A->Height)+;
 　　　　return B;
 }
 AVLTree DoubleLeftRightRotation ( AVLTree A )
 { /* 注意： A 必须有一个左子结点 B，且 B 必须有一个右子结点 C */
 　　/* 将 A、 B 与 C 做如图 4.38 所示的两次单旋，返回新的根结点 C */
 　　　　A->Left = SingleRightRotation(A->Left); /*将 B 与 C 做右单旋， C 被返回*/
 　　　　return SingleLeftRotation(A); /*将 A 与 C 做左单旋， C 被返回*/
 }