AVL Tree

來源：sicily

Description

給出結點的插入序列，構造AVL Tree。 

Input

第一行含一個整數t(0<t<10)，爲測試樣例個數。
每個測試樣例包含兩行；第1行爲一個整數n，表示插入的結點數;第2行依照插入順序給出n個結點的數值（整數），之間用一個空格分隔。

Output

對每個測試樣例單獨一行輸出對應AVL Tree的前序遍歷序列，每輸出一個結點的數值（包括最後一個結點），其後輸出一個空格。 
 

Sample Input

2
5
1 2 3 5 4
16
3 2 1 4 5 6 7 16 15 14 13 12 11 10 8 9

Sample Output

2 1 4 3 5 
7 4 2 1 3 6 5 13 11 9 8 10 12 15 14 16

代碼實現：

// Problem#: 19591
// Submission#: 4960420
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <iostream>
using namespace std;
#define DataType int
/*
定義AVL樹的結構體，鏈式
*/
typedef struct AvlNode{
    DataType    data;
    AvlNode    * left;
    AvlNode    * right;
    int height;
}*AvlTree,AvlNode;

//求兩個數的最大值
int Max(int a,int b) {
    return a>b?a:b;
}
//求樹的高度
int Height( AvlTree T) {
    if(NULL == T)
        return -1;
    else
        return T->height;
}

//單旋轉右旋
AvlTree singleRotateWithRight(AvlTree T) {
    AvlTree L = T->left;
    T->left = L->right;
    L->right = T;
    T->height = Max( Height(T->left),Height(T->right) ) + 1;
    L->height = Max( Height(L->left),Height(L->right) ) + 1;
    return L;
}
//單旋轉左旋
AvlTree singleRotateWithLeft(AvlTree T) {
    AvlTree R = T->right;
    T->right = R->left;
    R->left = T;
    T->height = Max( Height(T->left),Height(T->right) ) + 1;
    R->height = Max( Height(R->left),Height(R->right) ) + 1;
    return R;
}
//雙旋轉，先左後右
AvlTree doubleRotateWithLeft(AvlTree T) {
    T->left = singleRotateWithLeft(T->left);
    return singleRotateWithRight(T);
}
//雙旋轉，先右後左
AvlTree doubleRotateWithRight(AvlTree T) {
    T->right = singleRotateWithRight(T->right);
    return singleRotateWithLeft(T);
}
AvlTree AvlTreeInsert(AvlTree T, DataType x) {
    if(T == NULL) {
        T = new AvlNode;
        if(T) {
            T->data = x;
            T->left    = NULL;
            T->right = NULL;
            T->height = 0;
        } else {
            exit(0);
        }
    }
    else if( x < T->data) {
        T->left = AvlTreeInsert(T->left,x);    //先插入，後旋轉
        if(Height(T->left) - Height(T->right) == 2) {
            if(x < T->left->data) {
                T = singleRotateWithRight( T );
            } else {   //左右情況，雙旋轉,先左
                T = doubleRotateWithLeft( T );
            }
        }
    }
    else if( x > T->data ) {
        T->right = AvlTreeInsert(T->right,x);
        if(Height(T->right) - Height(T->left) == 2) {
            if(x > T->right->data) {  //右右情況，進行左旋
                T = singleRotateWithLeft( T );
            } else {
                T = doubleRotateWithRight( T );
            }
        }
    }
    //如果這個數已經存在，那麼不進行插入
    T->height = Max(Height(T->left),Height(T->right)) + 1;
    return T;
}
//前序遍歷
void PrevOrderVisitUseRecur(const AvlTree pCurrent) {
    if(pCurrent) {
        cout << pCurrent->data << " ";
        PrevOrderVisitUseRecur(pCurrent->left);
        PrevOrderVisitUseRecur(pCurrent->right);
    }
}
// 刪除 
void clear(AvlTree root) {
    if (root == NULL) return;
    clear(root->left);
    clear(root->right);
    delete root;
}
int main() {
    int t, n, temp;
    AvlTree root = NULL;
    cin>> t;
    while (t--) {
        cin>> n;
        for (int i= 0; i< n; i++) {
            cin>> temp;
            root = AvlTreeInsert(root, temp);
        }
        PrevOrderVisitUseRecur(root);
        cout<< endl;
        clear(root);
        root = NULL;
    }
    return 0;
}