AVL树，C语言实现，完整代码，先贴上，讲解稍后

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define ADD_FOUND 0
#define ADD_ALLOC_FAILED 1
#define ADD_ROOT 2
#define ADD_NORMAL 3
#define ADD_RLNULL 4
#define ADD_LRNULL 5
#define DEL_LLNULL 6
#define DEL_LRNULL 7
#define DEL_RRNULL 8
#define DEL_RLNULL 9
#define DEL_NOTFOUND 10
#define DEL_ROOT 11
#define DEL_NORMAL 12
#define ADD_PARAERROR 13
#define DEL_PARAERROR 14
#define DEL_LCHILDNULL 15
#define DEL_RCHILDNULL 16
typedef struct _avl_node{
struct _avl_node *lchild;
struct _avl_node *rchild;
struct _avl_node *parent;
int value;
int bf;
}avl_node;
avl_node *avl_root = ;
static inline void rotate_left(avl_node *node){
avl_node *rnode;
avl_node *pnode;
if (!node || !node->rchild)return;
rnode = node->rchild;
pnode = node->parent;
if (pnode){
if (pnode->lchild == node)pnode->lchild = rnode;
else if (pnode->rchild == node)pnode->rchild = rnode;
}
else{
avl_root = rnode;
}
rnode->parent = pnode;
node->rchild = rnode->lchild;
node->parent = rnode;
if (rnode->lchild)rnode->lchild->parent = node;
rnode->lchild = node;
}
static inline void rotate_right(avl_node *node){
avl_node *lnode;
avl_node *pnode;
if (!node || !node->lchild)return;
lnode = node->lchild;
pnode = node->parent;
if (pnode){
if (pnode->lchild == node)pnode->lchild = lnode;
else if (pnode->rchild == node)pnode->rchild = lnode;
}
else{
avl_root = lnode;
}
lnode->parent = pnode;
node->lchild = lnode->rchild;
node->parent = lnode;
if (lnode->rchild)lnode->rchild->parent = node;
lnode->rchild = node;
}

static inline int add_avl_fixup(avl_node *node){
avl_node *pnode;
avl_node *child;
avl_node *tmp;
if (!node)return ADD_PARAERROR;
pnode = node->parent;
child = node;
while (pnode){
)return ADD_NORMAL;
){
if (pnode->lchild){
switch (pnode->lchild->bf)
{
:
if (pnode->lchild->lchild){
pnode->lchild->bf = ;
pnode->bf = ;
rotate_right(pnode);
 || pnode->bf <= -){
printf("ll error\n");
}
}
else{
printf("ADD_LLNULL\n");
}
break;
:
if (pnode->lchild->rchild){
){
pnode->bf = ;
pnode->lchild->bf = ;
}
){
pnode->bf = -;
pnode->lchild->bf = ;
}
){
pnode->bf = ;
pnode->lchild->bf = ;
}
pnode->lchild->rchild->bf = ;
tmp = pnode;
rotate_left(pnode->lchild);
rotate_right(tmp);
 || pnode->bf <= -){
printf("lr error\n");
}
}
else{
printf("ADD_LRNULL\n");
return ADD_LRNULL;
break;
}
}
}
else{
printf("2 not change\n");
}
return ADD_NORMAL;
}
){
if (pnode->rchild){
switch (pnode->rchild->bf)
{
:
if (pnode->rchild->rchild){
pnode->bf = ;
pnode->rchild->bf = ;
rotate_left(pnode);
||pnode->bf<=-){
printf("rr error\n");
}
}
else{
printf("ADD_RRNULL\n");
}
break;
:
if (pnode->rchild->lchild){
){
pnode->bf = ;
pnode->rchild->bf = -;
}
){
pnode->bf = ;
pnode->rchild->bf = ;
}
){
pnode->bf = ;
pnode->rchild->bf = ;
}
pnode->rchild->lchild->bf = ;
tmp = pnode;
rotate_right(pnode->rchild);
rotate_left(tmp);
 || pnode->bf <= -){
printf("rl error\n");
}
}
else {
printf("ADD_RLNULL\n");
return ADD_RLNULL;
}
break;
}
}
else{
printf("-2 not change\n");
}
return ADD_NORMAL;
}
child = pnode;
pnode = pnode->parent;
if (pnode){
 || pnode->bf == -){

}
if (pnode->lchild == child){

pnode->bf += ;

}
else if (pnode->rchild == child)
{
pnode->bf -= ;
}
}
}
}
int add_avl_node(avl_node**proot, int val,int seq){
;
avl_node *root;
avl_node *pre;
avl_node *nnode;
if (!proot)return ADD_PARAERROR;
root = *proot;
pre = root;
while (root){
pre = root;
if (root->value > val)root = root->lchild;
else if (root->value < val)root = root->rchild;
else return ADD_FOUND;
}
++counter;
nnode = (avl_node *)malloc(sizeof(avl_node));
if (!nnode)return ADD_ALLOC_FAILED;
memset(nnode, , sizeof(avl_node));
nnode->value = val;
nnode->bf = ;
nnode->parent = ;
nnode->lchild = ;
nnode->parent = ;
){
*proot = nnode;
return ADD_ROOT;
}
if (pre->value > val){
){
printf("NOT 1 %d 0x%x\n",counter,(unsigned int)pre->lchild);
}
pre->bf += ;
pre->lchild = nnode;
}
else if (pre->value < val){
){
printf("NOT -1 %d 0x%x\n",counter,(unsigned int)pre->rchild);
}
pre->bf -= ;
pre->rchild = nnode;
}
nnode->parent = pre;
return add_avl_fixup(nnode);
}
static inline int del_avl_fixup(avl_node *node){
avl_node *pnode;
avl_node *child;
if (!node)return DEL_PARAERROR;
pnode = node;
while (pnode){
){
if (!pnode->lchild){
printf("pnode->lchild is null\n");
return DEL_LCHILDNULL;
}
){
pnode->bf = ;
pnode->lchild->bf = -;
rotate_right(pnode);
return DEL_NORMAL;
}
){
pnode->bf = ;
pnode->lchild->bf = ;
child = pnode->lchild;
rotate_right(pnode);
pnode = child;
}
){
if (pnode->lchild->rchild){
){
pnode->lchild->bf = ;
pnode->bf = -;
}
){
pnode->lchild->bf = ;
pnode->bf = ;
}
){
pnode->lchild->bf = ;
pnode->bf = ;
}
pnode->lchild->rchild->bf = ;
child = pnode->lchild->rchild;
rotate_left(pnode->lchild);
rotate_right(pnode);
pnode = child;
}
else {
printf("DEL LR NULL\n");
return DEL_LRNULL;
}
}
}
){
if (!pnode->rchild){
printf("pnode->rchild is null\n");
return DEL_RCHILDNULL;
}

){
pnode->bf = -;
pnode->rchild->bf = ;
rotate_left(pnode);
return DEL_NORMAL;
}
){
if (pnode->rchild->lchild){
){
pnode->bf = ;
pnode->rchild->bf = -;
}
){
pnode->bf = ;
pnode->rchild->bf = ;
}
){
pnode->bf = ;
pnode->rchild->bf = ;
}
pnode->rchild->lchild->bf = ;
child = pnode->rchild->lchild;
rotate_right(pnode->rchild);
rotate_left(pnode);
pnode = child;
}
else{
printf("DEL RL NULL\n");
return DEL_RLNULL;
}
}
){
pnode->bf = ;
pnode->rchild->bf = ;
child = pnode->rchild;
rotate_left(pnode);
pnode = child;
}
}
 || pnode->bf == ){
return DEL_NORMAL;
}
 || pnode->bf < -){
printf("DEL INVALID bf %d\n", pnode->bf);
}
if (pnode->parent){
;
;
}
pnode = pnode->parent;
}
return DEL_NORMAL;
}
int del_avl_node(avl_node **proot,int val){
avl_node *root;
avl_node *post;
avl_node *pnode=;
if (!proot||!(*proot))return DEL_PARAERROR;
root = *proot;
while (root){
if (root->value > val)root = root->lchild;
else if (root->value < val)root = root->rchild;
else break;
}
if (!root)return DEL_NOTFOUND;
if (!root->lchild){
if (root->parent){
if (root->parent->lchild == root){
root->parent->bf -= ;
if (root->rchild)root->rchild->parent = root->parent;
root->parent->lchild = root->rchild;
}
else if (root->parent->rchild == root){
root->parent->bf += ;
if (root->rchild)root->rchild->parent = root->parent;
root->parent->rchild = root->rchild;
}
pnode = root->parent;
memset(root, , sizeof(avl_node));
free(root);
}
else{
;
*proot = root->rchild;
printf("L NULL P NULL\n");
memset(root, , sizeof(avl_node));
free(root);
return DEL_NORMAL;
}
}
else if (!root->rchild){
if (root->parent){
if (root->parent->lchild == root){
root->parent->bf -= ;
if (root->lchild)root->lchild->parent = root->parent;
root->parent->lchild = root->lchild;
}
else if (root->parent->rchild == root){
root->parent->bf += ;
if (root->lchild)root->lchild->parent = root->parent;
root->parent->rchild = root->lchild;
}
pnode = root->parent;
memset(root, , sizeof(avl_node));
free(root);
}
else{
;
*proot = root->rchild;
printf("R NULL P NULL\n");
memset(root, , sizeof(avl_node));
free(root);
return DEL_NORMAL;
}
}
else{
post = root->rchild;
while (post->lchild)post = post->lchild;
root->value = post->value;
if (post->parent->lchild==post){
post->parent->bf -= ;
post->parent->lchild = post->rchild;
if (post->rchild){
post->rchild->parent = post->parent;
}
}
else if (post->parent->rchild == post){
post->parent->bf += ;
post->parent->rchild = post->rchild;
if (post->rchild){
post->rchild->parent = post->parent;
}
}
pnode = post->parent;
memset(post, , sizeof(avl_node));
free(post);
}
return del_avl_fixup(pnode);
}
static void cal_avl_deepth(avl_node *root,int *total,int *deepth){
;
;
avl_node *post;
];
FILE *fp;
if (!root)return;
deepth[] = ;
memset(buf, , sizeof(buf));
sprintf(buf, ));
){
printf("Failed to open file\n");
return;
}
while (root){
){
root = root->lchild;
deepth[]++;
}
])last_deepth = deepth[];
)printf(]);
total[]++;
fprintf(fp, "%d ", root->value);
if (!root->rchild){
while (root->parent&&root->parent->rchild == root){
root = root->parent;
deepth[]--;
}
deepth[]--;
root = root->parent;
flag = ;
}
else{
deepth[]++;
root = root->rchild;
flag = ;
}
}
deepth[] = last_deepth;
fclose(fp);
}

int main(void){
;
;
;
srand(time());
; i < ;i++){
add_avl_node(&avl_root, rand()%0x7fffffff,i);
del_avl_node(&avl_root, rand() % 0x7fffffff);
}
cal_avl_deepth(avl_root, &total_avl_node, &avl_deepth);
printf("total:%d deepth:%d\n", total_avl_node, avl_deepth);
; i < 0x7fffffff; i++){
del_avl_node(&avl_root, i);
}
total_avl_node = ;
avl_deepth = ;
cal_avl_deepth(avl_root, &total_avl_node, &avl_deepth);
printf("total:%d deepth:%d\n", total_avl_node, avl_deepth);
){

}
;
}