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);
}