AVL 平衡二叉树

AVL 树的概念

      在计算机科学中，AVL树 是最先发明的自平衡二叉查找树 。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树 。查找、插入和删除在平均和最坏情况下都是O（log n ）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis，他们在1962年的论文《An algorithm for the organization of information》中发表了它。

      节点的平衡因子 是它的右子树的高度减去它的左子树的高度。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

操作

AVL树的基本操作一般涉及运作同在不平衡的二叉查找树所运作的同样的算法。但是要进行预先或随后做一次或多次所谓的"AVL旋转"。

插入

向AVL树插入可以通过如同它是未平衡的二叉查找树一样把给定的值插入树中，接着自底向上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。因为折回到根节点的路途上最多有1.5乘log n 个节点，而每次AVL旋转都耗费恒定的时间，插入处理在整体上耗费O(log n ) 时间。

删除

从AVL树中删除可以通过把要删除的节点向下旋转成一个叶子节点，接着直接剪除这个叶子节点来完成。因为在旋转成叶子节点期间最多有log n 个节点被旋转，而每次AVL旋转耗费恒定的时间，删除处理在整体上耗费O(log n ) 时间。

一样的进行，所以耗费O(log n )时间，因为AVL树总是保持平衡的。不需要特殊的准备，树的结构不会由于查询而改变。（这是与伸展树 查找相对立的，它会因为查找而变更树结构。）。

      以上基本概念来自维基百科（需要修改，不通顺）。那么，现在要做的就是把文字描述编写成代码。

实现

首先是原型定义。comp_func是比较函数，需要调用者实现。至于find操作，因为我们仅专注于AVL树本身，所以也需要调用者自己实现。

#include <stdio.h> #include <stdlib.h> struct avl_node { int height; struct avl_node *left; struct avl_node *right; }; struct avl_root { struct avl_node *node; struct avl_node ***stack; // save operation path int stack_index; }; //if node1's key > node2's key, return 1 //if node1's key < node2's key, return -1 //if node1's key == node2's key, return 0 typedef int (*comp_func)(struct avl_node *node1, struct avl_node *node2);

 

接着定义各种操作。不采用递归，使用一个栈来保存操作路径上的节点。由于定义了avl_node和avl_root不同结构体，栈中存放struct **avl_node类型指针，方便操作。对于双旋转，为了代码清晰，我没有做优化。

/* * define operations * 'find' & comparation should be written by the caller */ int avl_insert(struct avl_node *new_node, struct avl_root *root, comp_func comp); int avl_remove(struct avl_node *del_node, struct avl_root *root, comp_func comp); /* tree operation functions */ static inline void __avl_stack_push(struct avl_node **item, struct avl_root *root) { root->stack[root->stack_index++] = item; } static inline struct avl_node ** __avl_stack_pop(struct avl_root *root) { return root->stack[--root->stack_index]; } static inline void __avl_stack_hack(int index, struct avl_node **item, struct avl_root *root) { root->stack[index] = item; } static inline int __avl_stack_size(struct avl_root *root) { return root->stack_index; } //============================================================================================= #define heightof(tree) ( ( (tree) == NULL )? 0 : (tree)->height ) #define maxof(h1, h2) ((h1) > (h2)?(h1):(h2)) static inline void __avl_rotate_left(struct avl_node *node, struct avl_node **place) { struct avl_node *left = node->left; struct avl_node *right = node->right; node->right = right->left; right->left = node; node->height = maxof(heightof(node->right), heightof(node->left)) + 1; right->height = maxof(heightof(right->right), heightof(right->left)) + 1; *place = right; } static inline void __avl_rotate_right(struct avl_node *node, struct avl_node **place) { struct avl_node *left = node->left; struct avl_node *right = node->right; node->left = left->right; left->right = node; node->height = maxof(heightof(node->right), heightof(node->left)) + 1; left->height = maxof(heightof(left->right), heightof(left->left)) + 1; *place = left; } static void __avl_rebalance(struct avl_root *root) // do all works on stack { while ( __avl_stack_size(root) > 0 ) { struct avl_node **place = __avl_stack_pop(root); struct avl_node *node = *place; struct avl_node *left = node->left; struct avl_node *right = node->right; int height_left = heightof(left); int height_right = heightof(right); if ( height_right + 1 < height_left ) { struct avl_node *left_left = left->left; struct avl_node *left_right = left->right; int height_left_left = heightof(left_left); int height_left_right = heightof(left_right); if ( height_left_right > height_left_left ) {// double rotate __avl_rotate_left(left, &node->left); } __avl_rotate_right(node, place); } else if ( height_left + 1 < height_right ) { struct avl_node *right_left = right->left; struct avl_node *right_right = right->right; int height_right_left = heightof(right_left); int height_right_right = heightof(right_right); if ( height_right_left > height_right_right ) {// double rotate __avl_rotate_right(right, &node->right); } __avl_rotate_left(node, place); } else { int height = ( (height_left > height_right) ? height_left: height_right ) + 1; if ( height == node->height ) break; node->height = height; } } } // return 0 if ok, else return -1 int avl_insert(struct avl_node *new_node, struct avl_root *root, comp_func comp) { struct avl_node **place = &root->node; for ( ; ; ) { struct avl_node *node = *place; if ( NULL == node ) break; __avl_stack_push(place, root); if ( 1 == comp(new_node, node) ) place = &node->right; else if ( -1 == comp(new_node, node) ) place = &node->left; else return -1; // found the same, let caller to handle it } new_node->left = new_node->right = NULL; new_node->height = 1; *place = new_node; __avl_rebalance(root); return 0; } //return 0 if ok, else return -1 int avl_remove(struct avl_node *del_node, struct avl_root *root, comp_func comp) { struct avl_node **place = &root->node; struct avl_node **place_del; for ( ; ; ) { struct avl_node *node = *place; if ( NULL == node ) return -1; // NOT found , let caller to handle it __avl_stack_push(place, root); if ( 1 == comp(del_node, node) ) place = &node->right; else if ( -1 == comp(del_node, node) ) place = &node->left; else break; // found } place_del = place; if ( NULL == del_node->left ) { *place = del_node->right; __avl_stack_pop(root); } else { // need to find the biggest in the left subtree int stk_idx = __avl_stack_size(root); struct avl_node *node; place = &del_node->left; // this will be hacked later for ( ; ; ) { node = *place; if ( NULL == node->right ) break; __avl_stack_push(place, root); place = &node->right; } *place = node->left; node->left = del_node->left; node->right = del_node->right; node->height = del_node->height; *place_del = node; __avl_stack_hack(stk_idx, &node->left, root); } __avl_rebalance(root); return 0; } typedef unsigned int size_t; #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) #define container_of(ptr, type, member) ({ / const typeof( ((type *)0)->member ) *__mptr = (ptr); / (type *)( (char *)__mptr - offsetof(type,member) );}) //==================================================================================

OK，接下来的代码就是测试刚才完成的树。我们使用层次遍历来方便观察。层次遍历使用一个队列来方便打印。

//test #define MAX_LEVEL 256 struct test_node { int key; struct avl_node node; }; int key_comp(struct avl_node *node1, struct avl_node *node2) { struct test_node *n1, *n2; n1 = container_of(node1, struct test_node, node); n2 = container_of(node2, struct test_node, node); if ( n1->key > n2->key ) return 1; else if ( n1->key < n2->key ) return -1; else return 0; } struct test_node *avl_find(int key, struct avl_root *tree) { struct avl_node *node = tree->node; struct test_node *res; for ( ; ; ){ if ( NULL == node ) return NULL; res = container_of(node, struct test_node, node); if ( key < res->key ) node = node->left; else if ( key > res->key ) node = node->right; else return res; } } struct queue{ struct queue *next; struct avl_node *node; }; static void en_queue(struct avl_node *node, struct queue **head, struct queue **tail) { struct queue *item = (struct queue*)malloc(sizeof(struct queue)); item->next = NULL; item->node = node; if ( NULL != *tail ) (*tail)->next = item; *tail = item; if ( NULL == *head ) *head = *tail; } static struct avl_node *de_queue(struct queue **head, struct queue **tail) { struct queue *old = *head; struct avl_node *res = old->node; *head = (*head)->next; if ( NULL == *head ) *tail = NULL; free(old); return (res); } void print_avl_level( struct avl_root *root) { struct test_node *res; struct queue *tail = NULL, *head = NULL; en_queue(root->node, &head, &tail); while( head != NULL ) { struct avl_node *node; node = de_queue(&head, &tail); res = container_of(node, struct test_node, node); printf("%d(@0x%X),h(%d),/tleft(@0x%X),/tright(@0x%X)/n", res->key, node, node->height, node->left, node->right); if ( NULL != node->left ) en_queue(node->left, &head, &tail); if ( NULL != node->right ) en_queue(node->right, &head, &tail); } } int main(void) { int i, res; struct avl_root tree = {NULL, NULL, 0}; tree.stack = (struct avl_node***)malloc(sizeof(struct avl_node**)*MAX_LEVEL); printf("Usage: i|d value to insert|del value; q to quit/n"); for ( ; ; ) { struct test_node *node; char op; int val; scanf("%c", &op); //getchar(); if ( op == 'i' ) { scanf("%d", &val); node = (struct test_node*)malloc(sizeof(struct test_node)); node->key = val; printf("insert key=%d/t", node->key); res = avl_insert(&node->node, &tree, key_comp); if ( res == -1 ) printf("already in!/n"); else printf("insert ok!/n"); print_avl_level(&tree); } else if ( op == 'd' ) { struct test_node *node; scanf("%d", &val); node = avl_find(val, &tree); if ( node ) { printf("Delete key=%d/t", val); res = avl_remove(&node->node, &tree, key_comp); if ( res == -1 ) printf("not found!/n"); else { free(node); printf("delete ok!/n"); } } print_avl_level(&tree); } else if ( op == 'q' ) { exit(0); } } }

 

以上代码没有经过太多的测试，暂未发现明显错误。