平衡二叉树(AVL树)的简单实现

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->
#include<stdlib.h>

template<typenameT>
classCAVLTree;

template<typenameT>
classCAVLTreeNode
{
public:
CAVLTreeNode(constT&item,CAVLTreeNode<T>*lptr=NULL,CAVLTreeNode<T>*rptr=NULL,intbalfac=0):data(item),left(lptr),right(rptr),balanceFactor(balfac)
{
}
CAVLTreeNode<T>*Left(void)const
{
returnleft;
}
CAVLTreeNode<T>*Right(void)const
{
returnright;
}
intGetBalanceFactor()const
{
returnthis->balanceFactor;
}
friendclassCAVLTree<T>;
public:
Tdata;//数据
private:
CAVLTreeNode<T>*left;//左子树
CAVLTreeNode<T>*right;//右子树
intbalanceFactor;//平衡因子
CAVLTreeNode<T>*&Left(void)
{
returnleft;
}
CAVLTreeNode<T>*&Right(void)
{
returnright;
}

};

constintLEFTHEAVY=-1;
constintBALANCE=0;
constintRIGHTHEAVY=1;

template<typenameT>
classCAVLTree
{
public:
CAVLTree(void);
CAVLTree(constCAVLTree<T>&tree);
CAVLTree&operator=(constCAVLTree&rhs);
voidInsert(constT&item);
voidClearTree();//清空树
boolContains(constT&item);//是否包含数据
CAVLTreeNode<T>*FindNode(constT&item,CAVLTreeNode<T>*&parent)const;//寻找节点
CAVLTreeNode<T>*FindMin()const;//找最小值
CAVLTreeNode<T>*FindMax()const;//找最大值
voidPrintTree();//前序遍历树(非递归)
virtual~CAVLTree(void);

protected:
CAVLTreeNode<T>*GetAVLTreeNode(constT&item,CAVLTreeNode<T>*lptr=NULL,CAVLTreeNode<T>*rptr=NULL);
CAVLTreeNode<T>*CopyTree(CAVLTreeNode<T>*t);//拷贝树
voidFreeTreeNode(CAVLTreeNode<T>*p);//释放树节点
voidDeleteTree(CAVLTreeNode<T>*t);//删除树

//旋转
voidSingleRotateLeft(CAVLTreeNode<T>*&p);
voidSingleRotateRight(CAVLTreeNode<T>*&p);
voidDoubleRotateLeft(CAVLTreeNode<T>*&p);
voidDoubleRotateRight(CAVLTreeNode<T>*&p);

voidUpdateLeftTree(CAVLTreeNode<T>*&tree,int&reviseBalanceFactor);
voidUpdateRightTree(CAVLTreeNode<T>*&tree,int&reviseBalanceFactor);
voidAVLInsert(CAVLTreeNode<T>*&tree,CAVLTreeNode<T>*newnode,int&reviseBalanceFactor);

private:
CAVLTreeNode<T>*root;//平衡二叉树树根
intsize;//树节点个数
};

平衡二叉树实现代码
<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->#include"BinSTree.h"
#include<iostream>
#include<stack>
usingnamespacestd;

/**//**//**///////////////////////////////////////////////////////////////////////
//Construction/Destruction
/**//**//**///////////////////////////////////////////////////////////////////////
template<typenameT>
CAVLTree<T>::CAVLTree()
{
this->root=NULL;
this->size=0;
}
template<typenameT>
CAVLTree<T>::CAVLTree(constCAVLTree<T>&tree)
{
root=this->CopyTree(tree.root);
this->size=tree.size;
}
template<typenameT>
CAVLTree<T>::~CAVLTree()
{
this->ClearTree();
}
template<typenameT>
CAVLTree<T>&CAVLTree<T>::operator=(constCAVLTree<T>&rhs)
{
if(this==&rhs)
return*this;
this->ClearTree();
root=this->CopyTree(rhs.root);
size=rhs.size;
return*this;
}
template<typenameT>
CAVLTreeNode<T>*CAVLTree<T>::GetAVLTreeNode(constT&item,CAVLTreeNode<T>*lptr,CAVLTreeNode<T>*rptr)
{
CAVLTreeNode<T>*p;
p=newCAVLTreeNode<T>(item,lptr,rptr);
if(p==NULL)
{
cerr<<"分配内存失败!"<<endl;
exit(1);
}
returnp;
}
template<typenameT>
CAVLTreeNode<T>*CAVLTree<T>::FindMin()const
{
CAVLTreeNode<T>*t=root;
while(t->left!=NULL)
{
t=t->left;
}
returnt;
}
template<typenameT>
CAVLTreeNode<T>*CAVLTree<T>::FindMax()const
{
CAVLTreeNode<T>*t=root;
while(t->right!=NULL)
{
t=t->right;
}
returnt;
}
template<typenameT>
boolCAVLTree<T>::Contains(constT&item)
{
CAVLTreeNode<T>*p;
return(this->FindNode(item,p)!=NULL);
}

template<typenameT>
CAVLTreeNode<T>*CAVLTree<T>::CopyTree(CAVLTreeNode<T>*t)
{
CAVLTreeNode<T>*newnode,*newlptr,*newrptr;
if(t==NULL)
returnNULL;
if(t->Left()!=NULL)
newlptr=CopyTree(t->Left());
else
newlptr=NULL;
if(t->Right()!=NULL)
newrptr=CopyTree(t->Right());
else
newrptr=NULL;
newnode=this->GetAVLTreeNode(t->data,newlptr,newrptr);
returnnewnode;
}
template<typenameT>
voidCAVLTree<T>::FreeTreeNode(CAVLTreeNode<T>*p)
{
deletep;
p=NULL;
}
template<typenameT>
voidCAVLTree<T>::DeleteTree(CAVLTreeNode<T>*t)
{
if(t!=NULL)
{
DeleteTree(t->Left());
DeleteTree(t->Right());
FreeTreeNode(t);
}
}
template<typenameT>
voidCAVLTree<T>::ClearTree()
{
DeleteTree(root);
root=NULL;
}
template<typenameT>
CAVLTreeNode<T>*CAVLTree<T>::FindNode(constT&item,CAVLTreeNode<T>*&parent)const
{
CAVLTreeNode<T>*t=root;
parent=NULL;
while(t!=NULL)
{
if(item==t->data)
break;
else
{
parent=t;
if(item<t->data)
t=t->Left();
else
t=t->Right();
}
}
returnt;
}
template<typenameT>
voidCAVLTree<T>::Insert(constT&item)
{
CAVLTreeNode<T>*t=root,*parent=NULL,*newnode;
intreviseBalanceFactor=0;
newnode=this->GetAVLTreeNode(item);
this->AVLInsert(t,newnode,reviseBalanceFactor);
root=t;
size++;
}
template<typenameT>
voidCAVLTree<T>::AVLInsert(CAVLTreeNode<T>*&tree,CAVLTreeNode<T>*newnode,int&reviseBalanceFactor)
{

intrebalanceCurrNode;
if(tree==NULL)
{
tree=newnode;
tree->balanceFactor=BALANCE;
reviseBalanceFactor=1;
}
elseif(newnode->data<tree->data)
{
this->AVLInsert(tree->Left(),newnode,rebalanceCurrNode);
if(rebalanceCurrNode)
{
if(tree->balanceFactor==LEFTHEAVY)
{
this->UpdateLeftTree(tree,reviseBalanceFactor);
}
elseif(tree->balanceFactor==BALANCE)
{
tree->balanceFactor=LEFTHEAVY;
reviseBalanceFactor=1;
}
else
{
tree->balanceFactor=BALANCE;
reviseBalanceFactor=0;
}
}
}
else
{
this->AVLInsert(tree->Right(),newnode,rebalanceCurrNode);
if(rebalanceCurrNode)
{
if(tree->balanceFactor==LEFTHEAVY)
{
tree->balanceFactor=BALANCE;
reviseBalanceFactor=0;
}
elseif(tree->balanceFactor==BALANCE)
{
tree->balanceFactor=RIGHTHEAVY;
reviseBalanceFactor=1;
}
else
this->UpdateRightTree(tree,reviseBalanceFactor);
}
else
reviseBalanceFactor=0;
}
}

template<typenameT>
voidCAVLTree<T>::PrintTree()
{
stack<CAVLTreeNode<T>*>s;
CAVLTreeNode<T>*p=root;
while(p!=NULL||!s.empty())
{
while(p!=NULL)//遍历左子树
{
cout<<p->data<<endl;
s.push(p);
p=p->Left();
}//endwhile

if(!s.empty())
{
p=s.top();
s.pop();
p=p->Right();//通过下一次循环实现右子树遍历
}//endif
}
}
template<typenameT>
voidCAVLTree<T>::UpdateLeftTree(CAVLTreeNode<T>*&tree,int&reviseBalanceFactor)
{
CAVLTreeNode<T>*lc;
lc=tree->Left();
if(lc->balanceFactor==LEFTHEAVY)
{
this->SingleRotateRight(tree);
reviseBalanceFactor=0;
}
elseif(lc->balanceFactor==RIGHTHEAVY)
{
this->DoubleRotateRight(tree);
reviseBalanceFactor=0;
}
}
template<typenameT>
voidCAVLTree<T>::SingleRotateRight(CAVLTreeNode<T>*&p)
{
CAVLTreeNode<T>*lc;
lc=p->Left();
p->balanceFactor=BALANCE;
lc->balanceFactor=BALANCE;
p->left=lc->Right();
lc->right=p;
p=lc;
}
template<typenameT>
voidCAVLTree<T>::DoubleRotateRight(CAVLTreeNode<T>*&p)
{
CAVLTreeNode<T>*lc,*np;
lc=p->Left();
np=lc->Right();
if(np->balanceFactor==RIGHTHEAVY)
{
p->balanceFactor=BALANCE;
lc->balanceFactor=RIGHTHEAVY;
}
elseif(np->balanceFactor==BALANCE)
{
p->balanceFactor=BALANCE;
lc->balanceFactor=BALANCE;
}
else
{
p->balanceFactor=RIGHTHEAVY;
lc->balanceFactor=BALANCE;
}
np->balanceFactor=BALANCE;
lc->right=np->Left();
np->left=lc;
p->left=np->Right();
np->right=p;
p=np;
}
template<typenameT>
voidCAVLTree<T>::SingleRotateLeft(CAVLTreeNode<T>*&p)
{
CAVLTreeNode<T>*rc=p->right;

p->balanceFactor=BALANCE;
rc->balanceFactor=BALANCE;

p->right=rc->left;
rc->left=p;
p=rc;

}
template<typenameT>
voidCAVLTree<T>::DoubleRotateLeft(CAVLTreeNode<T>*&p)
{
CAVLTreeNode<T>*rc,*np;

rc=p->right;
np=rc->left;
if(np->balanceFactor==LEFTHEAVY)
{
p->balanceFactor=BALANCE;
rc->balanceFactor=LEFTHEAVY;
}
elseif(np->balanceFactor==BALANCE)
{
p->balanceFactor=BALANCE;
rc->balanceFactor=BALANCE;
}
else
{
p->balanceFactor=LEFTHEAVY;
rc->balanceFactor=BALANCE;
}
np->balanceFactor=BALANCE;
rc->left=np->right;
np->right=rc;
p->right=np->left;
np->left=p;
p=np;
}
template<typenameT>
voidCAVLTree<T>::UpdateRightTree(CAVLTreeNode<T>*&tree,int&reviseBalanceFactor)
{
CAVLTreeNode<T>*rc=tree->right;

if(rc->balanceFactor==RIGHTHEAVY)
{
SingleRotateLeft(tree);
reviseBalanceFactor=false;
}
elseif(rc->balanceFactor==LEFTHEAVY)
{
DoubleRotateLeft(tree);
reviseBalanceFactor=false;
}
}

测试代码

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->#include"BinSTree.cpp"
#include<iostream>
usingnamespacestd;

CAVLTree<int>*MakeSampleTree()
{//示例AVL树
CAVLTree<int>*tree1=newCAVLTree<int>();
inta=5;
tree1->Insert(a);
tree1->Insert(30);
tree1->Insert(65);
tree1->Insert(25);
tree1->Insert(35);
tree1->Insert(50);
tree1->Insert(10);
tree1->Insert(28);
tree1->Insert(26);
tree1->Insert(33);
returntree1;
}

intmain(intargc,char*argv[])
{
CAVLTree<int>*tree1=MakeSampleTree();
tree1->PrintTree();

cout<<tree1->Contains(40)<<endl;
CAVLTreeNode<int>*p=tree1->FindMin();
cout<<p->data<<endl;
system("pause");
return0;
}