在二叉搜索树来查询数据的结构里面,树形结构并不是一个平衡的二叉树。在有些情况下效率明显不是很高(例如,左单支或者右单支)。
在AVL树里面,每个子树的高度相差不大于1,即最高的子树和最低的子树之间相差最高为1。
例如:这里规定是右子树的高度-左子树的高度作为平衡因子。
当在整个树里面的结点的平衡因子含有绝对值大于1的时候就需要对树进行调整。
情况1:
情况2:
情况3:
情况4:
当每次进行插入和删除的同时,需要对结点的平衡因子进行相应的调整。
实现代码:
(只实现结点的插入和调整)
#ifndef _AVLTREE_H
#define _AVLTREE_H
#include<iostream>
using namespace std;
template<class T ,class V>
struct AVLTreeNode
{
AVLTreeNode(T d)
:left(NULL)
,right(NULL)
,_parent(NULL)
,fd(0)
,value(d)
{}
AVLTreeNode<T,V>* left;
AVLTreeNode<T,V>* right;
AVLTreeNode<T,V>* _parent;
int fd;
int value;
};
template<class T,class V>
class AVLTree
{
public:
typedef struct AVLTreeNode<T,V> Node;
AVLTree(T* arr,size_t size)
{
_root = NULL;
if(NULL == arr)
return ;
for(int i=0;i<size;i++)
Insert(arr[i]);
}
void Insert(T d)
{
_Insert(_root,d);
}
void Inorder()
{
_Inorder(_root);
cout<<endl;
}
Node* Find(T d)
{
return _Find(_root ,d);
}
private:
Node* _Find(Node* root,T d)
{
while(root)
{
if(d < root->value)
root = root->left;
else if(d > root->value)
root = root->right;
else
return root;
}
}
void _Inorder(Node* root)
{
if(root)
{
_Inorder(root->left);
cout<<root->value<<" ";
_Inorder(root->right);
}
}
void _rotate_R(Node* parent)//情况1
{
Node* pparent = parent->_parent; //记录当前节点的前一个结点
Node*subL = parent->left;
Node* subLR = subL->right;
if(subLR)
subLR->_parent = parent;
subL->right = parent;
parent->_parent = subL;
parent->left = subLR;
if(pparent == NULL)
_root = subL;
else if(pparent->left == parent)
pparent->left = subL;
else
pparent->right = subL;
subL->_parent = pparent;
subL->fd = parent->fd = 0;
}
void _rotate_L(Node* parent)//情况2
{
Node* subR = parent->right;
Node* subRL = subR->left;
Node* pparent = parent->_parent;
if(subRL)
subRL->_parent = parent;
subR->left = parent;
parent->_parent = subR;
parent->right = subRL;
if(pparent == NULL)
_root = subR;
else if(pparent->left == parent)
pparent->left = subR;
else
pparent->right = subR;
subR->_parent = pparent;
subR->fd = parent->fd = 0;
}
void _rotate_RL(Node* parent) //情况3
{
_rotate_R(parent);
_rotate_L(parent);
}
void _rotate_LR(Node* parent) //情况4
{
_rotate_L(parent);
_rotate_R(parent);
}
void _Insert(Node* root,T d)
{
Node* tmp = new Node(d);
Node* parent = NULL;
if(NULL == root)
{
_root = tmp;
return ;
}
while(root)
{
parent = root;
if(root && d < root->value )
root = root->left;
else
root = root->right;
}
if(d < parent->value)
{
parent->left = tmp;
tmp->_parent = parent;
}
else
{
parent->right = tmp;
tmp->_parent = parent;
}
while(tmp)
{
if(NULL == parent)
return;
if(tmp == parent->left)
parent->fd--;
else
parent->fd++;
if(parent->fd == 0)
break;
else if(parent->fd == 1 || parent->fd == -1)
{
tmp = parent;
parent = tmp->_parent;
}
else
{
if(parent->fd == 2 )
{
if(tmp->fd = 1)
{
_rotate_L(parent);
}
else
_rotate_RL(parent);
}
else
{
if(tmp->fd == 1)
_rotate_LR(parent);
else
_rotate_R(parent);
}
}
}
}
Node* _root;
};
#endif