二叉排序树（模板类）

根据《算法导论》实现的二叉排序树

#include <iostream>

template<typename KeyType>
   class TreeNode
   {	   
	   typedef KeyType _KeyType;
	   typedef TreeNode* _NodePtr;
	   typedef TreeNode& _NodeRef;
	
   public:
	   TreeNode()
	   {
		   _left = NULL;
		   _right = NULL;
		   _parent = NULL;
	   }
	   TreeNode(_KeyType key)
	   {
		   _key = key;
		   _left = NULL;
		   _right = NULL;
		   _parent = NULL;
	   }
   
   public:
	   const _KeyType Key() const
	   {
		   return _key;
	   }

	   void SetKey(const _KeyType & key)
	   {
		   _key = key;
	   }

	   const _NodePtr LeftChild() const
	   {
		   return _left;
	   }

	   void SetLeftChild(_NodePtr leftChild)
	   {
		   _left = leftChild;
	   }

	   const _NodePtr RightChild() const
	   {
		   return _right;
	   }

	   void SetRightChild(_NodePtr rightChild)
	   {
		   _right = rightChild;
	   }

	   const _NodePtr Parent() const
	   {
		   return _parent;
	   }

	   void SetParent(_NodePtr parent)
	   {
		   _parent = parent;
	   }

   private:
	   TreeNode & operator=(const TreeNode & node);

   private:	  
		_KeyType _key;
		_NodePtr _left;
		_NodePtr _right;
		_NodePtr _parent;       
   };

template<typename KeyType>
	class BiSortTree
	{
	public:
		typedef KeyType _KeyType;
		typedef TreeNode<KeyType> _Node;
		typedef _Node* _NodePtr;
		typedef _Node& _NodeRef;

		enum OutPutType
		{
			PreOrder,
			InOrder,
			PostOrder
		};

	public:
		BiSortTree(void)
		{
			_head = NULL;
		}
		~BiSortTree(void){}

	public:
		bool IsEmpty() const
		{
			return _head == NULL;
		}

		void CreateTree(_KeyType Headkey)
		{
			_head = new _Node(Headkey);
		}

		void InsertNode(_NodePtr parent, _KeyType key)
		{
			if (!parent) return;

			if (!parent->LeftChild() && key <= parent->Key())
			{
				_NodePtr newNode = new _Node(key);
				parent->SetLeftChild(newNode);
				newNode->SetParent(parent);
			}
			else if (!parent->RightChild() && key > parent->Key())
			{
				_NodePtr newNode = new _Node(key);
				parent->SetRightChild(newNode);
				newNode->SetParent(parent);
			}
			else 
			{
				if (parent->LeftChild() && key <= parent->Key()) InsertNode(parent->LeftChild(), key);
				else if (parent->RightChild() && key > parent->Key()) InsertNode(parent->RightChild(), key);
			}				
		}

		void InsertNode(_KeyType key)
		{
			if (!_head) return;
			InsertNode(_head, key);
		}

		_NodePtr Search(_KeyType key)
		{
			return Search(_head, key);
		}
	
		void Delete(_KeyType key)
		{
			_NodePtr target = Search(_head, key);

			if (!target) return;//未找到节点		
			if (!target->LeftChild() && !target->RightChild()) //叶节点
			{
				Transplant(target, NULL);			
			}
			else if (!target->LeftChild() || !target->RightChild()) //只有一个孩子节点
			{
				Transplant(target, target->LeftChild() != NULL? target->LeftChild():target->RightChild());						
			}
			else //两个孩子节点
			{
				_NodePtr PostNode = Minimum(target->RightChild());

				if (PostNode->Parent() == target) //后继节点是被删除节点的孩子
				{					
					Transplant(target, PostNode);				
					PostNode->SetLeftChild(target->LeftChild());
					target->LeftChild()->SetParent(PostNode);				
				}
				else//后继节点不是被删除节点的孩子
				{			
					Transplant(PostNode, PostNode->RightChild());
					Transplant(target, PostNode);
					PostNode->SetLeftChild(target->LeftChild());
					target->LeftChild()->SetParent(PostNode);
					PostNode->SetRightChild(target->RightChild());
					target->RightChild()->SetParent(PostNode);				
				}			
			}
			delete target;
		}
		
		void PreOrderOutput()
		{
			OutPut(_head, PreOrder);
			std::cout << std::endl;
		}

		void InOrderOutput()
		{
			OutPut(_head, InOrder);
			std::cout << std::endl;
		}

		void PostOrderOutput()
		{
			OutPut(_head, PostOrder);
			std::cout << std::endl;
		}	

	protected:

		void OutPut(_NodePtr node, OutPutType order)
		{
			if (!node) return;	
			if (order == PreOrder)std::cout << node->Key() << " ";
			OutPut(node->LeftChild(), order);
			if (order == InOrder)std::cout << node->Key() << " ";	
			OutPut(node->RightChild(), order);
			if (order == PostOrder)std::cout << node->Key() << " ";		
		}

		_NodePtr Search(_NodePtr parent, _KeyType key)
		{
			if (!parent) return NULL;
			if(parent->Key() == key) return parent;
			else if(key <= parent->Key())
			{
				return Search(parent->LeftChild(), key);
			}
			else if(key >= parent->Key())
			{
				return Search(parent->RightChild(), key);
			}		
			return NULL;
		}	

		void Transplant(_NodePtr node, _NodePtr postNode)
		{
			if (!node) return;
			_NodePtr parent = node->Parent();
			if (parent)
			{
				if (parent->LeftChild() == node) parent->SetLeftChild(postNode);
				else parent->SetRightChild(postNode);
				if (postNode) postNode->SetParent(parent);			
			}
		}

		_NodePtr Minimum(_NodePtr root)
		{
			if (root)
			{
				if (!root->LeftChild()) //左孩子为空
				{
					return root;
				}
				return Minimum(root->LeftChild());
			}
			return NULL;
		}

	private:
		_NodePtr _head;
	};