头文件

// BinarySearchTree.h 
//普通二叉搜索树的实现
#include <STACK>
using namespace std;

typedef int ElemType;
struct TreeNode
{
	ElemType elem;
	TreeNode *LChildNode;
	TreeNode *RChildNode;
	TreeNode(ElemType &e, TreeNode *lchild, TreeNode *rchild)
		:elem(e), LChildNode(lchild), RChildNode(rchild){}
};

class BinaryTree
{
public:
	BinaryTree();
	virtual ~BinaryTree();

public:
	void insert(ElemType e);
	void remove(ElemType e);
	int find(const ElemType &e);
	void printTree();
	void emptyTree();
private:
	void printTree(TreeNode* &node);
	void GetNodes(stack<TreeNode *> &st, TreeNode* &node);
private:
	TreeNode *m_root;
};

实现文件

///////////////////BinarySearchTree.cpp
#include <iostream>
#include "BinarySearchTree.h"
#include <Windows.h>

/////
BinaryTree::BinaryTree()
{
	m_root = NULL;
}

BinaryTree::~BinaryTree()
{
	emptyTree();  //释放结点
}

//插入结点 (非递归方式)
void BinaryTree::insert( ElemType e )
{
	if (!m_root)
	{
		m_root = new TreeNode(e, NULL, NULL);
		return;
	}
	TreeNode *pNode = m_root;
	while(pNode)
	{
		if (e > pNode->elem)
		{
			if (pNode->RChildNode == NULL)
			{
				pNode->RChildNode = new TreeNode(e, NULL, NULL);
				cout << "insert tree node: " << e << " succeed!" <<endl;
				break;
			}
			pNode = pNode->RChildNode;
		}
		else if (e < pNode->elem)
		{
			if (pNode->LChildNode == NULL)
			{
					pNode->LChildNode = new TreeNode(e, NULL, NULL);
					cout << "insert tree node: " << e << " succeed!" <<endl;
					break;
			}
			pNode = pNode->LChildNode;
		}
		else break;
	}
	Sleep(500);
}

//删除指定的结点
void BinaryTree::remove( ElemType e )
{
	TreeNode *pNode = m_root;
	TreeNode *preNode;
	while(pNode)
	{
		if (e < pNode->elem)
		{
			preNode = pNode;
			pNode = pNode->LChildNode;
		}
		else if (e > pNode->elem)
		{
			preNode = pNode;
			pNode = pNode->RChildNode;
		}
		else break;
	}
	if (pNode)
	{
		TreeNode *pTemp = pNode;
		while(pTemp->RChildNode)
		{
			preNode = pTemp;
			pTemp = pTemp->RChildNode;
		}
		if (pTemp && pTemp != pNode)
		{
			ElemType data = pTemp->elem;
			pTemp->elem = pNode->elem;
			pNode->elem = data;
		}
		if (pTemp != pNode && preNode->RChildNode->elem == e)
		{
			if (pTemp->LChildNode)
			{
				preNode->RChildNode = pTemp->LChildNode;
			}
			else
				preNode->RChildNode = NULL;
			delete pTemp;	
		}
		else
		{
			if (pTemp->LChildNode)//移动该结点下的左子树
			{
				preNode->LChildNode = pTemp->LChildNode;
			}
			else
				preNode->LChildNode = NULL;
			delete pTemp;
		}
		cout << "remove  tree node: " << e << " succeed!" <<endl;
	}
	Sleep(500);
}

// 查找树中的某一结点
int BinaryTree::find( const ElemType &e )
{
	TreeNode *pNode = m_root;
	while(pNode)
	{
		if (e < pNode->elem)
		{
			pNode = pNode->LChildNode;
		}
		else if (e > pNode->elem)
		{
			pNode = pNode->RChildNode;
		}
		else break;
	}
	if(pNode) 
	{
		cout << "The elem: " << e
			<< " had find in tree."<< endl;
		Sleep(500);
		return 1;
	}
	else 
		return 0;
}

// 用遍历方式打印树的结点
void BinaryTree::printTree()
{
	cout << "print the tree nodes: ";
	if (m_root)
		printTree(m_root);
	else 
		cout << "The Tree is empty !\n";
	cout << endl;
	Sleep(500);
}

void BinaryTree::printTree(TreeNode* &node)
{  //默认为前序遍历
	if (node)
	{
		cout << node->elem << "  ";
		printTree(node->LChildNode);
		printTree(node->RChildNode);
	}
}

// 清空树的结点，释放内存
void BinaryTree::emptyTree()
{
	stack<TreeNode *> stackTree;  //用临时的栈类对象遍历存储整个树的结点
	if (m_root == NULL)
	{
		return;
	}
	GetNodes(stackTree, m_root);//遍历存储整个树的结点
	TreeNode *tempNode = stackTree.top();
	stackTree.pop();
	while(tempNode)
	{
		delete tempNode;
		if (stackTree.size()>0)
		{
			tempNode = stackTree.top();
			stackTree.pop();
		}
		else break;
	}
	m_root = NULL;
	cout << "Emptied The Tree Nodes.\n";
}

void BinaryTree::GetNodes( stack<TreeNode *> &st, TreeNode* &node )
{// 用递归的方法遍历所有结点，存储在栈对象中
	if (node)
	{
		st.push(node);
	}
	else return;
	TreeNode *pLeft = node->LChildNode;
	if (pLeft)
	{
		GetNodes(st, pLeft );
	}
	TreeNode *pRight = node->RChildNode;
	if (pRight)
	{
		GetNodes(st, pRight );
	}
}

测试文件

//////Test.cpp for class BinaryTree

#include <iostream>
#include "BinarySearchTree.h"
using namespace std;

int main()
{
	BinaryTree Bitree;
	Bitree.insert(5);
	Bitree.insert(3);
	Bitree.insert(4);
	Bitree.insert(2);
	Bitree.insert(8);
	Bitree.insert(7);
	Bitree.insert(1);
	ElemType elem = 1;
	Bitree.find(elem);

	Bitree.printTree();
	Bitree.remove(2);
	Bitree.insert(6);
	Bitree.printTree();
	Bitree.insert(2);
	Bitree.remove(6);
	Bitree.insert(9);
	Bitree.insert(6);
	Bitree.printTree();
	Bitree.emptyTree();
	Bitree.printTree();
	return 0;
}