introduction to algorithms 菜鸟笔记 binfindtree

//author:yydrewdrew
#include <iostream>
using namespace std;
template <class T>
struct BinTreeNode
{
T data;
BinTreeNode<T> *left;
BinTreeNode<T> *right;
BinTreeNode<T> *parent;
};

template <class T>
class BinFindTree
{
public:
BinFindTree<T>():root(NULL){}
BinFindTree<T>(BinTreeNode<T> *p):root(p){}
BinFindTree<T> &operator = (const BinFindTree<T> &obj);
BinFindTree<T>(const BinFindTree<T> &obj);
virtual ~BinFindTree();
public:
void TreeWalk();
BinTreeNode<T> *Search(const T &t);
BinTreeNode<T> *Min()const;
BinTreeNode<T> *Max()const;
BinTreeNode<T> *Predecessor(const T &t);
BinTreeNode<T> *Successor(const T &t);
BinTreeNode<T> *Insert(const T &t);
BinTreeNode<T> *Delete(const T &t);
Swap(BinFindTree<T> &obj);
private:
void Scan(BinTreeNode<T> *root);
BinTreeNode<T> *root;
void Copy(const BinTreeNode<T> *p);
void Destory(BinTreeNode<T> *p);
};
template<class T>
void BinFindTree<T>::Destory(BinTreeNode<T> *p)
{
if (p != NULL)
{
Destory(p->left);
Destory(p->right);
delete p;
p = NULL;
}
return;
}

template<class T>
BinFindTree::~BinFindTree()
{
Destory(root);
}

template<class T>
void BinFindTree<T>::Copy(const BinTreeNode<T> *p)
{
if (p != NULL)
{
Copy(p->left);
Insert(p->data);
Copy(p->right);
}
return;
}

template<class T>
BinFindTree<T>::BinFindTree(const BinFindTree<T> &obj)
{
root = NULL;
Copy(obj.root);
}

template<class T>
void BinFindTree<T>::Swap(BinFindTree<T> &obj)
{
std::swap(root,obj.root);
}

template<class T>
BinFindTree<T> &BinFindTree<T>::operator = (const BinFindTree<T> &obj)
{
if (this != &obj)
{
Swap(BinFindTree(obj));
}
return *this;
}

template <class T>
BinTreeNode<T> *BinFindTree<T>::Min()const
{
if (root == NULL)
{
return NULL;
}
BinTreeNode<T> * p = root;
while (p->left != NULL)
{
p = p->left;
}
return p;
}
template <class T>
BinTreeNode<T> *BinFindTree<T>::Max()const
{
if (root == NULL)
{
return NULL;
}
BinTreeNode <T> *p = root;
while (p->right != NULL)
{
p = p->right;
}
return p;
}
template <class T>
BinTreeNode<T> *BinFindTree<T>::Search(const T &t)
{
if (root == NULL)
{
return NULL;
}
BinTreeNode<T> *p = root;
while (p->data != t)
{
if (p->data > t)
{
p = p->left;
}
else
{
p = p->right;
}
if (p == NULL)
{
break;
}
}
return p;
}
template <class T>
BinTreeNode<T> *BinFindTree<T>::Successor(const T &t)
{
BinTreeNode<T> *p = Search(t);
if (p != NULL)
{
if (p->right != NULL)
{
BinFindTree tem(p->right);
return tem.Min();
}
BinTreeNode<T> *p2 = p->parent;
while (p2 != NULL && p == p2->right)
{
p = p2;
p2 = p->parent;
}
return p2;
}
return p;
}
template <class T>
BinTreeNode<T> *BinFindTree<T>::Predecessor(const T &t)
{
BinTreeNode<T> *p = Search(t);
if (p != NULL)
{
if (p->left != NULL)
{
BinFindTree<T> tem(p->left);
return tem.Max();
}
BinTreeNode<T> *p2 = p->parent;
while (p2 != NULL && p == p2->left)
{
p = p2;
p2 = p->parent;
}
return p2;
}
return p;
}
template<class T>
BinTreeNode<T> *BinFindTree<T>::Insert(const T &t)
{
BinTreeNode<T> *p = new BinTreeNode<T>;
p->data = t;
p->left = NULL;
p->right = NULL;
BinTreeNode<T> *p2 = root;
BinTreeNode<T> *p3 = NULL;
while (p2 != NULL)
{
p3 = p2;
if (p2->data > t)
{
p2 = p2->left;
}
else
{
p2 = p2->right;
}
}
p->parent = p3;
if (p3 == NULL)
{
root = p;
return p;
}
if (p3->data > t)
{
p3->left = p;
}
else
{
p3->right = p;
}
return p;
}
template <class T>
BinTreeNode<T> *BinFindTree<T>::Delete(const T &t)
{
if (root == NULL)
{
return NULL;
}
BinTreeNode<T> *p = Search(t);
if (p != NULL)
{
if (p->left == NULL && p->right == NULL)
{
if (p == p->parent->left)
{
p->parent->left = NULL;
}
else
{
p->parent->right = NULL;
}
return p;
}
else if (p->left != NULL && p->right == NULL)
{
if (p == p->parent->left)
{
p->parent->left = p->left;
}
else
{
p->parent->right = p->left;
}
return p;
}
else if (p->left == NULL && p->right != NULL)
{
if (p == p->parent->left)
{
p->parent->left = p->right;
}
else
{
p->parent->right = p->right;
}
return p;
}
else
{
BinTreeNode<T> *psuccess = Successor(t);
if (psuccess->parent->left == psuccess)
{
psuccess->parent->left = psuccess->right;
psuccess->right->parent = psuccess->parent;
}
else
{
psuccess->parent->right = psuccess->right;
psuccess->right->parent = psuccess->parent;
}
swap(psuccess->data,p->data);
return psuccess;
}
}
return p;
}
template <class T>
void BinFindTree<T>::Scan(BinTreeNode<T> *root)
{
if (root == NULL)
{
return;
}
Scan(root->left);
cout<<root->data<<endl;
Scan(root->right);
return;
}

template <class T>
void BinFindTree<T>::TreeWalk()
{
Scan(root);
}