二叉搜索树实现文件C++

//	13-1.cpp
#include "stdafx.h"
#include "13-1.h"

namespace binarySearchTree
{
//	private:

	Node * BinarySearchTree ::  m_MakeNode (const Item & item)
	{
		Node * newNode = new Node ;

		if (newNode)
		{
			newNode -> item = item ;
			newNode -> left = newNode -> right = NULL ;
		}

		return newNode ;
	}
	
	void BinarySearchTree :: m_PrecedingOrderTreversal (const Node * const pn) const
	{
		if (pn)
		{
			std :: cout << pn -> item << std :: endl ;
			m_PrecedingOrderTreversal (pn -> left) ;
			m_PrecedingOrderTreversal (pn -> right) ;
		}
	}

	void BinarySearchTree :: m_IntermediateOrderTraversal (const Node * const pn) const
	{
		if (pn)
		{
			m_IntermediateOrderTraversal (pn -> left) ;
			std :: cout << pn -> item << std :: endl ;
			m_IntermediateOrderTraversal (pn -> right) ;
		}
	}

	void BinarySearchTree :: m_HindOrderTraversal (const Node * const pn) const
	{
		if (pn)
		{
			m_HindOrderTraversal (pn -> left) ;
			m_HindOrderTraversal (pn -> right) ;
			std :: cout << pn -> item << std :: endl ;
		}
	}

	void BinarySearchTree :: m_Release (const Node * const pn)
	{
		if (pn)
		{
			m_Release (pn -> left) ;
			m_Release (pn -> right) ;
			delete pn ;
		}
	}

	void BinarySearchTree :: m_Copy (const Node * const pn)
	{
		if (pn)
		{
			Insert (pn -> item) ;
			m_Copy (pn -> left) ;
			m_Copy (pn -> right) ;
		}
	}

	Item BinarySearchTree :: m_FindMin (const Node * pRight) const
	{
		while (pRight -> left)
			pRight = pRight -> left ;

		return pRight -> item ;
	}

//	public:
	BinarySearchTree :: BinarySearchTree (void)
	{
		m_root = NULL ;
		m_current = 0 ;
	}
	
	BinarySearchTree :: BinarySearchTree (const BinarySearchTree & t)
	{
		m_root = NULL ;
		m_current = 0 ;
		m_Copy (t.m_root) ;
	}

	Item BinarySearchTree ::  FindMin (void) const
	{
		Node * scan = m_root ;

		while (scan -> left)
			scan = scan -> left ;

		return scan -> item ;
	}

	Item BinarySearchTree :: FindMax (void) const
	{
		Node * scan = m_root ;

		while (scan -> right)
			scan = scan -> right ;

		return scan -> item ;
	}

	int BinarySearchTree :: Count (void) const
	{
		return m_current ;
	}

	bool BinarySearchTree :: IsEmpty (void) const
	{
		return 0 == m_current ;
	}

	bool BinarySearchTree :: Find (const Item & item) const
	{
		Node * scan = m_root ;

		while (scan && scan -> item != item)
		{
			if (item < scan -> item)
				scan = scan -> left ;
			else
				scan = scan -> right ;
		}
		if (!scan)
			return false ;
		else
			return true ;
	}

	bool BinarySearchTree :: Insert (const Item & item)
	{
		Node * newNode = m_MakeNode (item) ;

		if (!newNode)
			return false ;
		if (IsEmpty ())
		{
			m_root = newNode ;
			m_current = 1 ;
			return true ;
		}
		Node * scan = m_root ;
		while (1)
		{
			if (item < scan -> item)
			{
				if (!scan -> left)
				{
					scan -> left = newNode ;
					break ;
				}
				else
					scan = scan -> left ;
			}
			else
			{
				if (!scan -> right)
				{
					scan -> right = newNode ;
					break ;
				}
				else
					scan = scan -> right ;
			}
		}
		++m_current ;

		return true ;
	}

	bool BinarySearchTree :: Delete (const Item & item)
	{
		Node * scan = m_root, * parent = NULL ;

		while (scan && scan -> item != item)
		{
			parent = scan ;
			if (item < scan -> item)
				scan = scan -> left ;
			else
				scan = scan -> right ;
		}
		//	Not in tree
		if (!scan)
			return false ;
		//	If has two chidren
		if (scan -> left && scan -> right)
		{
			Item temp = m_FindMin (scan -> right) ;
			Delete (temp) ;
			scan -> item = temp ;
		}
		//	Else if has left child only
		else if (scan -> left)
		{
			if (parent)
			{
				if (scan == parent -> left)
				{
					parent -> left = scan -> left ;
					delete scan ;
				}
				else
				{
					parent -> right = scan -> left ;
					delete scan ;
				}
			}
			else
			{
				m_root = scan -> left ;
				delete scan ;
			}
		}
		//	Else if has right child only
		//	or is a leaf
		else
		{
			if (parent)
			{
				if (scan == parent -> left)
				{
					parent -> left = scan -> right ;
					delete scan ;
				}
				else
				{
					parent -> right = scan -> right ;
					delete scan ;
				}
			}
			else
			{
				m_root = scan -> right ;
				delete scan ;
			}
		}
		--m_current ;

		return true ;
	}

	void BinarySearchTree :: PrecedingOrderTreversal (void) const
	{
		m_PrecedingOrderTreversal (m_root) ;
	}

	void BinarySearchTree :: IntermediateOrderTraversal (void) const
	{
		m_IntermediateOrderTraversal (m_root) ;
	}
	
	void BinarySearchTree :: HindOrderTraversal (void) const
	{
		m_HindOrderTraversal (m_root) ;
	}

	BinarySearchTree & BinarySearchTree :: operator= (const BinarySearchTree & t)
	{
		if (this == &t)
			return *this ;
		m_Release (m_root) ;
		m_root = NULL ;
		m_current = 0 ;
		m_Copy (t.m_root) ;

		return *this ;
	}

	BinarySearchTree :: ~BinarySearchTree (void)
	{
		m_Release (m_root) ;
	}
}