模仿STL，实现二叉搜索数，带迭代器 BinSearchTree (iterator)

2019年11月3日 234次阅读

自己看着书，实现的，废话不多说，上代码

转载请注明出处http://blog.csdn.net/u010632868

#include <iostream>
#include <assert.h>
#include <time.h>
#include <stdlib.h>
using namespace std;

template <class Type>
class BinSearchTreee;

//下面是对于树节点的声明和定义
template <class Type>
class Tree_Node
{
private:
bool IsHeader; //判断是否是根节点，一棵树只有一个根节点
Type Date; //显然这是数据部分，当然根节点的数据部分，未作要求
Tree_Node* Parent; //没一个节点都一个父节点。这里的数据结构的一大特点是，根节点的父亲节点是头节点，而头节点的父亲节点是根节点
Tree_Node* Left; //左儿子，对于根节点来说，Left指向元素最小的那个节点
Tree_Node* Right; //右儿子，对于根节点来说，Right指向元素最大的那个节点
public:
Tree_Node(bool isheader = false,Type date = *(new Type),Tree_Node* parent = NULL,
Tree_Node *left = NULL,Tree_Node* right = NULL) :
IsHeader(isheader),Date(date),Parent(parent),
Left(left),Right(right) {}

Tree_Node(const Tree_Node &tmp) : IsHeader(tmp.IsHeader),Date(tmp.Date),
Parent(tmp.Parent),Left(tmp.Left),Right(tmp.Right) {}

template <class T>
friend class BinSearchTree; //把数结构定义为友元类
~Tree_Node()
{
cout<<“Destroy Node”<<endl;
}

};

template <class Type>
class BinSearchTree
{
private:
typedef Tree_Node<Type> Node; //把类型的别名写在里面。我在想如果写在外面，感觉根本没法写啊。
typedef Tree_Node<Type>* Link;//有人知道怎么给template 的量typedef吗，知道的请告诉我，我们一起交流交流

public:
class Iterator //在BinSearchTree类中嵌套定义类Iterator，主要是为更好的模仿STL的风格
{
Link link; //里面就一个Link类型，作用就不用我多说了
public:
Iterator(Link p = NULL) : link(p) {} //类的定义和初始化
Iterator(const Iterator &p);
Iterator& operator=(const Iterator &itr);
bool operator==(const Iterator &itr);
bool operator!=(const Iterator &itr);
Type& operator*();
Iterator& operator++();
Iterator& operator–(); //后置的我省略了，反正都一样
friend class BinSearchTree;
};

private:
Link Header; //指向根节点的指针，看名字很显然
size_t Size; //记录容器内有多少元素
private:
Iterator Find(const Type &item); //查询
void Prune(Link &link); //当link指向的节点至少有一个空节点时，调用介个家伙。
void DeleteLink(Link &link); //删除link指向的节点
void Destroy(Link &link); //自顶向下数据呈现扩张的状态，所以这里选择用自顶向下的递归调用销毁树节点
public:
BinSearchTree();
Iterator Insert(const Type &item); //插入Date为item的新元素
void Erase(Iterator itr); //按位置删除元素
size_t Length() {return Size;} //返回容器大小
Iterator Begin(){return Iterator(Header->Left);} //指向第一个元素
Iterator End(){return Iterator(Header);} //将根节点作为end();
~BinSearchTree(); //析构函数
};

template <class Type>
BinSearchTree<Type>::Iterator::Iterator(const Iterator &itr)
{
link = itr.link;
}

template <class Type>
class BinSearchTree<Type>::Iterator& BinSearchTree<Type>::Iterator::operator=(const Iterator &itr)
{
link = itr.link;
return *this;
}

template <class Type>
bool BinSearchTree<Type>::Iterator::operator==(const Iterator &itr)
{
return link == itr.link;
}

template <class Type>
bool BinSearchTree<Type>::Iterator::operator!=(const Iterator &itr)
{
return link != itr.link;
}

template <class Type>
Type& BinSearchTree<Type>::Iterator::operator*()
{
return link->Date;
}

template <class Type>
class BinSearchTree<Type>::Iterator& BinSearchTree<Type>::Iterator::operator++()
{
//第一先判断是否有右子数，不行就从父亲节点开始找。
if(link->Right != NULL)
{
Link child = link->Right;
while(child->Left != NULL)
{
child = child->Left;
}
link = child;
}
else //找父亲节点的关键是，当前节点为左节点
{
if(link->Parent->Left == link)
{
link = link->Parent;
}
else
{
Link parent = link->Parent;
if(parent->Parent->Parent == parent) //一个很蛋疼的特例，当当前节点刚刚好是头节点的时候，必须额外判断。
{
link = parent;
}
else
{

while(parent->Parent->Right == parent)
{
parent = parent->Parent;
}
link = parent->Parent;
}
}
}
return *this;
};

//–的思路同++，唯一的不同在最后面
template <class Type>
class BinSearchTree<Type>::Iterator& BinSearchTree<Type>::Iterator::operator–()
{
if(link->Left != NULL)
{
Link child = link->Left;
while(child->Right != NULL)
{
child = child->Right;
}
link = child;
}
else
{
if(link->Parent->Right == link)
{
link = link->Parent;
}
else
{
Link parent = link->Parent;
if(parent->Parent->Parent == parent)
{
link = parent;
}
else
{
while(parent->Parent->Left == parent)
{
parent = parent->Parent;
}
link = parent->Parent;
}
}
}

//为了实现逆序迭代器的功能原型，让–begin的结果为Right;
//不过这里我并没有做相关的函数，这里只是为了以后的补充做一个方便。
if(link->IsHeader)
{
link = link->Right;
}

return *this;
};

template <class Type>
BinSearchTree<Type>::BinSearchTree()
{
Header = new Node;
Header->IsHeader = true; //只有根节点的是true,其他的都是false;
Header->Parent = NULL;
Header->Left = Header;
Header->Right = Header;
Size = 0;
}

template <class Type>
void BinSearchTree<Type>::Destroy(Link &link)
{
if(link == NULL)
{
return ;
}
else
{
Destroy(link->Right);
Destroy(link->Left);
delete link;
}
}

template <class Type>
class BinSearchTree<Type>::Iterator BinSearchTree<Type>::Find(const Type &item)
{
Link parent = Header;
Link child = parent->Parent;
//之所以不用==符号，是为了加速。之所以为什么会更快，分析如下
//在同为能找到的时候，该操作的时间期望都是log(n),当如果没有找到
//那么用==判断的话，因为要先判断是否相等，如果不想等，判断在哪边，
//这样的话，如果没有找到，该操作的期望时间就变为2*log(n);但是
//一下这种方法，依旧是log(n);
while(child != NULL)
{
if(!(child->Date > item))
{
child = child->Left;
}
else
{
parent = child;
child = child->Right;
}
}

if(parent == Header || parent->Date > item)
{
return End();
}
else
{
return parent;
}
}

template <class Type>
class BinSearchTree<Type>::Iterator BinSearchTree<Type>::Insert(const Type &item)
{
++Size;
Link parent = Header;
Link child = Header->Parent;
if(child == NULL) //当树为空的时候。
{
Link tmp = new Node(false,item,Header,NULL,NULL);
Header->Parent = tmp;
Header->Left = tmp;
Header->Right = tmp;
return tmp;
}
else
{
while(child)
{
parent = child;
if(!(item > child->Date))
{
child = child->Left;
}
else
{
child = child->Right;
}
}

if(!(item > parent->Date))
{
parent->Left = new Node(false,item,parent,NULL,NULL);
if(Header->Left == parent) { Header->Left = parent->Left;}
return parent->Left;
}
else
{
parent->Right = new Node(false,item,parent,NULL,NULL);
if(Header->Right == parent) { Header->Right = parent->Right;}
return parent->Right;
}
}
}

template <class Type>
void BinSearchTree<Type>::Erase(Iterator itr)
{
//删除操作，分三种情况，一种是，所要删除的节点是头节点。
//除此之外，所要删除的节点没有子节点和有字节点的情况
assert(!(itr.link->IsHeader));
if(itr.link->Parent->Parent == itr.link)
{
DeleteLink(itr.link->Parent->Parent);
}
else if(itr.link->Parent->Right == itr.link)
{
DeleteLink(itr.link->Parent->Right);
}
else
{
DeleteLink(itr.link->Parent->Left);
}
}

template <class Type>
void BinSearchTree<Type>::DeleteLink(Link &link)
{//注意这里是引用，这是为什么函数Erase中，要从父亲节点那里调用指向自身节点的原因。为了直接修改父亲节点的指针
if(link->Right != NULL && link->Left != NULL)
{
Link child = link->Left;
while(child->Right != NULL)
{
child = child->Right;
}

link->Date = child->Date;
if(child == link->Left)
{
Prune(link->Left);
}
else
{
Prune(child->Parent->Right);
}

}
else
{
Prune(link);
}
}

template <class Type>
void BinSearchTree<Type>::Prune(Link &link)//这货专门用来删除至少一个子节点为空的情况
{
–Size;
Link tmp = link;
if(link->Right == NULL && link->Left == NULL)//两个都为空直接删除就好了
{
link = NULL;
delete tmp;
}
else if(link->Right != NULL)
{
link->Right->Parent = link->Parent;//因为是引用所以这里直接修改了父亲指针
link = link->Right;
if(Header->Left == tmp) //因为删除的是左边的节点，左边的节点可能是Left，所以需要做必要的判断和更新。
{
Link left = link;
while(left->Left != NULL) { left = left->Left; }
Header->Left = left;
}
delete tmp;
}
else
{
link->Left->Parent = link->Parent;
link = link->Left;
if(Header->Right == tmp) //同样因为是右边的节点，所以可以是原来的Right，所以做判断更新
{
Link right = link;
while(right->Right != NULL) { right = right->Right; }
Header->Right = right;
}
delete tmp;
}
}

template <class Type>
BinSearchTree<Type>::~BinSearchTree()
{
Destroy(Header->Parent);//递归的方式释放空间。
delete Header;
}

int main()
{
BinSearchTree<int> Coll;
int i,k;
for(i = 0;i < 10;++i)
{
k = rand()%100;
Coll.Insert(k);
}
class BinSearchTree<int>::Iterator pos;
for(pos = Coll.Begin();pos != Coll.End();++pos)
{
cout<<*pos<<‘ ‘;
}
cout<<“Size is : “<<Coll.Length()<<endl;
pos = Coll.Insert(5);
cout<<*pos<<endl;
for(pos = Coll.Begin();pos != Coll.End();++pos)
{
cout<<*pos<<‘ ‘;
}
cout<<“Size is : “<<Coll.Length()<<endl;
pos = Coll.Begin();
++pos;
++pos;
Coll.Erase(pos);
for(pos = Coll.Begin();pos != Coll.End();++pos)
{
cout<<*pos<<‘ ‘;
}
cout<<“Size is : “<<Coll.Length()<<endl;
return 0;
}