AVL 树的 思想就是 不停保持树的 平衡， 就是左右两棵子树的高度差不超过1，网上很多实例都是 在结构里 设置一个标志位来区分的，但我这次

直接使用高度判定来决定要不要旋转

左旋代码：

Node* left_left_rotation(AVLTree k2) //顺时针旋转 即从左向右旋转
{
　　AVLTree k1;
　　k1 = k2->left;
　　k2->left = k1->right;
　　k1->right = k2;

k2->height = MAX(HEIGHT(k2->left), HEIGHT(k2->right)) + 1; //旋转一次就调整高度， 这样在下次操作的时候就可以方便使用了
k1->height = MAX(HEIGHT(k1->left), k2->height) + 1;

return k1;
}
 
具体代码如下：
//avltree.h 以后可以在这里看着这几个api 来实现 
 1 #ifndef _AVL_TREE_H_
 2 #define _AVL_TREE_H_
 3 
 4 typedef int Type;
 5 typedef struct AVLTreeNode {
 6     Type key;
 7     int height;
 8     struct AVLTreeNode *left;
 9     struct AVLTreeNode *right;
10 }Node, *AVLTree;
11 
12 int avltree_height(AVLTree tree);  //树的高度
13 void preorder_avltree(AVLTree tree);  //前序遍历
14 void inorder_avltree(AVLTree tree);  //中序遍历
15 void postorder_avltree(AVLTree tree);   //后序遍历
16 void print_avltree(AVLTree tree, Type key, int direction);  //打印具体的树
17 Node* avltree_search(AVLTree tree, Type key);  //树中查找--递归实现
18 Node* iterative_avltree_search(AVLTree x, Type key);  //非递归查找
19 Node* avltree_maximum(AVLTree tree);  //树中的最大值
20 Node* avltree_minimum(AVLTree tree);   //树中的最小值
21 Node* avltree_insert(AVLTree tree, Type key);  //插入节点
22 Node* avltree_delete(AVLTree tree, Type key);   //删除节点
23 void destroy_avltree(AVLTree tree);  //销毁该树
24 
25 #endif
avltree.h

//abltree.c //具体实现

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "avltree.h"
  4 
  5 
  6 #define HEIGHT(p) ((p == NULL) ? -1 : (((Node *)(p))->height))
  7 
  8 #define MAX(a, b)  ((a) > (b) ? (a) : (b))
  9 
 10 int avltree_height(AVLTree tree)
 11 {
 12     return HEIGHT(tree);
 13 }
 14 
 15 void preorder_avltree(AVLTree tree)
 16 {
 17     if(tree != NULL)
 18     {
 19         printf("%d ", tree->key);
 20         preorder_avltree(tree->left);
 21         preorder_avltree(tree->right);
 22     }
 23 }
 24 
 25 void inorder_avltree(AVLTree tree)
 26 {
 27     if(tree != NULL)
 28     {
 29         inorder_avltree(tree->left);
 30         printf("%d ", tree->key);
 31         inorder_avltree(tree->right);
 32     }
 33 }
 34 
 35 void postorder_avltree(AVLTree tree)
 36 {
 37     if(tree != NULL)
 38     {
 39         postorder_avltree(tree->left);
 40         postorder_avltree(tree->right);
 41         printf("%d ", tree->key);
 42     }
 43 }
 44 
 45 Node* avltree_search(AVLTree x, Type key)
 46 {
 47     if(x == NULL || x->key == key)
 48         return x;
 49     if(key < x->key)
 50         return avltree_search(x->left, key);
 51     else 
 52         return avltree_search(x->right, key);
 53 }
 54 
 55 Node* iterative_avltree_search(AVLTree x, Type key)
 56 {
 57     while((x != NULL) && (x->key != key))
 58     {
 59         if(key < x->key)
 60             x = x->left;
 61         else 
 62             x = x->right;
 63     }
 64     return x;
 65 }
 66 
 67 Node* avltree_minimum(AVLTree tree)
 68 {
 69     if(tree == NULL)
 70         return NULL;
 71     while(tree->left != NULL)
 72         tree =tree->left;
 73     return tree;
 74 }
 75 
 76 Node* left_left_rotation(AVLTree k2) //顺时针旋转
 77 {
 78     AVLTree k1;
 79     k1 = k2->left;
 80     k2->left = k1->right;
 81     k1->right = k2;
 82 
 83     k2->height = MAX(HEIGHT(k2->left), HEIGHT(k2->right)) + 1;
 84     k1->height = MAX(HEIGHT(k1->left), k2->height) + 1;
 85 
 86     return k1;
 87 }
 88 
 89 Node* right_right_rotation(AVLTree k1)
 90 {
 91     AVLTree k2;
 92     k2 = k1->right;
 93     k1->right = k2->left;
 94     k2->left = k1;
 95 
 96     k1->height = MAX(HEIGHT(k1->left), HEIGHT(k1->right)) + 1;
 97     k2->height = MAX(HEIGHT(k2->right), k1->height) + 1;
 98 
 99     return k2;
100 }
101 
102 Node* left_right_rotation(AVLTree k3)
103 {
104     k3->left = right_right_rotation(k3->left);
105 
106     return left_left_rotation(k3);
107 }
108 
109 Node* right_left_rotation(AVLTree k4)
110 {
111     k4->right = left_left_rotation(k4->right);
112     
113     return right_right_rotation(k4);
114 }
115 
116 Node* avltree_maximum(AVLTree tree)
117 {
118     if(tree == NULL)
119         return NULL;
120     while(tree->right != NULL)
121         tree = tree->right;
122     return tree;
123 }
124 
125 Node* avltree_create_node(Type key, Node *left, Node *right)
126 {
127     Node* p;
128     if((p = (Node*)malloc(sizeof(Node))) == NULL)
129         return NULL;
130     p->key = key;
131     p->height = 0;
132     p->left = left;
133     p->right = right;
134 
135     return p;
136 }
137 
138 void destroy_avltree(AVLTree tree)
139 {
140     if(tree == NULL)
141         return;
142     if(tree->left != NULL)
143         destroy_avltree(tree->left);
144     if(tree->right != NULL)
145         destroy_avltree(tree->right);
146     free(tree);
147 }
148 
149 void print_avltree(AVLTree tree, Type key, int direction)
150 {
151     if(tree != NULL)
152     {
153         if(tree != NULL)
154         {
155             if(direction==0)    // tree是根节点
156                   printf("%2d is root\n", tree->key, key);
157             else                // tree是分支节点
158                 printf("%2d is %2d's %6s child\n", tree->key, key, direction==1?"right" : "left");
159        
160             print_avltree(tree->left, tree->key, -1);
161             print_avltree(tree->right, tree->key,  1);
162         }
163     }
164 }
165 
166 Node* avltree_insert(AVLTree tree, Type key)
167 {
168     if(tree == NULL)
169     {
170         tree = avltree_create_node(key, NULL, NULL);
171         if(tree == NULL)
172         {
173             printf("ERROR: create avltree node failed\n");
174             return NULL;
175         }
176     } else if(key < tree->key)
177     {
178         tree->left = avltree_insert(tree->left, key);
179         if(HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
180         {
181             if(key < tree->left->key)
182                 tree = left_left_rotation(tree);
183             else 
184                 tree = left_right_rotation(tree);
185         }
186     } else if(key > tree->key)
187     {
188         tree->right = avltree_insert(tree->right, key);
189         if(HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
190         {
191             if(key > tree->right->key)
192                 tree = right_right_rotation(tree);
193             else    
194                 tree = right_left_rotation(tree);
195         }
196     } else {
197         printf("add error: no allow to add same node\n");
198     }
199 
200     tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right))+ 1;
201     return tree;
202 }
203 
204 Node* delete_node(AVLTree tree, Node* z)
205 {
206     if(tree == NULL || z == NULL)
207         return NULL;
208 
209     if(z->key < tree->key) //待删节点在左子树中
210     {
211         tree->left = delete_node(tree->left, z); //失去平衡作调整
212         if(HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
213         {
214             Node *r = tree->right;
215             if(HEIGHT(r->left) > HEIGHT(r->right))
216                 tree = right_left_rotation(tree);
217             else 
218                 tree = right_right_rotation(tree);
219         }
220     } 
221     else if(z->key > tree->key) //待删节点在右子树中
222     {
223         tree->right = delete_node(tree->right, z);  //失去平衡作调整
224         if(HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
225         {
226             Node* l = tree->left;
227             if(HEIGHT(l->right) > HEIGHT(l->left))
228                 tree = left_right_rotation(tree);
229             else 
230                 tree = left_left_rotation(tree);
231         }
232     } else {
233         if((tree->right) && (tree->right))
234         {
235             if(HEIGHT(tree->left) > HEIGHT(tree->right))
236             {
237                 Node* max = avltree_maximum(tree->left);
238                 tree->key = max->key;
239                 tree->left = delete_node(tree->left, max);
240             } else {
241                 Node* min = avltree_maximum(tree->left);
242                 tree->key = min->key;
243                 tree->left = delete_node(tree->right, min);
244             }
245         } else {
246             Node *tmp = tree;
247             tree = tree->left ? tree->left : tree->right;
248             free(tmp);
249         }
250     }
251 
252     return tree;
253 }
254 
255 Node* avltree_delete(AVLTree tree, Type key)
256 {
257     Node *z;
258     if((z = avltree_search(tree, key)) != NULL)
259         tree = delete_node(tree, z);
260     return tree;
261 }
abltree.c

//avltree_test.c 测试文件

 1 #include <stdio.h>
 2 #include "avltree.h"
 3 #include "avltree.c"
 4 
 5 static int arr[]= {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
 6 #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )
 7 
 8 int main() 
 9 {   
10     int i, ilen;
11     AVLTree root = NULL;
12     printf("== height: %d\n", avltree_height(root));
13     printf("== follow add: ");
14     ilen = TBL_SIZE(arr);
15     printf("\n%d\n", ilen);
16     for(i = 0; i < ilen; i++)
17     {
18         printf("%d ",arr[i]);
19         root = avltree_insert(root, arr[i]);
20     }
21     printf("\n==perorder_avltree: ");
22     preorder_avltree(root);
23     printf("\n==inorder_avltree: ");
24     inorder_avltree(root);
25     printf("\n==postorder_avltree: ");
26     postorder_avltree(root);
27     printf("\n");
28 
29     printf("==height: %d\n",avltree_height(root));
30     printf("==the minist value: %d\n", avltree_minimum(root)->key);
31     if(NULL == root)
32         printf("true");
33     printf("==the maxest value: %d\n", avltree_maximum(root)->key);
34     printf("== the information of tree: \n");
35     print_avltree(root, root->key, 0);
36     i = 8;
37     printf("\n==delete root: %d", i);
38     root = avltree_delete(root, i);
39     printf("\n== height: %d", avltree_height(root));
40     printf("\n==中序遍历: ");
41     inorder_avltree(root);
42     printf("\n== the information of tree: \n");
43     print_avltree(root, root->key, 0);
44 
45 
46     destroy_avltree(root);
47     getchar();
48     return 0;
49 }
avltree_test.c