#include <stdio.h>
#include <malloc.h>

#define true 1
#define false 0
#define MaxDataNum 100

struct AVLTreeStruct {
    int data;
    int height;//我不知道这个有什么用，或许有更好的优化方法。
    struct AVLTreeStruct* left;
    struct AVLTreeStruct* right;
};
struct QueueStruct {
    int Capacity;
    int Rear, Front;
    struct AVLTreeStruct* Array[MaxDataNum];
};
typedef struct AVLTreeStruct* AVLTree;
typedef AVLTree TNode;
typedef struct QueueStruct* Queue;

TNode createTNode();
void initializeTNode( TNode t );
void printfError();
AVLTree insertAVLTree( AVLTree TreeHead, int data );
AVLTree RRotation( AVLTree PreviousTreeHead );
AVLTree LRotation( AVLTree PreviousTreeHead );
AVLTree RLRotation( AVLTree PreviousTreeHead );
AVLTree LRRotation( AVLTree PreviousTreeHead );
AVLTree deleteAVLTreeNode( AVLTree TreeHead, TNode Node );
TNode findMaxNode( AVLTree TreeHead );
TNode findMinNode( AVLTree TreeHead );
void drawATree( AVLTree TreeHead );
void enQueue( Queue q, TNode n );
TNode deQueue( Queue q );
int judgeNotChild( Queue q );
int Max( int a, int b );
int Height( AVLTree TreeHead );


int main( void ) {
    int i = 0;
    int data = 0;
    int n = 20;
    TNode tmp = createTNode();
    AVLTree t = createTNode();
    initializeTNode( t );
    initializeTNode( tmp );

    for( i = 0; i < n; i++ ) {
        scanf("%d", &data);
        if( i == 0 ) {
            t->data = data;
        }
        else {
            t = insertAVLTree( t, data );
        }
    }

    drawATree( t );
    printf("\n");
    
    TNode m = t;
    for( i = 0; i < n; i++ ) {
        scanf("%d", &tmp->data);
        t = deleteAVLTreeNode( t, tmp );
        drawATree( t );
        printf("\n");
    }

    return 0;
}

void printfError() {
    printf("Space Error!");
    exit(0);
}
TNode createTNode() {

    TNode t = ( TNode )malloc( sizeof(struct AVLTreeStruct) );
    if( !t ) {
        printfError();
    }

    return t;
}
void initializeTNode( TNode t ) {

    t->data = 0;
    t->left = t->right = NULL;
}
AVLTree RRotation( AVLTree PreviousTreeHead ) {
    TNode p = PreviousTreeHead;
    AVLTree t = p->left;

    p->left = t->right;
    t->right = p;

    return t;
}
AVLTree LRotation( AVLTree PreviousTreeHead ) {
    TNode p = PreviousTreeHead;
    AVLTree t = p->right;

    p->right = t->left;
    t->left = p;

    return t;
}
AVLTree RLRotation( AVLTree PreviousTreeHead ) {
    TNode p = PreviousTreeHead;

    p->right = RRotation( p->right );
    return LRotation( p );
}
AVLTree LRRotation( AVLTree PreviousTreeHead ) {
    TNode p = PreviousTreeHead;

    p->left = LRotation( p->left );
    return RRotation( p );
}
AVLTree insertAVLTree( AVLTree TreeHead, int data ) {
    AVLTree t = TreeHead;
    int d = data;
    AVLTree tmp1;

    if( t == NULL ) {
        t = createTNode();
        initializeTNode( t );
        t->data = d;
        return t;
    }

    if( d == t->data ) {
        return t;
    }
    if( d < t->data ) {
        t->left = insertAVLTree( t->left, d );

        if( Height(t->left) - Height(t->right) == 2 ) {
            tmp1 = t->left;//这样写是不是不好？

            t = Height(tmp1->left) >= Height(tmp1->right) ? RRotation( t ) : LRRotation( t );
        }
    }
    else {
        t->right = insertAVLTree( t->right, d );

        if( Height(t->right) - Height(t->left) == 2 ) {
            tmp1 = t->right;
            t = Height(tmp1->right) >= Height(tmp1->left) ? LRotation( t ) : RLRotation( t );
        }
    }

    return t;
}
int Height( AVLTree TreeHead ) {
    TNode t = TreeHead;

    if( !t ) {
        return 0;
    }

    return Max( Height(t->left), Height(t->right) ) + 1;

}
int Max( int a, int b ) {
    return a > b ? a : b;
}
AVLTree deleteAVLTreeNode( AVLTree TreeHead, TNode Node ) {

    AVLTree t = TreeHead;
    TNode n = Node;

    if( t == NULL || n == NULL ) {
        printf("Not Found!\n");
        return NULL;
    }

    if( n->data < t->data ) {
        t->left = deleteAVLTreeNode( t->left, n );

        if( Height(t->right) - Height(t->left) == 2 ) {
            t = Height(t->right->right) >= Height(t->right->left) ?  LRotation( t ) : RLRotation( t );
        }
    }
    else if( n->data > t->data ) {
        t->right = deleteAVLTreeNode( t->right, n );

        if( Height(t->right) - Height(t->right) == 2 ) {
            t = Height(t->left->left) >= Height(t->left->right) ?  RRotation( t ) : LRRotation( t );
        }
    }
    else {
        if( t->left && t->right ) {
            if( Height(t->left) >= Height(t->right) ) {//好像可以优化。
                TNode MaxNode = findMaxNode( t->left );
                t->data = MaxNode->data;
                t->left = deleteAVLTreeNode( t->left, MaxNode );
            }
            else {
                TNode MinNode = findMinNode( t->right );
                t->data = MinNode->data;
                t->right = deleteAVLTreeNode( t->right, MinNode );
            }
        }
        else {
            TNode tmp = t->right ? t->right : t->left;
            free( t );
            t = tmp;
        }
    }

    return t;
}
TNode findMaxNode( AVLTree TreeHead ) {
    TNode LastNode = NULL;
    AVLTree t = TreeHead;

    while( t ) {
        LastNode = t;
        t = t->right;
    }

    return LastNode;
}
TNode findMinNode( AVLTree TreeHead ) {
    TNode LastNode = NULL;
    AVLTree t = TreeHead;

    while( t ) {
        LastNode = t;
        t = t->left;
    }

    return LastNode;
}
void drawATree( AVLTree TreeHead ) {
    AVLTree t = TreeHead;
    TNode tmp = NULL;
    if( !t ) {
        return;
    }

    Queue q = ( Queue )malloc( sizeof(struct QueueStruct) );
    if( !q ) {
        printfError();
    }
    q->Front = q->Rear = 0;
    int num = 0;

    enQueue( q, t );
    printf("%d\n", t->data);

    while( !judgeNotChild( q ) ) {
        num = q->Rear-q->Front > 0 ? q->Rear - q->Front : q->Rear+MaxDataNum - q->Front;

        while( num ) {
            t = deQueue( q );
            tmp = t->left;
            if( tmp ) {
                printf("%d ", tmp->data);
                enQueue( q, tmp );
            }
            else {
                printf(" ");
            }
            tmp = t->right;
            if( tmp ) {
                printf("%d ", tmp->data);
                enQueue( q, tmp );
            }
            else {
                printf(" ");
            }
            num--;
        }
        printf("\n");
    }

}
void enQueue( Queue q, TNode n ) {
    if( (q->Rear+1) % MaxDataNum == q->Front ) {
        printf("IsFull!\n");
        return;
    }

    q->Rear = (q->Rear+1) % MaxDataNum;
    q->Array[q->Rear] = n;
}
TNode deQueue( Queue q ) {
    if( q->Front  == q->Rear ) {
        printf("IsEmpty\n");
        return NULL;
    }
    q->Front = (q->Front+1) % MaxDataNum;
    return q->Array[q->Front];
}
int judgeNotChild( Queue q ) {
    int i = (q->Front+1) % MaxDataNum;
    int num = q->Rear-q->Front > 0 ? q->Rear - q->Front : q->Rear+MaxDataNum - q->Front;
    AVLTree n = NULL;
    while( num ) {
        n = q->Array[i];
        if( n->left || n->right ) {
            break;
        }
        i++;
        num--;
    }

    if( !num ) {
        return true;
    }
    return false;
}

不会用Github。这个星期应该会去学。代码写了300多行，感觉就变成了怪物。重构的知识，只会一点。勉强，把代码量弄少一点，多写多思考，为了看我的平衡二叉树有没有问题，我还是写了一个层序遍历。代码好丑啊。