c++模板类递归实现二叉搜索树及其基本操作

二叉树搜索概念：http://baike.baidu.com/link?url=RK7ax6iDk2wiEzUxjKBfyOTcYKLgaDuAcyih0a6qjAewfYeK9PoIhWzjdSZl7ylwhkOdx-6ZCFhGuF0aIG1phG-X2sc9QP8KFWavC95c-ocAL9cs71wZhCOHVHsdRs3Ugr1Z85Iycv1zosbpZiRHea

.H:

//尾递归可以用一个while循环很轻易解决！
template<class T>
class BinarySearchTree
{
public:
BinarySearchTree( )
:_root(NULL)
{}

~BinarySearchTree( )
{
MakeEmpty( );
}

const T& FindMin( ) const
{
Node* ret = _FindMin( _root );

if ( NULL == ret )						//这样写可以吗？调用T类型默认构造函数
{
return T( );
}
else
{
return ret->_data;
}
}

const T& FindMax( ) const
{
Node* ret = _FindMax( _root );

if ( NULL == ret )						//这样写可以吗？调用T类型默认构造函数
{
return T( );
}
else
{
return ret->_data;
}
}

bool IsEmpty( ) const
{
return (NULL == _root) ? true : false;
}

bool Contains( const T& x ) const
{
return _Contains( x, _root );
}

void PrintTree( )const						//采用中序遍历打印树
{
_PrintTree( _root );
}

void MakeEmpty( )
{
_MakeEmpty( _root );
}

void Insert( const T& x )
{
_Insert( x, _root );
}

void Remove( const T& x )
{
_Remove( x, _root );
}

const BinarySearchTree& operator=( const BinarySearchTree& rhs )
{
if ( this != &rhs )
{
MakeEmpty( );

_root = Clone( rhs._root );
}

return *this;
}

private:
struct Node
{
T _data;
Node* _leftChild;
Node* _rightChild;

Node( const T& x, Node* leftChild, Node* rightChild )
:_data(x)
,_leftChild(leftChild)
,_rightChild(rightChild)
{}
};											//别忘了;

Node* _root;

void _Insert( const T& x, Node*& root )//想， 它是怎么链起来的， 因为下一个root是 它父亲的左或右孩子的引用， 如果传引用， new后，它的父亲的左右孩子就被链起来了。  否则的话， 临时变量，   孩子被new值赋予后不会影响到调用它的函数的值(父亲的左or右孩子的值)
{
if ( NULL == root )
{
root = new Node( x, NULL, NULL );
}
else if ( x < root->_data )
{
_Insert( x, root->_leftChild );
}
else if ( x > root->_data )
{
_Insert( x, root->_rightChild );
}
else
{
;									//相等，目前什么都不做，当然，也可以更新值什么的.
}
}

void _Remove( const T& x, Node*& root )		//注意此时指针为引用
{
if ( NULL == root )
{
return;
}
else if ( x < root->_data )
{
_Remove( x, root->_leftChild );
}
else if ( x > root->_data )
{
_Remove( x, root->_rightChild );
}
else if ( (NULL != root->_leftChild) && (NULL != root->_rightChild) )//两个孩子为一种情况
{
root->_data = _FindMin( root->_rightChild )->_data;
_Remove( root->_data, root->_rightChild );
}
else
{
Node* oldNode = root;

root = (NULL == root->_leftChild ? root->_rightChild : root->_leftChild);
delete oldNode;
}										//一个孩子，或叶子节点  归为一种情况
}

Node* _FindMin( Node* root ) const
{
if ( NULL == root )
{
return NULL;
}

if ( NULL == root->_leftChild )
{
return root;
}

return _FindMin( root->_leftChild );
}

Node* _FindMax( Node* root ) const
{
if ( NULL != root )
{
while ( NULL != root->_rightChild )
{
root = root->_rightChild;
}
}

return root;
}

bool _Contains( const T& x, Node* root ) const
{
if ( NULL == root )
{
return false;
}
else if ( x < root->_data )
{
return _Contains( x, root->_leftChild );
}
else if ( x > root->_data )
{
return _Contains( x, root->_rightChild );
}
else
{
return true;
}

//利用while循环代替尾递归(递归语句在结尾)

//while ( NULL != root )
//{
//	if ( x < root->_data )
//	{
//		root = root->_leftChild;
//	}
//	else if ( x > root->_data )
//	{
//		root = root->_rightChild;
//	}
//	else
//	{
//		return true;
//	}
//}
//return false;							//只要跳出循环，肯定没找到
}
void _MakeEmpty( Node*& root ) const
{
if ( NULL == root )
{
;
}
else
{
_MakeEmpty( root->_leftChild );		//后序删除
_MakeEmpty( root->_rightChild );

delete root;
}

root = NULL;							//别忘了置NULL
}

void _PrintTree( Node* root ) const			//中序
{
if ( NULL == root )
{
return;
}

_PrintTree( root->_leftChild );
cout << root->_data << " ";
_PrintTree( root->_rightChild );
}

Node* Clone( Node* root ) const
{
if ( NULL == root )
{
return NULL;
}
else
{
return ( new Node(root->_data, Clone(root->_leftChild), Clone(root->_rightChild)) );
}
}
};

.cpp:

#include <iostream>
#include <windows.h>
using namespace std;

#include "BinarySearchTree.h"

void test( );

int main( )
{

test( );

system( "pause" );
return 0;

}

void test( )
{
BinarySearchTree<int> t1;

int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };

for ( size_t i = 0; i < (sizeof(a) / sizeof(a[0])); ++i )
{
t1.Insert( a[i] );
}

t1.PrintTree( );
cout << endl;

cout << t1.FindMin( ) << " " << t1.FindMax( ) << " " << endl;

/*t1.MakeEmpty( );
cout << t1.FindMin( ) << " " << t1.FindMax( ) << " " << endl;*/

cout << t1.IsEmpty( ) << endl;

cout << t1.Contains( 77 ) << endl;
cout << t1.Contains( 7 ) << endl;

t1.Remove( 9 );
t1.PrintTree( );
cout << endl;

t1.Remove( 5 );
t1.PrintTree( );
cout << endl;

t1.Remove( 0 );
t1.Remove( 7 );
t1.Remove( 6 );
t1.Remove( 4 );
t1.Remove( 3 );
t1.Remove( 2 );
t1.Remove( 1 );
t1.Remove( 8 );

t1.PrintTree( );
}