【c++】二叉搜索树、平衡二叉树（AVL树）的模拟实现及注意事项

二叉搜索树的概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

3.它的左右子树也分别为二叉搜索树

二叉搜索树的插入

核心思想一共3步：

1.根据性质来定位元素要插入的位置

2.判断是否有重复元素（插入）

3.修改插入操作后影响的结点指针的指向

二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点 -> 1.定位 2.找到左边最大的 3.与之置换 4.删除 5.修改受影响指针的指向

二叉搜索树实现代码

#include<iostream>
using namespace std;

template<class T>
struct BSTNode
{
	BSTNode(const T& data = T())
		:_pleft(nullptr),
		_pright(nullptr),
		_data(data)
	{}
	BSTNode<T>* _pleft;
	BSTNode<T>* _pright;
	T _data;
};

template<class T>
class BSTree
{
public:
	BSTree() :_proot(nullptr)
	{}
	BSTNode<T>* Copy(BSTNode<T>* proot)
	{
		if (proot)
		{
			BSTNode<T>* newnode = new BSTNode<T>(proot->_data);
			newnode->_pleft = Copy(proot->_pleft);
			newnode->_pright = Copy(proot->_pright);
			return newnode;
		}
		else
			return nullptr;
	}
	BSTree(const BSTree<T>& bst)
	{
		_proot = Copy(bst._proot);
	}
	BSTNode<T>& operator=(const BSTree<T>& bst)
	{
		if (this == bst){
			cout << "self assignment" << endl;
			return *this;
		}
		if (_proot)
		{
			Destory(_proot);
		}
		_proot = Copy(bst._proot);
		return *this;
	}
	void Destory(BSTNode<T>* proot)
	{
		if (proot)
		{
			Destory(proot->_pleft);
			Destory(proot->_pright);
			delete proot;
			proot = nullptr;
		}
	}
	~BSTree()
	{
		if (_proot)
			Destory(_proot);
	}
	BSTNode<T>* Find(const T& data)
	{
		BSTNode<T>* pcur = _proot;
		while (pcur){
			if (pcur->_data == data)
				return pcur;
			else if (data > pcur->_data)
				pcur = pcur->_pright;
			else
				pcur = pcur->_pleft;
		}
		return nullptr;
	}
	bool IsExist(const T& data)
	{
		BSTNode<T>* pcur = _proot;
		while (pcur){
			if (pcur->_data == data)
				return true;
			else if (data > pcur->_data)
				pcur = pcur->_pright;
			else
				pcur = pcur->_pleft;
		}
		return false;
	}
	bool Insert(const T& data)
	{
		if (_proot == nullptr){
			_proot = new BSTNode<T>(data);
			return true;
		}
		BSTNode<T>* pcur = _proot;
		BSTNode<T>* pparent = nullptr;
		while (pcur)
		{
			pparent = pcur;
			if (data == pcur->_data)
			{
				cout << "ele "<< pcur->_data <<" exist" <<endl;
				return false;
			}
			else if (data > pcur->_data)
				pcur = pcur->_pright;
			else
				pcur = pcur->_pleft;
		}
		pcur = new BSTNode<T>(data);
		if (data > pparent->_data)
			pparent->_pright = pcur;
		else
			pparent->_pleft = pcur;
		return true;
	}
	bool Delete(const T& data)
	{
		if (_proot == nullptr){
			cout << "this is an empty tree!" << endl;
			return false;
		}
		BSTNode<T>* pcur = _proot;
		BSTNode<T>* pparent = nullptr;
		/*if (!IsExist(data))
		{
			cout << data << " don't exist " << endl;
			return false;//没有该元素
		}*/
		while (pcur){
			//定位要删除的元素，及其父亲节点
			if (data == pcur->_data)
				break;//ele exist
			else if (data > pcur->_data){
				pparent = pcur;
				pcur = pcur->_pright;
			}else{
				pparent = pcur;
				pcur = pcur->_pleft;
			}
		}
		if (pcur == nullptr)
		{
			cout << data << " don't exist " << endl;
			return false;//没有该元素
		}
		if (pcur->_pleft == nullptr&&pcur->_pright == nullptr){
			//删除叶子结点
			if (pparent == nullptr)
				_proot = nullptr;
			else{
				if (pparent->_pleft == pcur)
					pparent->_pleft = nullptr;
				else
					pparent->_pright = nullptr;
			}
			delete pcur;
			pcur = nullptr;
		}
		else if (pcur->_pleft == nullptr){
			//删除结点左孩子为空
			if (pparent == nullptr)
				_proot = pcur->_pright;
			else{
				if (pparent->_pleft == pcur)
					pparent->_pleft = pcur->_pright;
				else
					pparent->_pright = pcur->_pright;
			}
			delete pcur;
			pcur = nullptr;
		}
		else if (pcur->_pright == nullptr){
			//删除结点右孩子为空
			if (pparent == nullptr)
				_proot = pcur->_pleft;
			else{
				if (pparent->_pleft == pcur)
					pparent->_pleft = pcur->_pleft;
				else
					pparent->_pright = pcur->_pleft;
			}
			delete pcur;
			pcur = nullptr;
		}
		else {
			//左右孩子均存在
			BSTNode<T>* leftmax = pcur->_pleft;
			pparent = pcur;
			//找左边最大
			while (leftmax->_pright)
			{
				pparent = leftmax;
				leftmax = leftmax->_pright;
			}
			//置换，并连接
			pcur->_data = leftmax->_data;
			if (pparent->_pright == leftmax)
				pparent->_pright = leftmax->_pleft;
			else
				pparent->_pleft = leftmax->_pleft;
			//删除
			delete leftmax;
			leftmax = nullptr;
		}
	}
	void Inorder()
	{
		_Inorder(_proot);
		cout << endl;
	}
	void _Inorder(BSTNode<T>* root)
	{
		if (root){
			_Inorder(root->_pleft);
			cout << root->_data << " ";
			_Inorder(root->_pright);
		}
	}
private:
	BSTNode<T>* _proot;
};

int main()
{
	BSTree<int> T1;
	T1.Insert(2); T1.Insert(7); T1.Insert(8); T1.Insert(4);
	T1.Insert(6); T1.Insert(8); T1.Insert(-1); T1.Insert(1);
	T1.Insert(3); T1.Insert(-3); T1.Insert(100); T1.Insert(9);
	T1.Inorder();
	BSTree<int> T2(T1);
	T2.Inorder();
	T2.Delete(10);
	T2.Delete(8);
	BSTree<int>T3 = T2;
	T3.Inorder();
	getchar();
	return 0;
}

AVL树的概念

一棵树或者是空树，或者是具有以下性质的二叉搜索树：

1.它的左右子树都是AVL树

2.左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

3.平衡因子值 = 右子树高度 - 左子树高度

AVL树的插入（旋转）

与搜索树的基本步骤相同，分为三步，定位，判断（插入），修改指向。

但是为了维护AVL树的平衡，需要进行旋转操作。这里记录右旋与左右双旋的过程。左单旋和右左双旋自行对比。

平衡因子有着表示树的形状的功能，根据平衡因子能反应出树的多种形态。后面记做bf。

bf = 0，说明该树左右一样高；

bf < 0 ，左边高；若 bf = -2 则进行右旋。

bf > 0， 右边高；若 bf = 2 则进行左旋。

插入新节点后，使 P 结点的 bf = -2，此时需要对P结点进行旋转。 

更新平衡因子时也需要分两种情况，一种是P有PR，一种是P没有PR

有一个值得注意的坑：进行一次插入操作还未旋转时，不存在这样一棵树

因为在本次插入之前，他就已经不平衡了。所以不存在既没有有PR，又有PLR的情况

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

2. 验证其为平衡树

每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)

节点的平衡因子是否计算正确

AVL树实现代码

#include<iostream>
#include<string>
//#include<Windows.h>
using namespace std;

template<class T>
struct AVLTreeNode{
	AVLTreeNode(const T& data):_pparent(nullptr)
	, _pleft(nullptr)
	, _pright(nullptr)
	, _data(data)
	, _bf(0)
	{}

	AVLTreeNode<T>* _pparent;
	AVLTreeNode<T>* _pleft;
	AVLTreeNode<T>* _pright;
	T _data;
	int _bf;
};

template<class T>
class AVLTree{
private:
	AVLTreeNode<T>* _proot;
public:
	AVLTree() :_proot(nullptr)
	{}
	~AVLTree()
	{
		_Destroy(_proot);
	}
	bool InsertNode(const T& data)
	{
		if (_proot == nullptr)
		{
			_proot = new AVLTreeNode<T>(data);
			return true;
		}
		AVLTreeNode<T>* pcur = _proot;
		AVLTreeNode<T>* pparent = nullptr;
		while (pcur)
		{
			pparent = pcur;
			if (data < pcur->_data)
				pcur = pcur->_pleft;
			else if (data > pcur->_data)
				pcur = pcur->_pright;
			else
			{
				cout << "已有该元素，插入失败" << endl;
				return false;
			}
		}
		pcur = new AVLTreeNode<T>(data);
		if (data < pparent->_data)
			pparent->_pleft = pcur;
		else
			pparent->_pright = pcur;
		pcur->_pparent = pparent;
		
		while (pparent)
		{
			if (pcur == pparent->_pleft)
				pparent->_bf--;
			else
				pparent->_bf++;
			if (pparent->_bf == 0)
				return true;
			else if (pparent->_bf == 1 || pparent->_bf == -1){
				pcur = pparent;
				pparent = pcur->_pparent;
			}
			else{
				if (pparent->_bf == -2)//左边高
				{
					if (pparent->_bf*pparent->_pleft->_bf < 0)//pp与pPL异号则双旋，否则单旋
						LRrotate(pparent);
					else
						Rrotate(pparent);
				}
				else//右边高
				{
					if (pparent->_bf*pparent->_pright->_bf < 0)
						RLrotate(pparent);
					else
						Lrotate(pparent);
				}
				break;
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_proot);
		cout << endl;
	}
	void IsBalanceTree()
	{
		if (_IsBalanceTree(_proot))
			cout << "Y" << endl;
		else
			cout << "N" << endl;
	}
private:
	void Rrotate(AVLTreeNode<T>* pparent)
	{
		AVLTreeNode<T>* pPP = pparent->_pparent;
		AVLTreeNode<T>* pPL = pparent->_pleft;
		AVLTreeNode<T>* pPLR = pPL->_pright;
		if (pPLR){//如果pPLR存在，则旋转5连+更新bf
			pparent->_pparent = pPL;
			pparent->_pleft = pPLR;
			pPL->_pright = pparent;
			pPL->_pparent = pPP;
			pPLR->_pparent = pparent;
			if (pparent->_pright){
				pparent->_bf = pPL->_bf = 0;
			}
			else{
				//不存在该情况，错误例子。只能在pPLR存在时出现该情况。
				pparent->_bf++; pPL->_bf++;
			}
		}
		else{
			pparent->_pparent = pPL;
			pparent->_pleft = nullptr;//坑！pPLR不存在的时候也不能忽略 pp的left的指向！
			pPL->_pright = pparent;
			pPL->_pparent = pPP;
			if (pparent->_pright){
				pparent->_bf = 1; pPL->_bf = 0;
			}
			else{
				pparent->_bf = pPL->_bf = 0;
			}
			//pPL->_bf = 0;
		}
		if (!pPP){
			_proot = pPL;
			pPL->_pparent = nullptr;
		}
		else{
			if (pPP->_pleft == pparent)
				pPP->_pleft = pPL;
			else
				pPP->_pright = pPL;
		}
		//pparent->_bf = pPL->_bf = 0;
	}
	void Lrotate(AVLTreeNode<T>* pparent)
	{
		AVLTreeNode<T>* pPP = pparent->_pparent;
		AVLTreeNode<T>* pPR = pparent->_pright;
		AVLTreeNode<T>* pPRL = pPR->_pleft;
		if (pPRL){
			pparent->_pparent = pPR;
			pparent->_pright = pPRL;
			pPR->_pleft = pparent;
			pPR->_pparent = pPP;
			pPRL->_pparent = pparent;
			pparent->_bf = pPR->_bf = 0;
		}
		else{
			pparent->_pparent = pPR;
			pparent->_pright = nullptr;
			pPR->_pleft = pparent;
			pPR->_pparent = pPP;
			if (pparent->_pleft){
				pparent->_bf = -1; pPR->_bf = 0;
			}
			else{
				pparent->_bf = pPR->_bf = 0;
			}
		}
		if (!pPP){
			_proot = pPR;
			pPR->_pparent = nullptr;
		}
		else{
			if (pPP->_pleft == pparent)
				pPP->_pleft = pPR;
			else
				pPP->_pright = pPR;
		}
	}
	void LRrotate(AVLTreeNode<T>* pparent)
	{
		AVLTreeNode<T>* pPL = pparent->_pleft; 
		AVLTreeNode<T>* pPLR = pPL->_pright;
		Lrotate(pPL);
		Rrotate(pparent);
	}
	void RLrotate(AVLTreeNode<T>* pparent)
	{
		AVLTreeNode<T>* pPR = pparent->_pright;
		AVLTreeNode<T>* pPRL = pPR->_pleft;
		Rrotate(pPR);
		Lrotate(pparent);
	}
	void _Destroy(AVLTreeNode<T>*& proot)
	{
		if (proot)
		{
			_Destroy(proot->_pleft);
			_Destroy(proot->_pright);
			delete proot;
			proot = nullptr;
		}
	}
	void _InOrder(AVLTreeNode<T>* proot)
	{
		if (proot)
		{
			_InOrder(proot->_pleft);
			cout << proot->_data<<" ";
			_InOrder(proot->_pright);
		}
	}
	int _Height(AVLTreeNode<T>* proot)
	{
		if (!proot)
			return 0;
		int leftHeight = _Height(proot->_pleft);
		int rightHeight = _Height(proot->_pright);
		return (leftHeight > rightHeight) ? (leftHeight+1) : (rightHeight+1);
		//别他妈写leftHeight++,那是把值返回去之后再+1，傻逼！
	}
	bool _IsBalanceTree(AVLTreeNode<T>* proot)
	{
		if (!proot)
			return true;
		int leftHeight = _Height(proot->_pleft);
		int rightHeight = _Height(proot->_pright);
		int diff = rightHeight - leftHeight;
		if (diff != proot->_bf || (diff<-1 || diff>1))
			return false;
		return _IsBalanceTree(proot->_pleft) && _IsBalanceTree(proot->_pright);
	}
};

int main()
{
	int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 9 };
	//int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
	//int a[] ={4, 2, 6, 1, 3, 5, 15, 7, 16, 14};//特殊场景用例
	AVLTree<int> t;
	for (auto e : a)
		t.InsertNode(e);
	//getchar();
	//cout << "inorder" << endl;
	t.InOrder();
	t.IsBalanceTree();
	getchar();
	//system("pause");
	return 0;
}