二叉搜索树

#include <iostream>

using namespace std;

enum printType
{
Front,
Medi,
Back
};
template<typename T>
class BinartSearchTree
{
public:

BinartSearchTree();
~BinartSearchTree()
{
makeEmpty(root);
}
T findMin()
{
return findMin(root);
}
T findMax();
bool contains(const T& t)
{
return contains(t,root);
}

bool insertElemt(T& t)
{
return insertElemt(t,root);
}
bool deleteElemt(const T& t)
{
return deleteElemt(t,root);
}
bool isEmpty()
{
return (root!=NULL)?false:true;
}
void printTree(printType type);

private:

struct Node
{
T t;
Node* leftNode;
Node* rightNode;
Node(T t):t(t),leftNode(NULL),rightNode(NULL){}
};
T findMin(Node*& node);
T findMax(Node*& node);
bool insertElemt(T& t,Node*& node);
bool deleteElemt(const T& t,Node* &node);
bool contains(const T& t,Node* &node);
void frontPrint(Node*& node);
void makeEmpty(Node* & node);
Node* root;

};

template<typename T>
BinartSearchTree<T>::BinartSearchTree()
{
root=NULL;
}

template<typename T>
bool BinartSearchTree<T>::insertElemt(T& t,Node*& node)
{
if(node==NULL)//二叉树为空
{
node=new Node(t);
return true;

}
if(t<=node->t)
{
insertElemt(t,node->leftNode);
}
else
{
insertElemt(t,node->rightNode);
}
return false;

}

template<typename T>
bool BinartSearchTree<T>::contains(const T& t,Node*& node)
{
if(node==NULL)
{
return false;
}
if(t==node->t)
{
return true;
}
if(t<node->t)
{
contains(t,node->leftNode);
}
else
{
contains(t,node->rightNode);
}
}

template<typename T>
T BinartSearchTree<T>::findMin(Node*& node)
{
if(node->leftNode==NULL)
{
return node->t;
}
findMin(node->leftNode);
}

template<typename T>
bool BinartSearchTree<T>::deleteElemt(const T& t,Node* &node)
{
if(node==NULL)
{
return false;
}
if(t<node->t)
{
deleteElemt(t,node->leftNode);
}
else if(t>node->t)
{
deleteElemt(t,node->rightNode);
}
else if(node->leftNode!=NULL&&node->rightNode!=NULL)
{
node->t=findMin(node->rightNode);
deleteElemt(node->t,node->rightNode);
}
else
{
Node* oldNode=node;
node=(node->leftNode!=NULL)?node->leftNode:node->rightNode;
delete oldNode;
return true;
}

}

template<typename T>
void BinartSearchTree<T>::makeEmpty(Node* &node)
{
if(node==NULL)
{
return;
}
makeEmpty(node->leftNode);
makeEmpty(node->rightNode);
delete node;
}

template<typename T>
void BinartSearchTree<T> ::printTree(printType type)
{
switch(type)
{
case Front:
frontPrint(root);
break;
}
}

template<typename T>
void BinartSearchTree<T>::frontPrint(Node*& node)
{
if(node==NULL)
{
return;
}
cout<<node->t;
frontPrint(node->leftNode);
frontPrint(node->rightNode);
}

#include "BinarySearchTree.h"

int main()
{
BinartSearchTree<int> tree;
int x1=10;
int x2=5;
int x3=12;
int x4=4;
int x5=7;
cout<<tree.isEmpty()<<endl;
tree.insertElemt(x1);
tree.insertElemt(x2);
tree.insertElemt(x3);
tree.insertElemt(x4);
tree.insertElemt(x5);
tree.printTree(Front);
cout<<endl;
cout<<tree.contains(5)<<endl;
cout<<tree.contains(2)<<endl;
cout<<tree.isEmpty()<<endl;
//tree.searchPath(22);
getchar();
}