二叉搜索树的概念
二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树:
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;
}