平衡二叉查找树即AVL树的创建与旋转

平衡二叉树是基于二叉排序树（或者也叫二叉搜索树）实现的一种自平衡的二叉树，实现方法有比如：AVL树、红黑树等等

二叉搜索树定义（维基百科）：

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

1.若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；

2.若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；

3.任意节点的左、右子树也分别为二叉查找树；

4.没有键值相等的节点。

二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为O(log n)

平衡二叉树定义（维基百科）：

平衡二叉搜索树(Balanced Binary Tree)是一种结构平衡的二叉搜索树，即叶节点深度差不超过1，它能在O(log n)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为AVL树。

二叉查找树插入的时候很快，但是它可能会退化为线性链表，所以查询的时候有可能时间复杂度为O(n)

如图：

但是平衡二叉树插入的时候会自动平衡让它任何节点的左右子节点的高度差不超过1，主要是通过树的旋转来解决。

以AVL树来做一个说明，其中数的旋转有两种：一种是左旋，一种是右旋。

有的时候通过一次旋转就能维持平衡，而有的时候需要两次。主要有四种情况，左左、左右、右左，右右，其中左左和右右是只需要一次旋转，而左右和右左需要两次旋转，具体如下：

1-1左左模式和1-4右右模式只需要旋转一次，其中旋转的方式是一样的，而旋转方向不同而已，下面就拿一个左左的方式：

根节点的左边的深度为减去右边的深度差值为2，说明并不满足平衡二叉树，所以需要进行旋转，根据分析是左边深度大于右边，并且超出的节点2的父节点于祖父节点的左边，所以是左左模式，及需要进行右旋，右旋的时候将节点3作为根节点，节点5像右边作为节点3的右子节点，并且将节点4断开和节点3的连接然后再作为节点5的左子节点，旋转完成（其中右右模式同理，左旋就行了，旋转是一样的只是方向不一样而已）。

1-2左右和1-3右左都需要旋转两次，方向不一样而已操作一样，就拿1-2左右来说，如下图所示：

第一次旋转：将二叉树的1、2、3、4节点抽出来进行左旋，得到后面的树然后再结合5、6节点变成最后一个二叉树，第一次旋转得到的二叉树是一个左左模式。

然后根据左左模式进行右旋，即可得到平衡二叉树：

第二次旋转：然后将这个第一次旋转的左左模式二叉树安装图1-1进行右旋即可，最终得到一个AVL树。

 

下面是AVL树的创建与旋转示例代码

/**
1  * AVL树(C语言): C语言实现的AVL树。
2  */

#include <stdio.h>
#include <stdlib.h>

#define HEIGHT(p)    ( (p==NULL) ? -1 : (((Node *)(p))->height) )
#define MAX(a, b)    ( (a) > (b) ? (a) : (b) )
typedef int Type;

typedef struct AVLTreeNode{
Type key;                    // 关键字(键值)
int height;
struct AVLTreeNode *left;    // 左孩子
struct AVLTreeNode *right;    // 右孩子
}Node, *AVLTree;
/*
16  * 获取AVL树的高度
17  */
int avltree_height(AVLTree tree)
{
return HEIGHT(tree);
}

/*
24  * 前序遍历"AVL树"
25  */
void preorder_avltree(AVLTree tree)
{
if(tree != NULL)
{
printf("%d ", tree->key);
preorder_avltree(tree->left);
preorder_avltree(tree->right);
}
}

/*
38  * 中序遍历"AVL树"
39  */
void inorder_avltree(AVLTree tree)
{
if(tree != NULL)
{
inorder_avltree(tree->left);
printf("%d ", tree->key);
inorder_avltree(tree->right);
}
}

/*
51  * 后序遍历"AVL树"
52  */
void postorder_avltree(AVLTree tree)
{
if(tree != NULL)
{
postorder_avltree(tree->left);
postorder_avltree(tree->right);
printf("%d ", tree->key);
}
}

/*
64  * (递归实现)查找"AVL树x"中键值为key的节点
65  */
Node* avltree_search(AVLTree x, Type key)
{
if (x==NULL || x->key==key)
return x;

if (key < x->key)
return avltree_search(x->left, key);
else
return avltree_search(x->right, key);
}

/*
* (非递归实现)查找"AVL树x"中键值为key的节点
*/
Node* iterative_avltree_search(AVLTree x, Type key)
{
while ((x!=NULL) && (x->key!=key))
{
if (key < x->key)
x = x->left;
else
x = x->right;
}

return x;
}

/*
* 查找最小结点：返回tree为根结点的AVL树的最小结点。
*/
Node* avltree_minimum(AVLTree tree)
{
if (tree == NULL)
return NULL;

while(tree->left != NULL)
tree = tree->left;
return tree;
}

/*
* 查找最大结点：返回tree为根结点的AVL树的最大结点。
*/
Node* avltree_maximum(AVLTree tree)
{
if (tree == NULL)
return NULL;

while(tree->right != NULL)
tree = tree->right;
return tree;
}

/*
* LL：左左对应的情况(左单旋转)。
*
* 返回值：旋转后的根节点
*/
static 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;
}

/*
* RR：右右对应的情况(右单旋转)。
*
* 返回值：旋转后的根节点
*/
static Node* right_right_rotation(AVLTree k1)
{
AVLTree k2;

k2 = k1->right;
k1->right = k2->left;
k2->left = k1;

k1->height = MAX( HEIGHT(k1->left), HEIGHT(k1->right)) + 1;
k2->height = MAX( HEIGHT(k2->right), k1->height) + 1;

return k2;
}

/*
* LR：左右对应的情况(左双旋转)。
*
* 返回值：旋转后的根节点
*/
static Node* left_right_rotation(AVLTree k3)
{
k3->left = right_right_rotation(k3->left);

return left_left_rotation(k3);
}

/*
170  * RL：右左对应的情况(右双旋转)。
171  *
172  * 返回值：旋转后的根节点
173  */
static Node* right_left_rotation(AVLTree k1)
{
k1->right = left_left_rotation(k1->right);

return right_right_rotation(k1);
}

/*
* 创建AVL树结点。
*
* 参数说明：
*     key 是键值。
*     left 是左孩子。
*     right 是右孩子。
*/
static Node* avltree_create_node(Type key, Node *left, Node* right)
{
Node* p;

if ((p = (Node *)malloc(sizeof(Node))) == NULL)
return NULL;
p->key = key;
p->height = 0;
p->left = left;
p->right = right;

return p;
}

/*
* 将结点插入到AVL树中，并返回根节点
*
* 参数说明：
*     tree AVL树的根结点
*     key 插入的结点的键值
* 返回值：
*     根节点
*/
Node* avltree_insert(AVLTree tree, Type key)
{
if (tree == NULL)
{
// 新建节点
tree = avltree_create_node(key, NULL, NULL);
if (tree==NULL)
{
printf("ERROR: create avltree node failed!\n");
return NULL;
}
}
else if (key < tree->key) // 应该将key插入到"tree的左子树"的情况
{
tree->left = avltree_insert(tree->left, key);
// 插入节点后，若AVL树失去平衡，则进行相应的调节。
if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
{
if (key < tree->left->key)
tree = left_left_rotation(tree);
else
tree = left_right_rotation(tree);
}
}
else if (key > tree->key) // 应该将key插入到"tree的右子树"的情况
{
tree->right = avltree_insert(tree->right, key);
// 插入节点后，若AVL树失去平衡，则进行相应的调节。
if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
{
if (key > tree->right->key)
tree = right_right_rotation(tree);
else
tree = right_left_rotation(tree);
}
}
else //key == tree->key)
{
printf("添加失败：不允许添加相同的节点！\n");
}

tree->height = MAX( HEIGHT(tree->left), HEIGHT(tree->right)) + 1;

return tree;
}

/*
* 删除结点(z)，返回根节点
*
* 参数说明：
*     ptree AVL树的根结点
*     z 待删除的结点
* 返回值：
*     根节点
*/
static Node* delete_node(AVLTree tree, Node *z)
{
// 根为空 或者 没有要删除的节点，直接返回NULL。
if (tree==NULL || z==NULL)
return NULL;

if (z->key < tree->key)        // 待删除的节点在"tree的左子树"中
{
tree->left = delete_node(tree->left, z);
// 删除节点后，若AVL树失去平衡，则进行相应的调节。
if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
{
Node *r =  tree->right;
if (HEIGHT(r->left) > HEIGHT(r->right))
tree = right_left_rotation(tree);
else
tree = right_right_rotation(tree);
}
}
else if (z->key > tree->key)// 待删除的节点在"tree的右子树"中
{
tree->right = delete_node(tree->right, z);
// 删除节点后，若AVL树失去平衡，则进行相应的调节。
if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
{
Node *l =  tree->left;
if (HEIGHT(l->right) > HEIGHT(l->left))
tree = left_right_rotation(tree);
else
tree = left_left_rotation(tree);
}
}
else    // tree是对应要删除的节点。
{
// tree的左右孩子都非空
if ((tree->left) && (tree->right))
{
if (HEIGHT(tree->left) > HEIGHT(tree->right))
{
// 如果tree的左子树比右子树高；
// 则(01)找出tree的左子树中的最大节点
//   (02)将该最大节点的值赋值给tree。
//   (03)删除该最大节点。
// 这类似于用"tree的左子树中最大节点"做"tree"的替身；
// 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
Node *max = avltree_maximum(tree->left);
tree->key = max->key;
tree->left = delete_node(tree->left, max);
}
else
{
// 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
// 则(01)找出tree的右子树中的最小节点
//   (02)将该最小节点的值赋值给tree。
//   (03)删除该最小节点。
// 这类似于用"tree的右子树中最小节点"做"tree"的替身；
// 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。
Node *min = avltree_maximum(tree->right);
tree->key = min->key;
tree->right = delete_node(tree->right, min);
}
}
else
{
Node *tmp = tree;
tree = tree->left ? tree->left : tree->right;
free(tmp);
}
}

return tree;
}

/*
* 删除结点(key是节点值)，返回根节点
*
* 参数说明：
*     tree AVL树的根结点
*     key 待删除的结点的键值
* 返回值：
*     根节点
*/
Node* avltree_delete(AVLTree tree, Type key)
{
Node *z;

if ((z = avltree_search(tree, key)) != NULL)
tree = delete_node(tree, z);
return tree;
}

/*
359  * 销毁AVL树
360  */
void destroy_avltree(AVLTree tree)
{
if (tree==NULL)
return ;

if (tree->left != NULL)
destroy_avltree(tree->left);
if (tree->right != NULL)
destroy_avltree(tree->right);

free(tree);
}
/*
* 打印"AVL树"
*
* tree       -- AVL树的节点
* key        -- 节点的键值
* direction  --  0，表示该节点是根节点;
*               -1，表示该节点是它的父结点的左孩子;
*                1，表示该节点是它的父结点的右孩子。
*/
void print_avltree(AVLTree tree, Type key, int direction)
{
if(tree != NULL)
{
if(direction==0)    // tree是根节点
printf("%2d is root\n", tree->key, key);
else                // tree是分支节点
printf("%2d is %2d's %6s child\n", tree->key, key, direction==1?"right" : "left");

print_avltree(tree->left, tree->key, -1);
print_avltree(tree->right,tree->key,  1);
}
}

// static int arr[]= {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
// #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )

int main()
{
int i,ilen;
int arr[100];
AVLTree root=NULL;

printf("输入插入的节点个数为");
scanf("%d",&ilen);

for(i=0; i<ilen; i++)
{
scanf("%d",&arr[i]);
root = avltree_insert(root, arr[i]);
}

printf("\n== 前序遍历: ");
preorder_avltree(root);

printf("\n== 中序遍历: ");
inorder_avltree(root);
printf("\n== 后序遍历: ");
postorder_avltree(root);
printf("\n");
printf("== 高度: %d\n", avltree_height(root));

printf("== 树的详细信息: \n");
print_avltree(root, root->key, 0);
i = 8;
printf("\n== 删除根节点: %d", i);
root = avltree_delete(root, i);
printf("\n== 高度: %d", avltree_height(root));
printf("\n== 中序遍历: ");
inorder_avltree(root);
printf("\n== 树的详细信息: \n");
print_avltree(root, root->key, 0);

// 销毁二叉树
destroy_avltree(root);
return 0;
}