AVL平衡搜索树C++实现

高度：

用递归实现了从下向上查找失衡节点。

四种旋转：（不会用电脑画图，字迹也不好）

LL：在一个节点的左子树的左子树上插入一个新节点，通过将节点右旋使其平衡。
RR：在一个节点的右子树的右子树上插入一个新节点，通过将节点左旋使其平衡。
LR：在一个节点的左子树的右子树上插入一个新节点，先进行一次左旋，变成了LL，再进行一次单右旋操作。
RL：在一个节点的右子树的左子树上插入一个新节点，先进行一次右旋，变成了RR，再进行一次单左旋操作。

#include<queue>
#include<iostream>
using namespace std;
int max(int a, int b)
{
	return a > b ? a : b;
}
template<class T>
struct Node
{
	T key;
	int h;//结点所处的高度
	Node<T>* left;//左 右
	Node<T>* right;
	Node(T v):key(v), h(0), left(nullptr), right(nullptr) {}
};

template<class T>
class Tree
{
private:
	Node<T>* root;
public:
	Tree() { root = nullptr; }
	~Tree();
	int height();//获取高度
	void PreOrder();//前序遍历
	void InOrder();//中序遍历
	void PostOrder();//后续遍历
	bool insert(T key);//插入
	void bfs(Node<T>*);//深度优先搜索逐层遍历
	Node<T>* ROOT() { return root; }//返回根指针
	Node<T>* SearchT(T k);//搜索
	void remove(T k);//删除

private:
	//私有方法，对某个子树作用
	void preOrder(Node<T>*);
	void inOrder(Node<T>*);
	void postOrder(Node<T>*);
	int height(Node<T>* t);
	Node<T>* LL(Node<T>* t);
	Node<T>* RR(Node<T>* t);
	Node<T>* LR(Node<T>* t);
	Node<T>* RL(Node<T>* t);
	Node<T>* insert(Node<T>* tree, T key);
	Node<T>* remove(Node<T>* tree, Node<T>* z);
	Node<T>* Max(Node<T>* x);
	Node<T>* Min(Node<T>* x);    //以x为根子树最小元素
	void Destory(Node<int>*);
};

旋转：

template<class T>
Node<T>* Tree<T>::LL(Node<T>* t)//旋转 LL型（返回该子树新的根结点指针）
{
	Node<T>* tc = t->left;
	t->left = tc->right;
	tc->right = t;
	t->h = max(height(t->left), height(t->right)) + 1;//tc的右结点为t，必须先更新t。t新的左右子树的高度未变。
	tc->h = max(height(tc->left), height(tc->right)) + 1;
	return tc;
}

template<class T>
Node<T>* Tree<T>::RR(Node<T>* t)//旋转 RR
{
	Node<T>* tc = t->right;
	t->right = tc->left;
	tc->left = t;
	t->h = max(height(t->left), height(t->right)) + 1;
	tc->h = max(height(tc->left), height(tc->right)) + 1;
	return tc;
}

template<class T>
Node<T>* Tree<T>::LR(Node<T>* t)//LR 先R再L
{
	t->left = RR(t->left);
	return LL(t);
}

template<class T>
Node<T>* Tree<T>::RL(Node<T>* t)
{
	t->right = LL(t->right);
	return RR(t);
}

搜索结点：

template<class T>
Node<T>* Tree<T>::SearchT(T x)
{
	Node<int>* t = root;
	while (t != nullptr&&t->key != x)
	{
		if (x < t->key)
			t = t->left;
		else t = t->right;
	}
	return t;
}

最大最小、获取高度：

template<class T>
int Tree<T>::height(Node<T>* t)
{
	if (t != nullptr)
		return t->h;
	return 0;
}

template<class T>
int Tree<T>::height()
{
	return height(root);
}

template<class T>
Node<T>* Tree<T>::Max(Node<T>* x)
{
	while (x->right != nullptr)
		x = x->right;
	return x;
}

template<class T>
Node<T>* Tree<T>::Min(Node<T>* x)    //以x为根子树最小元素
{
	while (x->left != nullptr)
		x = x->left;
	return x;
}

插入：

template<class T>
Node<T>* Tree<T>::insert(Node<T>* tree, T key)
{
	if (tree == nullptr)
		tree = new Node<T>(key);
	else if (key < tree->key)
	{
		tree->left = insert(tree->left, key);  //key插入TREE左子树，以递归实现自下向上寻找失衡点
		if (height(tree->left) - height(tree->right) == 2)
		{
			if (key < tree->left->key)
				tree = LL(tree);
			else
				tree = LR(tree);
		}
	}
	else if (key > tree->key)
	{
		tree->right = insert(tree->right, key);
		if (height(tree->right) - height(tree->left) == 2)
		{
			if (key > tree->right->key)
				tree = RR(tree);
			else
				tree = RL(tree);
		}
	}
	else
	{
		cout << "Two equal key is abandoned!\n";
		return nullptr;
	}
	tree->h = max(height(tree->right), height(tree->left)) + 1;
	return tree;
}

template<class T>
bool Tree<T>::insert(T key)
{
	Node<T>* t = insert(root, key);
	if (t != nullptr)
	{
		root = t;
		return true;
	}
	else
		return false;
}

删除：

template<class T>
Node<T>* Tree<T>::remove(Node<T>* tree, Node<T>* z)
{
	if (tree == nullptr || z == nullptr)
		return nullptr;
	if (z->key < tree->key)
	{
		tree->left = remove(tree->left, z);//递归
		if (height(tree->right) - height(tree->left) == 2)
		{
			Node<T>* s = tree->right;
			if (height(s->left) > height(s->right))
				tree = RL(tree);
			else
				tree = RR(tree);
		}
	}
	else if (z->key > tree->key)
	{
		tree->right = remove(tree->right, z);
		if (height(tree->left) - height(tree->right) == 2)
		{
			Node<T>* s = tree->left;
			if (height(s->right) > height(s->left))
				tree = LR(tree);
			else
				tree = LL(tree);
		}
	}
	else//递归到了要删除的结点
		if ((tree->left != nullptr) && (tree->right != nullptr))
		{
			if (height(tree->left) > height(tree->right))
			{
				Node<T>* max = Max(tree->left);//替换的方法
				tree->key = max->key;
				tree->left = remove(tree->left, max);
			}
			else
			{
				Node<T>* min = Min(tree->right);
				tree->key = min->key;
				tree->right = remove(tree->right, min);
			}
		}
		else
		{
			Node<T>* l = tree;
			tree = (tree->left != nullptr) ? tree->left : tree->right;
			delete l;
		}
	return tree;
}

template<class T>
void Tree<T>::remove(T k)
{
	Node<int>* z;
	if ((z = SearchT(k)) != nullptr)
		root = remove(root, z);
	else
		cout << "WRONG!\n";
}

遍历输出：

template<class T>
void Tree<T>::bfs(Node<T>* x)
{
	if (x == nullptr)
		return;
	queue<Node<T>*> q;
	q.push(x);
	Node<T>* t;
	while (!q.empty())
	{
		t = q.front();
		q.pop();
		if (t->left != nullptr)
		{
			cout << t->key << "'s L : " << t->left->key << '\t' << endl;
			q.push(t->left);
		}
		if (t->right != nullptr)
		{
			cout << t->key << "'s R : " << t->right->key << endl;
			q.push(t->right);
		}
	}
}

template<class T>
void Tree<T>::preOrder(Node<T>* x)
{
	if (x != nullptr)
	{
		cout << x->v;
		preOrder(x->left);
		preOrder(x->right);
	}
}
template<class T>
void Tree<T>::inOrder(Node<T>* x)
{
	if (x != nullptr)
	{
		inOrder(x->left);
		cout << x->v;
		inOrder(x->right);
	}
}
template<class T>
void Tree<T>::postOrder(Node<T>* x)
{
	if (x != nullptr)
	{
		Be_T_Walk(x->left);
		Be_T_Walk(x->right);
		cout << x->v;
	}
}

template<class T>
void Tree<T>::PreOrder()
{
	preOrder(root);
}

template<class T>
void Tree<T>::InOrder()
{
	inOrder(root);
}

template<class T>
void Tree<T>::PostOrder()
{
	postOrder(root);
}

析构销毁：

template<class T>
void Tree<T>::Destory(Node<int>* t)
{
	if (t != nullptr)
	{
		Destory(t->left);
		Destory(t->right);
		delete t;
	}
}

template<class T>
inline Tree<T>::~Tree()
{
	Destory(root);
}

完