用C++实现二叉树

#include <iostream>

using namespace std;

template<class Comparable>
class BinarySearchTree
{
public:
BinarySearchTree():root(NULL){}
/*复制构造函数*/
BinarySearchTree(const BinarySearchTree & rhs){
root = clone(rhs.root);
}
/*重载赋值运算符函数*/
const BinarySearchTree & operator=(const BinarySearchTree & rhs){
if (this != & rhs){
clear();
root = clone(rhs.root);
}
return *this;
}
/*析构函数*/
~BinarySearchTree(){
clear();
}
/*查找最小值*/
const Comparable & findMin() const{
return findMin(root)->element;
}
/*查找最大值*/
const Comparable & findMax() const{
return findMax(root)->element;
}
/*判断是否包含结点x*/
bool contains(const Comparable & x) const{
return contains(x, root);
}
/*判断树是否为空*/
bool isEmpty() const{
return isEmpty(root);
}

/*前序输出*/
void printTree_ELR() const{
printTree_ELR(root);
cout << endl;
}
/*中序输出*/
void printTree_LER() const{
printTree_LER(root);
cout << endl;
}
/*后序输出*/
void printTree_LRE() const{
printTree_LRE(root);
cout << endl;
}
/*清空树*/
void clear(){
clear(root);
}

/*插入结点x*/
void insert(const Comparable & x){
insert(x, root);
}

/*删除结点x*/
void remove(const Comparable & x){
remove(x, root);
}

private:
struct BinaryNode{
Comparable element;
BinaryNode * left;
BinaryNode * right;

BinaryNode(const Comparable & theElement, BinaryNode * lt, BinaryNode * rt)//:element(theElement), left(lt), right(rt)
{
element = theElement;
left = lt;
right = rt;
}
};

BinaryNode * root;
/*插入结点x*/
void insert(const Comparable & x, BinaryNode * & t) const{
if (t == NULL)
t = new BinaryNode(x, NULL, NULL);
else if (x < t->element)
insert(x, t->left);
else if (x > t->element)
insert(x, t->right);
else ;
}
/*判断树是否为空*/
bool isEmpty(BinaryNode * t) const{
if (root == NULL)
return true;
else
return false;
}
/*删除结点x*/
void remove(const Comparable & x, BinaryNode * & t){
if (t == NULL)
return;
if (x < t->element)
remove(x, t->left);
else if (x > t->element)
remove(x, t->right);
else if (t->left != NULL && t->right != NULL){
t->element = findMin(t->right)->element;
remove(t->element, t->right);
}
else {
BinaryNode *oldNode = t;
t = (t->left != NULL)? t->left : t->right;
delete oldNode;
}
}
/*查找最小值*/
BinaryNode * findMin(BinaryNode *t) const{
if (t == NULL)
return NULL;
else if(t->left == NULL)
return t;
return findMin(t->left);
}
/*查找最大值*/
BinaryNode * findMax(BinaryNode *t) const{
if (t == NULL)
return NULL;
else if (t->right == NULL)
return t;
return findMax(t->right);
}
/*判断是否包含结点x*/
bool contains(const Comparable & x, BinaryNode * t) const{
if (t == NULL)
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;
}
/*清空树
注意此处的值为根节点的引用（也就是跟结点本身），因为要清空树之后要把根结点置为NULL
*/
void clear(BinaryNode *  &t){
if (t != NULL){
clear(t->left);
clear(t->right);
delete t;
}
t = NULL;
}
/*下面这个清空树的函数也是正确的*/
//void clear(BinaryNode * t){
//	if (t != NULL){
//		clear(t->left);
//		clear(t->right);
//		delete t;
//	}
//	root = NULL;
//}

BinaryNode * clone(BinaryNode * t) const{
if (t == NULL)
return NULL;
return new BinaryNode(t->element, clone(t->left), clone(t->right));
}
/*前序输出*/
void printTree_ELR(BinaryNode * t) const{
if (t == NULL)
return;
cout << t->element << " ";
printTree_ELR(t->left);
printTree_ELR(t->right);
}
/*中序输出*/
void printTree_LER(BinaryNode * t) const{
if (t == NULL)
return;
printTree_LER(t->left);
cout << t->element << " ";
printTree_LER(t->right);
}

/*后序输出*/
void printTree_LRE(BinaryNode * t) const{
if (t == NULL)
return;
printTree_LRE(t->left);
printTree_LRE(t->right);
cout << t->element << " ";
}
};

#include "binarytree.h"

int main()
{
BinarySearchTree<int> tree;

if (tree.isEmpty())
cout << "tree is empty.\n";
else
cout << "tree is not empty.\n";

tree.insert(10);
tree.insert(9);
tree.insert(8);
tree.insert(18);
cout << "After insert four node in the tree.\n";
if (tree.isEmpty())
cout << "tree is empty.\n";
else
cout << "tree is not empty.\n";

cout << "中序输出：";
tree.printTree_LER();
cout << "前序输出：";
tree.printTree_ELR();
cout << "后序输出：";
tree.printTree_LRE();

if (tree.contains(18))
cout << "tree containes 18.\n";
else
cout << "tree doesn't contain 18.\n";

if (tree.contains(20))
cout << "tree containes 20.\n";
else
cout << "tree doesn't contain 20.\n";

cout << "The max value in the tree is " << tree.findMax() << endl;
cout << "The min value in the tree is " << tree.findMin() << endl;

tree.remove(10);
cout << "删除10之后，中序输出：";
tree.printTree_LER();

BinarySearchTree<int> tree2;
tree2 = tree;//调用赋值运算符函数
cout << "tree2中序输出：";
tree2.printTree_LER();

BinarySearchTree<int> tree3(tree);
cout << "tree3中序输出：";
tree3.printTree_LER();

tree3.clear();
if (tree3.isEmpty())
cout << "tree3 is empty.\n";
else
cout << "tree3 is not empty.\n";

cout << "tree3中序输出：";
tree3.printTree_LER();

cout << endl;
system("pause");
exit(0);
}