尤其注意删除单个根结点、删除有一个分支的根结点时要防止内存泄露（_root为私有成员时）

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

//结点类
template <class T>
class BinaryNode
{
public:
	T data;
	BinaryNode<T> *lchild;
	BinaryNode<T> *rchild;

	BinaryNode();
	BinaryNode(T val);
private:

};

template <class T>
BinaryNode<T>::BinaryNode()
{
	data = 0;
	lchild = NULL;
	rchild = NULL;
}

template <class T>
BinaryNode<T>::BinaryNode(T val)
{
	data = val;
	lchild = NULL;
	rchild = NULL;
}

//二叉树类
template <class  T>
class BinaryTree
{
private:
	BinaryNode<T> *_root;  //根结点

public:
	BinaryTree();	//构造空结点
	BinaryTree(const T preList[], const int size, int index, const T end);	//先序构造
	~BinaryTree();

	BinaryNode<T>* CreateBiTree(const T preList[], const int size, int &index, const T end);	//先序创建二叉树
	void ClearBiTree(BinaryNode<T> *root);  //销毁二叉树
	void PreVisitBiTree();	//先序遍历，非递归
	void MidVisitBiTree();	//中序遍历，非递归
	void PostVisitBiTree();	//后序遍历，非递归
	void LevelVisitBiTree();//层序遍历，非递归
	void InsertTree(int val);
	void DeleteTree(int val);
	BinaryNode<T>* SearchTree(int val);
};

//构造空树
template <class T>
BinaryTree<T>::BinaryTree()
{
	_root = NULL;
}

//先序构造二叉树
template <class T>
BinaryTree<T>::BinaryTree(const T preList[], const int size, int index, const T end)
{
	_root = CreateBiTree(preList, size, index, end);
}

//析构
template <class T>
BinaryTree<T>::~BinaryTree()
{
	ClearBiTree(_root);
	_root = NULL;
}

//先序创建二叉树
template <class T>
BinaryNode<T>* BinaryTree<T>::CreateBiTree(const T preList[],const int size, int &index,const T end)  //特别注意：index必须用引用，否则函数的两个++index将不会正常改变
{
	BinaryNode<T>* root = NULL;

	if((index < size) && (preList[index] != end))
	{

		root = new BinaryNode<T>();

		root->data = preList[index];
		root->lchild = CreateBiTree(preList, size, ++index, end);
		root->rchild = CreateBiTree(preList, size, ++index, end);
	}
	return root;
}

//销毁二叉树
template <class T>
void BinaryTree<T>::ClearBiTree(BinaryNode<T>* root)
{
	BinaryNode<T> *tmp = root;

	if(tmp == NULL)
	{
		return;
	}
	ClearBiTree(tmp->lchild);
	ClearBiTree(tmp->rchild);

	delete tmp;
	tmp = NULL;
}

//非递归遍历

//1 前序遍历
template <class T>
void BinaryTree<T>::PreVisitBiTree()
{
	BinaryNode<T>* cur = _root;
	stack<BinaryNode<T> *> biTreeStack;

	if(cur == NULL)
	{
		cout << "NULL" << endl;
		return;
	}

	while ((cur != NULL) || (!biTreeStack.empty()))
	{
		while (cur != NULL)
		{
			cout << cur->data << " "; 
			biTreeStack.push(cur);
			cur = cur->lchild;
		}
		BinaryNode<T> *top = biTreeStack.top();
		biTreeStack.pop();
		cur = top->rchild;
		cur->data;
	}
	cout << endl;
}

//2 中序遍历
template<class T>
void BinaryTree<T>::MidVisitBiTree()
{
	BinaryNode<T> *cur = _root;
	stack<BinaryNode<T> *> biTreeStack;

	while ((cur != NULL) || (!biTreeStack.empty()))
	{
		while (cur != NULL)
		{
			biTreeStack.push(cur);
			cur = cur->lchild;
		}
		BinaryNode<T> *top = biTreeStack.top();
		cout << top->data << " ";
		biTreeStack.pop();
		cur = top->rchild;
	}
	cout << endl;
}

//3 后序遍历
template<class T>
void BinaryTree<T>::PostVisitBiTree()
{
	BinaryNode<T> *cur = _root;
	BinaryNode<T> *priview = NULL;

	stack<BinaryNode<T> *> biTreeStack;

	while ((cur != NULL) || (!biTreeStack.empty()))
	{
		while (cur != NULL)
		{
			biTreeStack.push(cur);
			cur = cur->lchild;
		}

		BinaryNode<T> *top = biTreeStack.top();

		if((top->rchild == NULL) || (priview == top->rchild))
		{
			cout << top->data << " ";
			priview = top;
			biTreeStack.pop();
		}
		else
		{
			cur = top->rchild;
		}
		
	}
	cout << endl;
}

//4 层序遍历
template<class T>
void BinaryTree<T>::LevelVisitBiTree()
{
	BinaryNode<T> *cur = _root;
	queue<BinaryNode<T> *> biTreeQueue;

	biTreeQueue.push(cur);

	while (!biTreeQueue.empty())
	{
		BinaryNode<T> *top = biTreeQueue.front();
		cout << top->data << " ";
		biTreeQueue.pop();
		
		if(top->lchild != NULL)
		{
			biTreeQueue.push(top->lchild);
		}
		if(top->rchild != NULL)
		{
			biTreeQueue.push(top->rchild);
		}
	}
	cout << endl;
}

//搜索二叉树的插入
template<class T>
void BinaryTree<T>::InsertTree(int val)
{
	if(NULL == _root)
	{
		_root =new BinaryNode<T>();
		_root->data = val;
		
		return;
	}

	BinaryNode<T> *cur = _root;
	BinaryNode<T> *parant = NULL;
	BinaryNode<T> *tmp = new BinaryNode<T>();

	while (cur != NULL)
	{
		parant = cur;
		if(val < cur->data)
		{
			cur = cur->lchild;
		}
		else
		{
			cur = cur->rchild;
		}
	}
	
	tmp->data = val;
	if(val < parant->data)
	{
		parant->lchild = tmp;
	}
	else
	{
		parant->rchild = tmp;
	}
}

//删除二叉树
template<class T>
void BinaryTree<T>::DeleteTree(int val)
{
	if(NULL == _root)
	{
		cout << "删除失败：树为空" << endl;
		return;
	}

	BinaryNode<T> *cur = _root;
	BinaryNode<T> *parent = _root;

	int flag = 0;

	while (cur != NULL)
	{
		if(cur->data == val)
		{
			if((NULL == cur->lchild) && (NULL == cur->rchild)) //要删除的点为叶节点
			{
				if(parent == cur) //树只有一个结点
				{
					delete _root;	//必须删除原始根结点 _root
					_root = NULL;	
					return;
				}
				else if(parent->lchild == cur) //左孩子为要删除的点
				{
					parent->lchild = NULL;
				}
				else if(parent->rchild == cur) //右孩子为要删除的点
				{
					parent->rchild = NULL;
				}

				delete cur;
				cur = NULL;
				return;
			}
			else if((NULL == cur->lchild) || (NULL == cur->rchild)) //要删除的点有一个孩子
			{
				if(parent->lchild == cur)  //要删除的点是左孩子
				{
					if(cur->lchild != NULL) //要删除的点有一个左孩子
					{
						parent->lchild = cur->lchild;
					}
					else if(cur->rchild != NULL)
					{
						parent->lchild = cur->rchild;
					}
				}
				else if(parent->rchild == cur)
				{
					if(cur->lchild != NULL)
					{
						parent->rchild = cur->lchild;
					}
					else if(cur->rchild != NULL)
					{
						parent->rchild = cur->rchild;
					}
				}

				else if(parent == cur)  //要删除的点为根节点，且有一个分支
				{
					if(cur->lchild != NULL)
					{
						_root = cur->lchild;	//必须删除原始根结点 _root，如果delete一个局部变量，只是将_root中的值改变，但是
												//_root还是存在的，它变成了野指针，当再次访问根结点的时候，就会导致内存泄露
					}
					else if(cur->rchild != NULL)
					{
						_root = cur->rchild;	//必须删除原始根结点 _root
					}
				}
				delete cur;
				cur = NULL;
				return;
			}
			else
			{
				BinaryNode<T> *tmp = cur;
				BinaryNode<T> *tmpParent = cur;
				
				tmp = tmp->lchild;
				while (tmp->rchild != NULL)
				{
					tmpParent = tmp;
					tmp = tmp->rchild;
				}

				cur->data = tmp->data;
				if(tmpParent == cur)
				{
					cur->lchild = tmp->lchild;
				}
				else
				{
					tmpParent->rchild = tmp->lchild;
				}
				delete tmp;
				tmp = NULL;
				return;
			}
		}

		parent = cur;
		if(val < cur->data)
		{
			cur = cur->lchild;
		}
		else
		{
			cur = cur->rchild;
		}
	}

	cout << "未找到要删除的点" << endl;
}

//搜索二叉树
template<class T>
BinaryNode<T>* BinaryTree<T>::SearchTree(int val)
{
	if(NULL == _root)
	{
		cout << "none tree" << endl;
		return _root;
	}

	BinaryNode<T> *cur = _root;
	while (cur != NULL)
	{
		if(val < cur->data)
		{
			cur = cur->lchild;
		}
		else if(val > cur->data)
		{
			cur = cur->rchild;
		}
		else
		{
			return cur;
		}
	}

	cout << "none tree" << endl;
	return NULL;
}

int main()
{
	//int preList[] = {8, 2 , 0, 3, 0, 0, 14, 0, 33, 0, 0};
	int preList[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
	BinaryTree<int> *tree = new BinaryTree<int>(preList, 12, 0, 0);
	//tree->PreVisitBiTree();
	//tree->MidVisitBiTree();
	//tree->PostVisitBiTree();
	//tree->LevelVisitBiTree();
	tree->InsertTree(34);
	tree->InsertTree(32);
	//tree->InsertTree(33);
	//tree->DeleteTree(8);
	tree->DeleteTree(34);
	//tree->DeleteTree(32);
	//tree->DeleteTree(33);
	//tree->DeleteTree(14);
	//tree->DeleteTree(2);
	//tree->DeleteTree(3);
	//tree->DeleteTree(35);
	cout << "insert a number" << endl;
	tree->MidVisitBiTree();
	cout << "search tree" << endl;
	
	BinaryNode<int> *tmp = tree->SearchTree(98);
	if(tmp != NULL)
	{
		cout << tmp->data << endl;
	}

	delete tree;

	return 0;
}