AVLTREE

#ifndef __MYAVLTREE__
#define __MYAVLTREE__

template<typename Comparable>
class AvlTree;

template<typename Comparable>
class AvlNode {
	friend class AvlTree<Comparable>;
	Comparable elem;//元素
	AvlNode* lchild;//左子树
	AvlNode* rchild;//右子树
	int height;//当前节点高度，计算时空节点的高度按-1计算
public:
	AvlNode(const Comparable& e, AvlNode* l, AvlNode* r, int h = 0) :elem(e), lchild(l), rchild(r), height(h) {}
	~AvlNode() {
		makeEmty(this);
	}
	void makeEmpty(AvlNode* t);
};

template<typename Comparable>
class AvlTree {
public:
	AvlTree() :root(nullptr) {}//构造函数
	AvlTree(AvlNode<Comparable>* r) :root(r) {}
	AvlTree(const AvlTree& AT);//拷贝构造
	~AvlTree();//析构函数
	AvlTree(const AvlTree&& AT)noexcept;//移动构造
	AvlTree& operator=(const AvlTree& AT);//拷贝赋值运算符
	AvlTree& operator=(const AvlTree&& AT)noexcept;//移动赋值运算符
	void insert(const Comparable e);//插入元素e
	bool contain(const Comparable e)const;//判断是否含有元素e，可用递归或非递归实现
	void remove(const Comparable e);//删除元素e
	void makeEmpty();//清空子树
	bool isEmpty();//判断子树是否为空
	int getHeight()const;//返回树的高度
	void printTree()const;//打印子树
private:
	static const int ALLOWED_IMBALANCE = 1;
	AvlNode<Comparable>* root;//根节点指针
	int getHeight(AvlNode<Comparable>* root);//返回子树高度，若指针为空，返回-1
	int max(int lhs, int rhs)const;//返回最大值
	void printTree(AvlNode<Comparable>* root)const;//内部打印函数
	AvlNode<Comparable>* clone( AvlNode<Comparable>*  root)const;//拷贝子树方法
	void insert(const Comparable& e, AvlNode<Comparable>*& root);//内部插入函数
	bool contain(const Comparable& e, AvlNode<Comparable>* root)const;//内部函数判断是否包含元素
	void remove(const Comparable& e, AvlNode<Comparable>*& root);//内部删除函数
	void makeEmpty(AvlNode<Comparable>* root);//内部清空函数
	Comparable& findMin(AvlNode<Comparable>* root);//寻找子树最小值，返回其引用
	Comparable& finMax(AvlNode<Comparable>* root);//寻找子树最大值
	void rotateWithLeftChild(AvlNode<Comparable>*& root);//LL
	void rotateWithRightChild(AvlNode<Comparable>*& root);//RR
	void doubleWithLeftChild(AvlNode<Comparable>*& root);//LR
	void doubleWithRightChild(AvlNode<Comparable>*& root);//RL
	void balance(AvlNode<Comparable>* root);//平衡子树，并且重置高度
};
#endif

#include"myAvlTree.h"
#include<iostream>
template<typename Comparable>void  AvlNode<Comparable>::
makeEmpty(AvlNode* t) {
	if (t) {
		makeEmpty(t->lchild);
		makeEmpty(t->rchild);
		delete t;
	}
	t = nullptr;
}

template<typename Comparable> AvlTree<Comparable>::
AvlTree(const AvlTree& AT) {
	clone(AT.root);
}

template<typename Comparable> AvlTree<Comparable>::
~AvlTree() {
	makeEmpty();
}

template<typename Comparable> AvlTree<Comparable>::
AvlTree(const AvlTree&& AT) noexcept :root(AT.root) {
	AT.root = nullptr;
}

template<typename Comparable> AvlTree<Comparable>&  AvlTree<Comparable>::
operator=(const AvlTree& AT) {
	clone(AT.root);
	return *this;
}

template<typename Comparable> AvlTree<Comparable>& AvlTree<Comparable>::
operator=(const AvlTree&& AT)noexcept {
	if (this != &AT) {
		this->root = AT.root;
		AT.root = nullptr;
	}
	return *this;
}

template<typename Comparable> void AvlTree<Comparable>::
insert(const Comparable e) {
	insert(e, root);
}

template<typename Comparable> bool  AvlTree<Comparable>::
contain(const Comparable e)const {
	return contain(e, root);
}

template<typename Comparable> void  AvlTree<Comparable>::
remove(const Comparable e) {
	if (contain(e))
		remove(e, root);
	else
		std::cout << "要删除元素不存在";
}

template<typename Comparable> void  AvlTree<Comparable>::
makeEmpty() {
	makeEmpty(root);
}

template<typename Comparable> bool  AvlTree<Comparable>::
isEmpty() {
	return root == nullptr;
}

template<typename Comparable> int  AvlTree<Comparable>::
getHeight()const {
	return getHeight(root);
}

template<typename Comparable> void  AvlTree<Comparable>::
printTree()const {
	printTree(root);
}

template<typename Comparable> int  AvlTree<Comparable>::
getHeight(AvlNode<Comparable>* root) {
	return root == nullptr ? -1 : root->height;
}

template<typename Comparable> int  AvlTree<Comparable>::
max(int lhs, int rhs)const {
	return lhs > rhs ? lhs : rhs;
}

template<typename Comparable> void  AvlTree<Comparable>::
printTree(AvlNode<Comparable>* root)const {
	if (!root)
		return;
	printTree(root->lchild);
	std::cout << root->elem;
	printTree(root->rchild);
}

template<typename Comparable> AvlNode<Comparable>* AvlTree<Comparable>::
clone( AvlNode<Comparable>* root)const {
	if (!root)
		return nullptr;
	return new AvlNode(root->elem, clone(root->lchild), clonr(root->rchild), root->height);
}

template<typename Comparable> void AvlTree<Comparable>::
insert(const Comparable& e, AvlNode<Comparable>*& root) {
	if (!root)
		root = new AvlNode<Comparable>(e, nullptr, nullptr);
	else if (e < root->elem)
		insert(e, root->lchild);
	else if (root->elem < e)
		insert(e, root -> rchild);
	balance(root);
}

template<typename Comparable> bool AvlTree<Comparable>::
contain(const Comparable& e, AvlNode<Comparable>* root)const {
	if (!root)
		return false;
	else if (e < root->elem)
		return contain(e, root->lchild);
	else if (root->elem < root)
		return contain(root->rchild);
	else
		return true;
}

template<typename Comparable> void AvlTree<Comparable>::
remove(const Comparable& e, AvlNode<Comparable>*& root) {
	if (e < root->elem)
		remove(e, root->lchild);
	else if (root->elem < e)
		remove(e, root->rchild);
	else {
		if (root->lchild && root->rchild) {
			root->elem = findMin(root -> rchild);
			remove(root->elem, root->right);
		}
		else if (root->lchild) {
			root = root->lchild;
		}
		else {
			root = root->rchild;
		}
	}
}

template<typename Comparable> void AvlTree<Comparable>::
makeEmpty(AvlNode<Comparable>* root) {
	if (root) {
	makeEmpty(root->lchild);
	makeEmpty(root->rchild);
	delete root;
	}
	root = nullptr;
}

template<typename Comparable> Comparable& AvlTree<Comparable>::
findMin(AvlNode<Comparable>* root) {
	while (root->lchild)
		root = root->lchild;
	return root->elem;
}

template<typename Comparable> Comparable& AvlTree<Comparable>::
finMax(AvlNode<Comparable>* root) {
	while (root->rchild)
		root = root->rchild;
	return root->elem;
}

template<typename Comparable> void AvlTree<Comparable>::
rotateWithLeftChild(AvlNode<Comparable>*& root) {
	AvlNode<Comparable>* old = root;
	root = root->lchild;
	old->lchild = root->rchild;
	root->rchild = old;
	old->height = max(getHeight(old->lchild), getHeight(old->rchild)) + 1;
	root->height = max(getHeight(root->lchild), getHeight(old)) + 1;
}

template<typename Comparable> void AvlTree<Comparable>::
rotateWithRightChild(AvlNode<Comparable>*& root) {
	AvlNode<Comparable>* old = root;
	root = root->rchild;
	old->rchild = root->lchild;
	root->lchild = old;
	old->height = max(getHeight(old->lchild), getHeight(old->rchild)) + 1;
	root->height = max(getHeight(root->lchild), getHeight(old)) + 1;
}

template<typename Comparable> void AvlTree<Comparable>::
doubleWithLeftChild(AvlNode<Comparable>*& root) {
	rotateWithRightChild(root->lchild);
	rotateWithLeftChild(root);
}

template<typename Comparable> void AvlTree<Comparable>::
doubleWithRightChild(AvlNode<Comparable>*& root) {
	rotateWithLeftChild(root->rchild);
	rotateWithRightChild(root);
}

template<typename Comparable> void AvlTree<Comparable>::
balance(AvlNode<Comparable>* root) {
	if (getHeight(root -> lchild) - getHeight(root->rchild) > ALLOWED_IMBALANCE) {
		if (getHeight(root->lchild->rchild) < getHeight(root->lchild->lchild))
			rotateWithLeftChild(root);
		else
			doubleWithLeftChild(root);
	}
	else if (getHeight(root->rchild) - getHeight(root -> lchild) > ALLOWED_IMBALANCE) {
		if (getHeight(root->rchild->lchild) < getHeight(root->rchild->rchild))
			rotateWithRightChild(root);
		else
			doubleWithRightChild(root);
	}
	root->height = max(getHeight(root->lchild), getHeight(root->rchild));
}