二叉搜索树和红黑树概述以及模板实现(1)

最近研究了一下算法导论里面关于二叉搜索树和红黑树的一章，对于红黑树的内容虽然还没有完全消化吸收，写一篇blog算是对所有内容的一个复习和反思吧。

1. 二叉搜索树

二叉搜索树是一颗二叉树，要求对于任何一个节点，它的左儿子内的数据要小于根节点数据，而右节点的数据要大于根节点内的数据。

例如

在搜索问题中，虽然哈希表在比较好的情况下可以提供O(1)的时间，但是对于数据分布不好，或者数据较少的时候会造成聚集或者空间浪费。但是用搜索树，在检索效率平均是lnN

下面用看《算法导论》实现的算法分析一些具体的操作，其实基本的操作和一般的二叉树一样，包括插入、删除、遍历等。只不过因为树结构的特殊，在操作后要做一些处理。

#ifndef BINARY_SEARCH_TREE_H
#define BINARY_SEARCH_TREE_H

#include <assert.h>

#include <stack>
#include <iostream>


namespace DataStructure
{

        //模板节点

	template <typename T>
	class TreeNode
	{
	public:
		T data;
		TreeNode *left,*right;
		TreeNode *parent;
		
		TreeNode()
		{
			parent = left = right = NULL;
		}
		TreeNode(T _data)
		{
			data = _data;
			parent = left = right = NULL;
		}
	};

	template<typename T>
	class BinarySearchTree
	{
	public:
		typedef TreeNode<T> NodeType;
	public:
		BinarySearchTree()
		{
			m_pRoot = NULL;
		}

		/*
		* Add a element into tree
		*/
		TreeNode<T>* insert(T _element);

		/*
		* Find a element
		*/
		TreeNode<T>* search(T _element) const;

		/*
		* delete an element
		*/
		bool delete_element(TreeNode<T> *_pElement);

		/**search the element interactively*/
		TreeNode<T>* interative_search(T data);

		/**the minimum element of the tree*/
		TreeNode<T>* minimum_element(TreeNode<T> *)const;

		/**the maximum element*/
		TreeNode<T>* maximum_element(TreeNode<T> *)const;

		/**tree successor */
		TreeNode<T>* successor(TreeNode<T>* pElement) const;

		/**tree predecessor */
		TreeNode<T>* predecessor(TreeNode<T> *pElement)const;

		/**iterate all elements*/
		void print_ordered_elements()const;

		/**
		* delete one node from the tree
		*/
	

	private:
		TreeNode<T> * m_pRoot;
	};

	/*
	* Add a element into tree
	*/
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::insert(T _element)
	{
		if(m_pRoot == NULL)
		{
			m_pRoot = new TreeNode<T>;
			m_pRoot->data = _element;
			m_pRoot->left = m_pRoot->right = NULL;
			return m_pRoot;
		}
		else
		{
			TreeNode<T> *pNode = m_pRoot;
			while(pNode != NULL)
			{
				if( _element > pNode->data )
				{
					//insert into right subtree
					//pNode = pNode->right;

					//make the current element be the right son.
					if(pNode->right == NULL)
					{
						TreeNode<T> *pNewElement = new TreeNode<T>;
						pNewElement->data = _element;
						pNewElement->left = NULL;
						pNewElement->right = NULL;
						pNewElement->parent = pNode;
						pNode->right = pNewElement;
						return pNewElement;
					}
					else
					{
						pNode = pNode->right;
					}
					
				}
				else if(_element < pNode->data )
				{
					//insert into left subtree
					//pNode = pNode->left;
					if(pNode->left == NULL)
					{
						TreeNode<T> *pNewElement = new TreeNode<T>;
						pNewElement->data = _element;
						pNewElement->left = NULL;
						pNewElement->right = NULL;
						pNewElement->parent = pNode;
						pNode->left = pNewElement;
						return pNewElement;
					}
					else
					{
						pNode = pNode->left;
					}
				}
				else
				{
					return pNode;
				}

			}
		}
		return NULL;
	}

	/*
	* Find an element
	* if there is no such element return NULL
	*/
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::search(T _element) const
	{
		TreeNode<T> *pElement = m_pRoot;
		while(pElement != NULL)
		{
			//search the left
			if(_element < pElement->data)
			{
				pElement = pElement->left;
			}
			else if(_element > pElement->data)
			{
				pElement = pElement->right;
			}
			else
			{
				return pElement;
			}
		}
		return NULL;
	}

	/*
	* delete an element
	*/
	template<typename T>
	bool BinarySearchTree<T>::delete_element(TreeNode<T> *_pElement)
	{
		//assert
		//assert(_pElement != NULL && m_pRoot != NULL);
		if(_pElement == NULL || m_pRoot == NULL)
		{
			return false;
		}
		TreeNode<T> *realDelete = NULL;
		TreeNode<T> *pSon = NULL;

		if(_pElement ->left == NULL || _pElement->right == NULL)
		{
			realDelete = _pElement;
		}
		else
		{
			realDelete = successor(_pElement);
		}

		if(realDelete->left != NULL)
		{
			pSon = realDelete->left;
		}
		else
		{
			pSon = realDelete->right;
		}

		if(pSon != NULL)
		{
			pSon->parent = realDelete->parent;
		}
	

		if(realDelete ->parent != NULL)
		{
			if(realDelete->parent->left == realDelete)
			{
				realDelete->parent->left = pSon;
			}
			else
			{
				realDelete->parent->right = pSon;
			}

			if(_pElement != realDelete)
			{
				_pElement->data = realDelete->data;
				delete realDelete;
			}
		}
		else
		{
			delete m_pRoot;
			m_pRoot = NULL;
		}
		return true;
		//this is what age
	}


	/**the minimum element of the tree*/
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::minimum_element(TreeNode<T> *pCNode)const
	{
		TreeNode<T> *pNode = pCNode;
		while(pNode->left != NULL)
		{
			pNode = pNode->left;
		}
		return pNode;
	}

	/**the maximum element*/
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::maximum_element(TreeNode<T> *pCNode)const
	{
		TreeNode<T> *pNode = pCNode;
		while(pNode->right != NULL)
		{
			pNode = pNode->right;
		}
		return pNode;
	}

	//print 
	template<typename T>
	void BinarySearchTree<T>::print_ordered_elements()const
	{
		std::stack<TreeNode<T>*> elements;
		TreeNode<T>* tmp = m_pRoot;
		elements.push(m_pRoot);
		std::cout<<"All Elements\n";
		while(!elements.empty())
		{
			while(tmp != NULL)
			{
				tmp = tmp ->left;
				elements.push(tmp);
			}
			
			elements.pop();

			if(!elements.empty())
			{
				tmp = elements.top();
				elements.pop();

				std::cout<<tmp->data<<std::endl;
				tmp = tmp->right;
				elements.push(tmp);
			}
		}
	}
	/**tree successor */
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::successor(TreeNode<T>* pElement) const
	{
		if(pElement->right != NULL)
		{
			return minimum_element(pElement->right);
		}
		
		TreeNode<T>* pNode = pElement->parent;
		while(pNode != NULL && pNode ->right == pElement)
		{
			pElement = pNode;
			pNode = pNode->parent;
		}
		return pNode;
		
	}

	/**tree predecessor */
	template<typename T>
	TreeNode<T>* BinarySearchTree<T>::predecessor(TreeNode<T> *pElement)const
	{
		if(pElement->left != NULL)
		{
			return maximum_element(pElement->left);
		}

		TreeNode<T>* pNode = pElement->parent;
		while(pNode != NULL && pNode ->left == pElement)
		{
			pElement = pNode;
			pNode = pNode->parent;
		}
		return pNode;
	}



	



}//namespace DataStructure

#endif //BINARY_SEARCH_TREE_H