平衡二叉树(AVL Tree)的C++实现

1:先说一下AVL Tree和普通的二叉排序树的区别：

对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为log2n，其各操作的时间复杂度（O(log2n)）同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种情况，但是在进行了多次的操作之后，由于在删除时，我们总是选择将待删除节点的后继代替它本身，这样就会造成总是右边的节点数目减少，以至于树向左偏沉。这同时也会造成树的平衡性受到破坏，提高它的操作的时间复杂度。但是对于AVLTree来说，任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树，n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O（log n），大大降低了操作的时间复杂度，但是增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

2:AVL Tree中的几种旋转操作

在这里我们做一个规定，我们规定平衡因子（balance factor）等于左子树的高度减去左子树的高度。

1:右旋操作

2:左旋操作

3:左平衡操作

4:右平衡操作

3:代码实现

#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<stack>
#include<queue>
#include<algorithm>
#define LH +1
#define EH 0
#define RH -1
using namespace std;
struct AVLTreeNode {
	int val;				//节点值
	int bf;				//节点的平衡因子值
	struct AVLTreeNode * left;
	struct AVLTreeNode * right;
	AVLTreeNode(int a) :val(a), left(nullptr), right(nullptr) {}
};
void PrintAVLTree(AVLTreeNode *&root) {
	if (root == nullptr)
		return;
	cout << root->val << " ";
	PrintAVLTree(root->left);
	PrintAVLTree(root->right);
}
//右旋转
void Right_Rotation(AVLTreeNode * &root) {
	AVLTreeNode * Left = root->left;
	root->left = Left->right;
	Left->right = root;
	root = Left;
}
//左旋转
void Left_Rotation(AVLTreeNode * &root) {
	AVLTreeNode *Right = root->right;
	root->right = Right->left;
	Right->left = root;
	root = Right;
}
//左平衡
void LeftBalance(AVLTreeNode * &root) {
	AVLTreeNode * L = root->left;
	switch (L->bf) {
	case LH:
		root->bf = L->bf = EH;
		Right_Rotation(root);
		break;
	case RH:
		AVLTreeNode * Lr = L->right;
		switch (Lr->bf) {
		case LH:
			root->bf = RH;
			L->bf = EH;
			break;
		case EH:
			L->bf = root->bf = EH;
			break;
		case RH:
			L->bf = LH;
			root->bf = EH;
			break;
		}
		Lr->bf = EH;
		Left_Rotation(L);
		root->left = L;
		Right_Rotation(root);
		break;
	}
}
//右平衡
void RightBalance(AVLTreeNode * &root) {
	AVLTreeNode * R = root->right;
	switch (R->bf){
	case RH:
		root->bf = R->bf = EH;
		Left_Rotation(root);
		break;
	case LH:
		AVLTreeNode * Rl = R->left;
		switch (Rl->bf){
		case LH:
			root->bf = EH;
			R->bf = RH;
			break;
		case EH:
			root->bf = R->bf = EH;
			break;
		case RH:
			root->bf = LH;
			R->bf = EH;
			break;
		}
		Rl->bf = EH;
		Right_Rotation(R);
		root->right = R;
		Left_Rotation(root);	
	}
}
//插入数据
bool InsertAVL(AVLTreeNode * &root, int e,bool & taller) {
	if (!root)
	{	 //根节点为空或者已经递归到叶节点的子节点
		root = new AVLTreeNode(e);
		root->bf = EH;
		taller = true;
	}
else {
	if (e == root->val) {
		taller = false;
		return false;
	}
	else if (e > root->val) {
		if (!InsertAVL(root->right, e, taller))
			return false;
		if (taller) {
			switch (root->bf) {
			case EH:
				root->bf = RH;
				taller = true;
				break;
			case RH:
				RightBalance(root);
				taller = false;
				break;
			case LH:
				root->bf = EH;
				taller = false;
				break;
			}
		}
	}
	else if (e < root->val) {
		if (!InsertAVL(root->left, e, taller))
			return false;
		if (taller) {
			switch (root->bf) {
			case EH:
				root->bf = LH;
				taller = true;
				break;
			case LH:
				LeftBalance(root);
				taller = false;
				break;
			case RH:
				root->bf = EH;
				taller = false;
				break;
			}
		}
	}
}
return true;
}
//删除节点
bool DeleteAVLNode(AVLTreeNode * &root, int key, bool & shorter) {
	if (root == nullptr)
		return false;
	else if (key == root->val) {
		AVLTreeNode * tmp = nullptr;
		if (!root->left) {
			tmp = root;
			root = root->right;
			shorter = true;
			delete tmp;
		}
		else if (!root->right) {
			tmp = root;
			root = root->left;
			shorter = true;
			delete tmp;
		}
		else {
			tmp = root->left;
			while (tmp->right) 
				tmp = tmp->right;
			root->val = tmp->val;
			DeleteAVLNode(root->left, root->val, shorter);  
		}
	}
	else if (key < root->val) {
		if (!DeleteAVLNode(root->left, key, shorter))
			return false;
		if (shorter) {
			switch (root->bf){
			case LH:
				root->bf = EH;
				shorter = true;
				break;
			case EH:
				root->bf = RH;
				shorter = false;
				break;
			case RH:
				if (root->right->bf ==EH) {
					shorter = false;
				}
				else   shorter = true;
				RightBalance(root);
				break;
			}	 
		}


	}
	else  {
		if (!DeleteAVLNode(root->right, key, shorter))
			return false;
		if (shorter) {
			switch (root->bf)
			{
			case LH:
				if (root->left->bf == EH) {
					shorter = false;
				}
				else shorter = true;
				LeftBalance(root);
				break;
			case EH:  
				root->bf = LH;
				shorter = false;
				break;
			case RH:
				root->bf = EH;
				shorter = true;
				break;
			}
		}

	}
	return true;
}
//计算高度
int CalculateHeight(AVLTreeNode * root) {
	if (!root)
		return 0;
	 int LeftHeight = CalculateHeight(root->left);
	 int RightHeight = CalculateHeight(root->right);
	 return LeftHeight > RightHeight ? LeftHeight + 1 : RightHeight + 1;
}

这个代码我是用C/C++混合编程，里面很多应该用二级指针的地方我都用了一级指针加引用去替代了，目前自己跑的测试数据都没有太大问题，有问题的话希望大家指出来一起进步。