构建AVL树

AVL（Adelson-Velskii and Landis）树是**满足平衡条件的二叉搜索树：左右子树的深度差不大于1。**

一、理解AVL树

意义：通过调整二叉树结构，提高二叉查找的效率。

调整手段：左旋转、右旋转、双旋转。

类似抖葡萄那样，找到合适的节点作为新的根，拎起来抖两下，树结构就得到了调整。

四种失衡情况：

1）LL（left-left）型：

失衡位置从名字可以看出，左子树的左侧挂了太多节点；

此时需要的调整是右旋，顺时针旋转一下，即可恢复平衡。

2）RR（right-right）型

3）LR（left-right）型：失衡位置在左子树的右侧

调整操作：①先调整左子树，以K为新的根进行左旋（逆时针旋转）操作；②再处理整棵树，再次以K作为新的根，进行右旋操作。

4）RL（right-left）型，和LR型对称。

二、代码实现

1、结构定义

typedef int elem_t;

typedef struct avl_node {
	elem_t elem;
	struct avl_node *left;
	struct avl_node *right;
	int height;		// 节点高度
} avl_t;

2、高度计算

#define MAX(A,B) ((A)>(B)? (A):(B))
#define HEIGHT(node) (node == NULL ? -1:node->height)

int update_height(avl_t *T) {
	return MAX(HEIGHT(T->left), HEIGHT(T->right)) + 1;
}

3、失衡处理操作（结合图片理解）

// 左子树不平衡，太高，右旋转
avl_t *LL(avl_t *T) {
	avl_t *L = T->left;	// 作为新的根
	T->left = L->right;	
	L->right = T;

	T->height = update_height(T);
	L->height = update_height(L);
	return L;
}
// 右子树不平衡，太高，左旋转
avl_t *RR(avl_t *T) {
	avl_t *R = T->right;	// 作为新的根
	
	T->right = R->left;	
	R->left = T;

	T->height = update_height(T);
	R->height = update_height(R);
	return R;
}

avl_t *LR(avl_t *T) {
	T->left = RR(T->left);
	return LL(T);
}

avl_t *RL(avl_t *T) {
	T->right = LL(T->right);
	return RR(T);
}

4、通过插入操作，构建AVL树

avl_t *avl_new_node(elem_t e, avl_t *left, avl_t *right) {
	avl_t *node = malloc(sizeof(*node));
	node->elem = e;
	node->left = left;
	node->right = right;
	node->height = 0;
	return node;
}


// 在插入节点后要保证树的平衡
avl_t *insert(avl_t *T, elem_t e) {
	if (T == NULL) 
		return avl_new_node(e, NULL, NULL);
	
	if (e < T->elem) {	// 往左子树中插入节点
		T->left = insert(T->left, e);
		if (HEIGHT(T->left) - HEIGHT(T->right) > 1) {
			if (e < T->left->elem)
				T = LL(T);
			else
				T = LR(T);
		}
	} else if (e > T->elem) {	// 往右子树中插入节点
		T->right = insert(T->right, e);
		if (HEIGHT(T->right) - HEIGHT(T->left) > 1) {
			if (e > T->right->elem)
				T = RR(T);
			else
				T = RL(T);
		}
	} 

	T->height = update_height(T);
	return T;
}

int main() {
    // 构造AVL树测试
	elem_t arr[] = {12, 2, 6, 19, 8, 25};
	int len = sizeof(arr)/sizeof(arr[0]);
	avl_t *T = NULL;
	for (int i = 0; i < len; i++) {
		T = insert(T, arr[i]);
	}
	in_order(T);	// 中序遍历，结果为升序数组
}

5、删除操作就不展示了，例程代码放这里：https://gitee.com/zhoujiabo/leetcode_c/blob/master/AVL.c