二叉搜索树(BST树)的简单实现

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

template<typenameT>
classCTreeNode
{//树节点类
public:
CTreeNode(constT&item,CTreeNode<T>*lptr=NULL,CTreeNode<T>*rptr=NULL):data(item),left(lptr),right(rptr)
{
}
CTreeNode<T>*Left(void)
{
returnleft;
}
CTreeNode<T>*Right(void)
{
returnright;
}
friendclassCBinSTree<T>;
public:
Tdata;//数据
private:
CTreeNode<T>*left;//左子树
CTreeNode<T>*right;//右子树
};

template<typenameT>
classCBinSTree
{//二叉搜索树类
public:
CBinSTree();
virtual~CBinSTree();
CBinSTree(constCBinSTree<T>&tree);
CBinSTree<T>&operator=(constCBinSTree<T>&rhs);
CTreeNode<T>*FindNode(constT&item,CTreeNode<T>*&parent)const;//寻找节点
voidPrintTree();//前序遍历树(非递归)
voidClearTree();//清空树
voidInsert(constT&item);//插入数据
voidDelete(constT&item);//删除数据
boolContains(constT&item);//是否包含数据
CTreeNode<T>*FindMin()const;//找最小值
CTreeNode<T>*FindMax()const;//找最大值

protected:
//辅助函数区
CTreeNode<T>*GetTreeNode(constT&item,CTreeNode<T>*lptr=NULL,CTreeNode<T>*rptr=NULL);//分配树节点
voidFreeTreeNode(CTreeNode<T>*p);//释放树节点
voidDeleteTree(CTreeNode<T>*t);//删除树
CTreeNode<T>*CopyTree(CTreeNode<T>*t);//拷贝树
private:
CTreeNode<T>*root;//二叉搜索树树根
intsize;//树节点个数
};

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

/**///////////////////////////////////////////////////////////////////////
//Construction/Destruction
/**///////////////////////////////////////////////////////////////////////
template<typenameT>
CBinSTree<T>::CBinSTree()
{
this->root=NULL;
this->size=0;
}
template<typenameT>
CBinSTree<T>::CBinSTree(constCBinSTree<T>&tree)
{
root=this->CopyTree(tree.root);
this->size=tree.size;
}
template<typenameT>
CBinSTree<T>::~CBinSTree()
{
this->ClearTree();
}
template<typenameT>
CBinSTree<T>&CBinSTree<T>::operator=(constCBinSTree<T>&rhs)
{
if(this==&rhs)
return*this;
this->ClearTree();
root=this->CopyTree(rhs.root);
size=rhs.size;
return*this;
}
template<typenameT>
CTreeNode<T>*CBinSTree<T>::GetTreeNode(constT&item,CTreeNode<T>*lptr,CTreeNode<T>*rptr)
{
CTreeNode<T>*p;
p=newCTreeNode<T>(item,lptr,rptr);
if(p==NULL)
{
cerr<<"分配内存失败!"<<endl;
exit(1);
}
returnp;
}
template<typenameT>
CTreeNode<T>*CBinSTree<T>::FindMin()const
{
CTreeNode<T>*t=root;
while(t->left!=NULL)
{
t=t->left;
}
returnt;
}
template<typenameT>
CTreeNode<T>*CBinSTree<T>::FindMax()const
{
CTreeNode<T>*t=root;
while(t->right!=NULL)
{
t=t->right;
}
returnt;
}
template<typenameT>
boolCBinSTree<T>::Contains(constT&item)
{
CTreeNode<T>*p;
return(this->FindNode(item,p)!=NULL);
}
template<typenameT>
CTreeNode<T>*CBinSTree<T>::CopyTree(CTreeNode<T>*t)
{
CTreeNode<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=GetTreeNode(t->data,newlptr,newrptr);
returnnewnode;
}
template<typenameT>
voidCBinSTree<T>::FreeTreeNode(CTreeNode<T>*p)
{
deletep;
p=NULL;
}
template<typenameT>
voidCBinSTree<T>::DeleteTree(CTreeNode<T>*t)
{
if(t!=NULL)
{
DeleteTree(t->Left());
DeleteTree(t->Right());
FreeTreeNode(t);
}
}
template<typenameT>
voidCBinSTree<T>::ClearTree()
{
DeleteTree(root);
root=NULL;
}
template<typenameT>
CTreeNode<T>*CBinSTree<T>::FindNode(constT&item,CTreeNode<T>*&parent)const
{
CTreeNode<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>
voidCBinSTree<T>::Insert(constT&item)
{
CTreeNode<T>*t=root,*parent=NULL,*newnode;
while(t!=NULL)
{
parent=t;
if(item<t->data)
t=t->Left();
else
t=t->Right();
}
newnode=this->GetTreeNode(item);
if(parent==NULL)
root=newnode;
elseif(item<parent->data)
parent->left=newnode;
else
parent->right=newnode;
size++;
}
template<typenameT>
voidCBinSTree<T>::Delete(constT&item)
{
CTreeNode<T>*pDNode,*pRNode,*pParNode;
if((pDNode=this->FindNode(item,pParNode))==NULL)
return;
if(pDNode->left==NULL)
pRNode=pDNode->right;
elseif(pDNode->right==NULL)
pRNode=pDNode->left;
else
{
CTreeNode<T>*pParOfRNode=pDNode;
pRNode=pDNode->left;
while(pRNode->right!=NULL)
{
pParOfRNode=pRNode;
pRNode=pRNode->right;
}
if(pParOfRNode==pDNode)
{
pRNode->right=pDNode->right;
}
else
{
pParOfRNode->right=pRNode->left;
pRNode->left=pDNode->left;
pRNode->right=pDNode->right;
}
}
if(pParNode==NULL)
root=pRNode;
elseif(pDNode->data<pParNode->data)
pParNode->left=pRNode;
else
pParNode->right=pRNode;
this->FreeTreeNode(pDNode);
this->size--;

}
template<typenameT>
voidCBinSTree<T>::PrintTree()
{
stack<CTreeNode<T>*>s;
CTreeNode<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
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->//test.cpp:Definestheentrypointfortheconsoleapplication.
//

#include"stdafx.h"
#include"BinSTree.cpp"
#include<iostream>
usingnamespacestd;

CBinSTree<int>*MakeSampleTree()
{//示例BST树
CBinSTree<int>*tree1=newCBinSTree<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[])
{
CBinSTree<int>*tree1=MakeSampleTree();
tree1->PrintTree();
std::cout<<"删除节点30:"<<endl;
tree1->Delete(30);
tree1->PrintTree();
cout<<tree1->Contains(40)<<endl;
CTreeNode<int>*p=tree1->FindMin();
cout<<p->data<<endl;
return0;
}