数据结构--------------AVLTree

一、AVLTree的概念

在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log
n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。

二、AVLTree的性质

1. 左子树和右子树的高度之差的绝对值不超过1

2. 树中的每个左子树和右子树都是AVL树

3. 每个节点都有一个平衡因子(balance factor--bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )

三、AVLTree的插入







四、实现如下：

#pragma once
#include<iostream>
#include<math.h>
using namespace std;
template<class K,class V>
struct AVLTreeNode
{
AVLTreeNode(K key,V value)
:_left(NULL)
,_right(NULL)
,_parent(NULL)
,_key(key)
,_value(value)
,bf(0)
{

}
AVLTreeNode* _left;
AVLTreeNode* _right;
AVLTreeNode* _parent;
K _key;
V _value;
int bf;  //平衡因子
};
template<class K,class V>
class AVLTree
{
typedef AVLTreeNode<K,V> Node;
public:
AVLTree()
:_root(NULL)
{
}
bool Insert(K key,V value)
{
if(_root==NULL)
{
_root=new Node(key,value);
return true;
}
Node* cur=_root;
Node* parent=NULL;
while(cur)
{
parent=cur;
if(cur->_key>key)
{
cur=cur->_left;
}
else if(cur->_key<key)
{
cur=cur->_right;
}
else
{
return false;
}
}
cur=new Node(key,value);
if(parent->_key>key)
{
parent->_left=cur;
cur->_parent=parent;
}
else if(parent->_key<key)
{
parent->_right=cur;
cur->_parent=parent;
}
//更新平衡因子
//不平衡旋转
while(parent)
{
if(cur==parent->_right)
{
parent->bf++;
}
else
{
parent->bf--;
}
if(parent->bf==0)
{
break;
}
else if(parent->bf==1||parent->bf==-1)
{
cur=parent;
parent=cur->_parent;
}
else// bf==2 、-2
{
//旋转
if(parent->bf==-2)
{
if(cur->bf==-1)
{
RotateR(parent);
}
else
{
RotateLR(parent);
}
break;
}
else
{
if(cur->bf==1)
{
RotateL(parent);
}
else
{
RotateRL(parent);
}
break;
}
}

}
return true;
}
bool Find(K key)
{

}
bool Remove()
{}
void InOrder()
{
_InOrder(_root);
}
bool IsBalance()
{
return _IsBalance(_root);
}
private:
bool Height(Node* root)
{
if(root==NULL)
{
return 0;
}
int left_height=Height(root->_left);
int right_height=Height(root->_right);
return left_height ? right_height+1 : left_height+1;
}
bool _IsBalance(Node* root)
{
if(root==NULL)
{
return true;
}
int left=Height(root->_left);
int right=Height(root->_right);
return abs(left-right)<2 && _IsBalance(root->_left)&&_IsBalance(root->_right);
}
void _InOrder(Node* root)
{
if(root==NULL)
{
return;
}
_InOrder(root->_left);
cout<<root->_key<<endl;
_InOrder(root->_right);
}
void RotateR(Node* parent)
{
Node* subL=parent->_left;
Node* subLR=subL->_right;
Node* ppNode=parent->_parent;
subL->_right=parent;
parent->_parent=subL;
if(subLR)
{
subLR->_parent=parent;
}
parent->_left=subLR;
if(ppNode&&ppNode->_left==parent)
{
ppNode->_left=subL;

}
else if(ppNode&&ppNode->_right==parent)
{
ppNode->_right=subL;
}
subL->_parent=ppNode;
subL->bf=parent->bf=0;
if(ppNode==NULL)
{
_root=subL;
}
}
void RotateL(Node* parent)
{
Node* subR=parent->_right;
Node* subRL=subR->_left;
Node* ppNode=parent->_parent;
subR->_left=parent;
parent->_parent=subR;
if(subRL)
{
subRL->_parent=parent;
}
parent->_right=subRL;
if(ppNode&&ppNode->_left==parent)
{
ppNode->_left=subR;

}
else if(ppNode&&ppNode->_right==parent)
{
ppNode->_right=subR;
}
subR->_parent=ppNode;
subR->bf=parent->bf=0;
if(ppNode==NULL)
{
_root=subR;
}
}
void RotateLR(Node* parent)
{
Node* subL=parent->_left;
Node* subLR=subL->_right;
int bf=subLR->bf;
RotateL(parent->_left);
RotateR(parent);
if(bf==-1)
{
parent->bf=1;
subL->bf=0;
}
else if(bf==1)
{
parent->bf=0;
subL->bf=-1;
}
else
{
parent->bf=subL->bf=0;
}
subLR->bf=0;
}
void RotateRL(Node* parent)
{
Node* subR=parent->_right;
Node* subRL=subR->_left;
int bf=subRL->bf;
RotateR(parent->_right);
RotateL(parent);
if(bf==-1)
{
parent->bf=0;
subR->bf=1;
}
else if(bf==1)
{
parent->bf=-1;
subR->bf=0;
}
else
{
parent->bf=subR->bf=0;
}
subRL->bf=0;

}
private:
Node* _root;
};

#include "AVLTree.h"
int main()
{
//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,int> t;
for(int i=0;i<sizeof(a)/sizeof(a[0]);i++)
{
t.Insert(a[i],i);
}
t.InOrder();
cout<<t.IsBalance()<<endl;
system("pause");
return 0;
}

五、结果：