c++实现搜索二叉树

#include <iostream>
using namespace std;


//枚举类，前中后三种遍历方式
enum ORDER_MODE
{ ORDER_MODE_PREV = 0, ORDER_MODE_MID, ORDER_MODE_POST};


//树节点的结构体
template <class T>
struct BinaryNode
{
T element;
BinaryNode *left;
BinaryNode *right;
BinaryNode(const T& theElement, BinaryNode *lt,BinaryNode *rt):element(theElement),left(lt),right(rt){}
};




template <class T>
class BinarySearchTree
{
private:


BinaryNode<T> *m_root;


public:
BinarySearchTree()
{
m_root=NULL;
}
BinarySearchTree(const BinarySearchTree& rhs);
~BinarySearchTree();


const T& findMin() const;
const T& findMax() const;
bool contains(const T& x) const;
void printTree(ORDER_MODE eOrderMode = ORDER_MODE_PREV) const;


void makeEmpty();
void insert(const T& x);
void remove(const T& x);


private:
void insert(const T& x, BinaryNode<T>* &t) ;
void remove(const T& x, BinaryNode<T>* &t) ;
BinaryNode<T>* findMin( BinaryNode<T>* t) const;
BinaryNode<T>* findMax( BinaryNode<T>* t) const;
bool contains(const T& x, const BinaryNode<T>* t) const;
void makeEmpty(BinaryNode<T>* &t);
void printTreeInPrev(BinaryNode<T>* t) const;
void printTreeInMid(BinaryNode<T>* t)const;
void printTreeInPost(BinaryNode<T>* t)const;
};


//构造方法
//template <class T>
//BinarySearchTree<T>::BinarySearchTree()
//{
// m_root = NULL;
//}


//使用另一棵二叉搜索树的构造函数
template <class T>
BinarySearchTree<T>:: BinarySearchTree(const BinarySearchTree& rhs)
{
m_root = rhs.m_root;
}


//析构函数，释放内存
template <class T>
BinarySearchTree<T>:: ~BinarySearchTree()
{
makeEmpty();
}


// 判断x元素是否存在
template <class T>
bool  BinarySearchTree<T>::contains(const T& x) const
{
return contains(x, m_root);
}


//递归调用,看元素X是否存在，查找树中某个元素值
template <class T>
bool BinarySearchTree<T>::contains(const T& x, const BinaryNode<T>* t) const
{
if (!t)
return false;
else if (x < t->element)
return contains(x, t->left);
else if (x > t->element)
return contains(x, t->right);
else
return true;
}


// 寻找树中的最小值
template <class T>
const T& BinarySearchTree<T>::findMin() const
{
return findMin(m_root)->element;
}


//递归搜索树中最小值,在最左边的叶子
template <class T>
BinaryNode<T>* BinarySearchTree<T>::findMin( BinaryNode<T>* t) const
{
//二叉树的一个特点就是左子叶的值比根节点小， 右子叶的比根节点的大
if (!t)
return NULL;
if (t->left == NULL)
return t;
else
return findMin(t->left);//可以不用递归
}


// 寻找树中最大值，在最右边的叶子
template <class T>
const T& BinarySearchTree<T>::findMax() const
{
return findMax(m_root)->element;
}


//非递归方法来寻找树中最大值
template <class T>
BinaryNode<T>* BinarySearchTree<T>::findMax( BinaryNode<T>* t) const
{
//二叉树的一个特点就是左子叶的值比根节点小， 右子叶的比根节点的大
if (t != NULL)
while (t->right != NULL)
t = t->right;
return t;
}


// 插入元素
template <class T>
void BinarySearchTree<T>:: insert(const T& x)
{
insert(x, m_root);
}


//递归插入，用它来建立二叉搜索树
template <class T>
void BinarySearchTree<T>::insert(const T& x, BinaryNode<T>* &t) 
{
if (t == NULL)
t = new BinaryNode<T>(x, NULL, NULL);//注意这个指针参数是引用
else if (x < t->element)
insert(x, t->left);
else if (x > t->element)
insert(x, t->right);
else
;//do nothing
}




//移除元素
template <class T>
void BinarySearchTree<T>::remove(const T& x)
{
return remove(x, m_root);
}


//递归移除
template <class T>
void BinarySearchTree<T>::remove(const T& x, BinaryNode<T>* &t) 
{
if (t == NULL)
return;
if (x < t->element)
remove(x, t->left);
else if (x > t->element)
remove (x, t->right);
else // now ==，x=t->element的情况
{
if (t->left != NULL &&  //节点x有两个孩子的情况
t->right != NULL)//two child
{
t->element = findMin(t->right)->element;//用后继元素的数据值替换掉删去节点的数据值，且这里t还是等于x
//找到X的 后继元素，对于有右孩子的节点，他的后继一定是右子树中最小的，肯定是位于右子树中，且肯定没有左孩子的，因为它是最小的

remove(t->element, t->right);//在右子树中找到后继节点的位置，用它的右孩子替换它
}
else
{
BinaryNode<T> *oldNode = t;   
t = (t->left != NULL) ? t->left : t->right;//只有一个孩子节点或者是没有孩子节点的情况，没有孩子节点此时t->right=NULL
delete oldNode;
}
}
}


//清空二叉树,释放内存
template <class T>
void  BinarySearchTree<T>::makeEmpty()
{
makeEmpty(m_root);
}


//递归清空
template <class T>
void  BinarySearchTree<T>::makeEmpty(BinaryNode<T>* &t)
{
if (t)
{
makeEmpty(t->left);
makeEmpty(t->right);
delete t;
}
t = NULL;
}




// 打印二叉搜索树
template <class T>
void BinarySearchTree<T>::printTree(ORDER_MODE eOrderMode /*= ORDER_MODE_PREV*/) const
{
if (ORDER_MODE_PREV == eOrderMode)
printTreeInPrev(m_root);
else if (ORDER_MODE_MID == eOrderMode)
printTreeInMid(m_root);
else if (ORDER_MODE_POST == eOrderMode)
printTreeInPost(m_root);
else 
;//do nothing
}


//前序打印
template <class T>
void BinarySearchTree<T>::printTreeInPrev(BinaryNode<T>* t) const
{
if (t)
{
cout << t->element<<" ";
printTreeInPrev(t->left);
printTreeInPrev(t->right);
}
}


//中序打印
template <class T>
void BinarySearchTree<T>::printTreeInMid(BinaryNode<T>* t) const
{
if (t)
{
printTreeInMid(t->left);
cout << t->element<<" ";
printTreeInMid(t->right);
}
}


//后序打印
template <class T>
void BinarySearchTree<T>::printTreeInPost(BinaryNode<T>* t) const
{
if (t)
{
printTreeInPost(t->left);
printTreeInPost(t->right);
cout << t->element<<" ";
}
}




int main()
{
BinarySearchTree<int> binaryTree;
binaryTree.insert(12);
binaryTree.insert(5);
binaryTree.insert(2);
binaryTree.insert(9);
binaryTree.insert(18);
binaryTree.insert(15);
binaryTree.insert(13);
binaryTree.insert(17);
binaryTree.insert(19);


//测试前中后序打印
cout <<endl<<"前序："<<endl;
binaryTree.printTree(ORDER_MODE_PREV);
cout <<endl<<"中序："<<endl;
binaryTree.printTree(ORDER_MODE_MID);
cout <<endl<<"后序："<<endl;
binaryTree.printTree(ORDER_MODE_POST);
cout <<endl;


//测试基本操作
bool b = binaryTree.contains(1);
cout<< "是否存在1：";
if(b==false)
cout<<" 不存在1"<<endl;
else
cout<<"存在"<<endl;
int x = binaryTree.findMin();
cout << "最小值为："<< x <<endl;
x = binaryTree.findMax();
cout << "最大值为："<< x <<endl;
binaryTree.remove(2);


cout << "移除元素2之后"<<endl;


//测试前中后序打印
cout <<endl<<"前序："<<endl;
binaryTree.printTree(ORDER_MODE_PREV);
cout <<endl<<"中序："<<endl;
binaryTree.printTree(ORDER_MODE_MID);
cout <<endl<<"后序："<<endl;
binaryTree.printTree(ORDER_MODE_POST);
cout <<endl;
return 0;
}