能学到这里，相信你已经对树有了基本的认识，了解了输的结构以及特殊树–二叉树有了初步的认识，在AVL树之前你可能学过搜索二叉树，它主要是为了方便数据搜索建立的二叉树，以根节点作为分水岭，将数据和根节点比较来决定数据放在根节点的左右子树中，在和子树中的节点中的数据进行比较决定最终数据时节点的左右子节点。
而这里的平衡搜索二叉树不仅做到了搜索二叉树的功能，它还大大降低了查找节点的深度，保证了整个树的每个节点的高度相差不超过1，从而达到高效率的搜索效果，它的平均查找次数为Log2N(假设有n个节点)，AVL搜索树的出现有效的提高了查找的速度，提高了效率。
AVL树的平衡就体现在它严格要求的就是它的每一个节点的左右子女节点的高度差绝对值都不能超过1，有人喜欢用左树的高度减右树的高度，一般使用有数的高度减去左树的高度取绝对值，二者结果均可作为一棵树是否为AVL树的凭据。如果某个节点的高度差绝对值超过2那么该节点就不平衡需要对该节点进行调整。概念性的我们不多说，下面我们直入主题：
1、AVL树节点调整的两大状态：
1）单旋转：
（1）左单旋转：
（2）右单旋转：
2）双旋转：
（1）左右旋转：先进行左旋转之后后旋转。
（2）右左旋转：先进行右旋转，之后左旋转。
以上四种情况只是简单状况，但是如果在代码种我们需要考虑更为复杂的情况，比如在下面我们双旋转的情况我们需要考虑这两种情况：
红色为最终的根节点。在双旋转代码展示的时候会配有具体的旋转图解，右边旋转同理。
2、代码实现：
在AVL中除了两种方法和前面的搜索二叉树以及二叉树方法不同，其他都相同，那就是AVL树的增加节点和删除节点比较难，因为AVL树有平衡因子的存在，所以每次的操作我们都需要考虑到树的平衡因素。在将不平衡节点调整平衡后还需要将其与树连接起来，为了修改平衡因子需要记录节点走过的路径，这里借助栈来记录节点走过的路径，将走过的节点一一入栈，回退的时候刚好是之前走过的路径。这里也主要写的是AVL树的增加和删除节点。
//**函数头文件：**
#pragma once
#include<stack>
template<class Type>
class AVLTree;
template<class Type>
class AVLnode
{
friend class AVLTree<Type>;
public:
AVLnode():data(Type()),leftchild(NULL),rightchild(NULL),bf(0)
{}
AVLnode(Type d = Type(), AVLnode* left = NULL, AVLnode* right = NULL, int bf1 = 0):data(d),leftchild(left),rightchild(right),bf(bf1)
{}
private:
Type data;
AVLnode *leftchild;
AVLnode* rightchild;
int bf;
};
template<class Type>
class AVLTree
{
public:
AVLTree():root(NULL)
{}
AVLTree(const Type &x)
{
Insert(root, x);
}
public:
void Insert(const Type &x)
{
Insert(root, x);
}
bool Remove(const Type &x)
{
Remove(root, x);
}
bool find(const Type & key)
{
find(root, key);
}
public:
//增加节点操作
void Insert(AVLnode<Type> *&rt, const Type &x)//需要借助栈来记录路径
{
AVLnode<Type> *q = NULL;
AVLnode<Type> *t = rt;
stack<AVLnode<Type> *> st;
while(t != NULL)
{
if(x == t->data)
return ;
q = t;
st.push(q);
if(x < t->data)
{
t = t->leftchild;
//不在这里更改bf，是因为防止相等，在插入后才能回退的方式来更改平衡因子，
//没有成功插图就不需要更改平衡因子
}
else if(x > t->data)
t = t->rightchild;
}
t = new AVLnode<Type>(x);
if(rt == NULL)
{
rt = t;
return ;
}
else if(x < q->data)
q ->leftchild = t;
else
q->rightchild = t;
while(!st.empty())
{
q = st.top();
st.pop();
if(q->leftchild == t)
q->bf --;
else
q->bf ++;
if(q->bf == 0)
break;
else if(q->bf == 1 || q->bf == -1)
t = q;
else
{//调整
if(q->bf < 0)
{
if(t->bf<0)// /
{
RotateR(q);
}
else// <
{
RotateLR(q);
}
}
else
{
if(t->bf > 0)// \//
{
RotateL(q);
}
else// >
{
RotateRL(q);
}
}
break;
}
}
if(st.empty())
{
rt = q;
}
else
{
AVLnode<Type>* p = st.top();
if(q->data < p->data)
p->leftchild = q;
else
p->rightchild = q;
}
}
//删除节点操作
bool Remove(AVLNode<Type> *&t, const Type &key)
{
//1
if(t == NULL)
return false;
AVLNode<Type> *p = t;
AVLNode<Type> *q;
AVLNode<Type> *pr = NULL;
stack<AVLNode<Type> *> st;
while(p != NULL)
{
if(p->data == key)
break;
pr = p;
st.push(pr);
if(key < p->data)
p = p->leftChild;
else
p = p->rightChild;
}
if(p == NULL)
return false;
//
if(p->leftChild!=NULL && p->rightChild!=NULL)
{
pr = p;
st.push(pr);
q = p->leftChild;
while(q->rightChild != NULL)
{
pr = q;
q = q->rightChild;
}
p->data = q->data;
p = q;
}
//
if(p->leftChild != NULL)
q = p->leftChild;
else
q = p->rightChild;
if(pr == NULL)
t = q;
else
{
if(pr->leftChild == p)
pr->leftChild = q;
else
pr->rightChild = q;
///
while(!st.empty())
{
pr = st.top();
st.pop();
if(pr->leftChild == q)
pr->bf++;
else
pr->bf--;
if(pr->bf==1 || pr->bf==-1)
break;
else if(pr->bf == 0)
q = pr;
else
{
if(pr->bf > 0)
q = pr->rightChild;
else
q = pr->leftChild;
if(q->bf == 0) // 单旋转
{
if(pr->bf > 0)
{
RotateL(pr);
pr->bf = -1;
pr->leftChild->bf = 1;
}
else
{
RotateR(pr);
pr->bf = 1;
pr->rightChild->bf = -1;
}
break;
}
else if(q->bf > 0)
{
if(pr->bf > 0) // \
{
RotateL(pr);
}
else // <
{
RotateLR(pr);
//cout<<"RotateLR"<<endl;
}
}
else
{
if(pr->bf < 0) // /
{
RotateR(pr);
}
else // >
{
RotateRL(pr);
}
}
if(!st.empty())
{
AVLNode<Type> *ppr = st.top();
if(ppr->data > pr->data )
ppr->leftChild = pr;
else
ppr->rightChild = pr;
}
q = pr;
}
}
if(st.empty())
t = pr;
else
{
AVLNode<Type> *ppr = st.top();
if(ppr->data > pr->data )
ppr->leftChild = pr;
else
ppr->rightChild = pr;
}
}
delete p;
return true;
}
bool find(AVLnode<Type> *&t, const Type &key)
{
if(t == NULL)
return false;
else
{
if(key == t->data)
return true;
else if(key < t->data)
find(t->leftchild,key);
else
find(t->rightchild,key);
}
}
protected://将调整方法设为保护方法，防止外部调用引起的错误操作
AVLnode<Type > * RotateR(AVLnode<Type> *&q)
{
AVLnode<Type> * p = q->leftchild;
q->leftchild = p->rightchild;
p->rightchild = q;
p->bf = q->bf = 0;
q = p;
return q;
}
AVLnode<Type > * RotateLR(AVLnode<Type> *&q)
{
AVLnode<Type>* right = q;
AVLnode<Type>* left = q->leftchild;
q = left->rightchild;
left->rightchild = q->leftchild;
right->leftchild = q->rightchild;
q->leftchild = left;
q->rightchild = right;
if(right->leftchild == NULL && right->rightchild!=NULL)
{
right->bf = 1;
left->bf = 0;
}
else if(left->rightchild==NULL && left->leftchild!=NULL)
{
left->bf = -1;
right->bf = 0;
}
else
left->bf = right->bf = 0;
q->bf = 0;
return q;
}
AVLnode<Type > * RotateL(AVLnode<Type> *&q)
{
AVLnode<Type> *p = q->rightchild;
q->rightchild = p->leftchild;
p->leftchild = q;
p->bf = q->bf = 0;
q = p;
return q;
}
AVLnode<Type > * RotateRL(AVLnode<Type> *&q)
{
AVLnode<Type>* left = q;
AVLnode<Type>* right= q->rightchild;
q = right->leftchild;
left->rightchild = q->leftchild;
right->leftchild = q->rightchild;
q->leftchild = left;
q->rightchild = right;
if(right->leftchild == NULL && right->rightchild!=NULL)
{
right->bf = 1;
left->bf = 0;
}
else if(left->rightchild==NULL && left->leftchild!=NULL)
{
left->bf = -1;
right->bf = 0;
}
else
left->bf = right->bf = 0;
q->bf = 0;
return q;
}
private:
AVLnode<Type>* root;
};
//**主函数部分：**
#include<iostream>
#include"AVL.h"
using namespace std;
int main()
{
int ar[] = {16,3,7,11,9,26,18,14,15};
int n = sizeof(ar)/sizeof(int);
AVLTree<int> bt;
for(int i=0; i<n; ++i)
{
bt.Insert(ar[i]);//插入
}
return 0;
}AVL树的删除节点比增加节点稍微复杂一些，请仔细分析代码，自己亲手编写代码来加深知识掌握。
2989
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
