二叉树

#include <iostream>
#include <cassert>
#include <stack>
#include <queue>
using namespace std;

template<class T>
struct BinaryTreeNode//二叉树的节点
{
	BinaryTreeNode(const T value)
	:_data(value)
	, _pleft(NULL)
	, _pright(NULL)
	{}

	T _data;
	BinaryTreeNode<T>* _pleft;
	BinaryTreeNode<T>* _pright;
};

template<class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_proot(NULL)
	{}

	BinaryTree(const T* p, size_t size, const T& invalid)//构造函数
	{
		assert(p);
		size_t index = 0;
		CreatTree(_proot, p, size, invalid, index);//创建二叉树
	}

	BinaryTree(const BinaryTree<T>& bt)//拷贝构造函数
	{
		_proot = Copy(bt._proot);
	}

	BinaryTree<T>& operator =(const BinaryTree<T> bt)//赋值运算符的重载（现代写法）
	{
		swap(_proot, bt._proot);
		return *this;
	}

	~BinaryTree()//析构函数
	{
		if (_proot != NULL)
			Distroy(_proot);
	}

	void PreOrder()//前序遍历递归写法
	{
		cout << "PreOrder:";
		_PreOrder(_proot);
		cout << endl;
	}

	void PreOrderNor()//前序遍历递非写法
	{
		if (_proot == NULL)
			return;

		cout << "PreOrderNor:";
		stack<Node*> s;
		Node* cur = _proot;

		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cout << cur->_data << " ";
				cur = cur->_pleft;
			}

			cur = s.top();
			s.pop();
			cur = cur->_pright;
		}
		cout << endl;
	}

	void InOrder()//中序遍历递归写法
	{
		cout << "InOrder:";
		_InOrder(_proot);
		cout << endl;
	}

	void InOrderNor()//中序遍历非递归写法
	{
		if (_proot == NULL)
			return;

		cout << "InOrderNor";
		stack<Node*> s;
		Node* cur = _proot;

		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cur = cur->_pleft;
			}

			cur = s.top();
			s.pop();
			cout << cur->_data << " ";
			cur = cur->_pright;
		}
		cout << endl;
	}

	void PostOrder()//后续遍历递归写法
	{
		cout << "PostOrder:";
		_PostOrder(_proot);
		cout << endl;
	}

	void PostOrderNor()//后续遍历非递归写法
	{
		if (_proot == NULL)
			return;

		cout << "PostOrderNor:";
		stack<Node*> s;
		Node* cur = _proot;
		Node* pre = NULL;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cur = cur->_pleft;
			}

			cur = s.top();
			if (cur->_pright == NULL || cur->_pright == pre)
			{
				cout << cur->_data << " ";
				pre = cur;
				cur = NULL;
				s.pop();
			}
			else
				cur = cur->_pright;
		}
		cout << endl;
	}

	void LevelOrder()//层序遍历
	{
		cout << "LevelOrder:";
		if (_proot == NULL)
			return;

		queue<Node*> q;
		q.push(_proot);
		while (!q.empty())
		{
			Node* tmp = q.front();
			cout << tmp->_data << " ";
			q.pop();
			if (tmp->_pleft)
				q.push(tmp->_pleft);
			if (tmp->_pright)
				q.push(tmp->_pright);
		}
		cout << endl;
	}

	void Mirror()//二叉树的镜像递归写法
	{
		_Mirror(_proot);
	}

	void MirrorNor()//二叉树的镜像非递归写法
	{
		if (_proot == NULL)
			return;

		queue<Node*> q;
		q.push(_proot);
		while (!q.empty())
		{
			Node* tmp = q.front();
			q.pop();
			swap(tmp->_pleft, tmp->_pright);
			if (tmp->_pleft)
				q.push(tmp->_pleft);
			if (tmp->_pright)
				q.push(tmp->_pright);
		}
	}

	size_t Size()
	{
		return _Size(_proot);
	}

	size_t Height()
	{
		 return _Height(_proot);
	}

	size_t LeafCount()
	{
		return _LeafCount(_proot);
	}

	size_t LevelNodeCount(size_t k)
	{
		return _LevelNodeCount(_proot, k);
	}

	Node* Find(const T& data)
	{
		return _Find(_proot, data);
	}

	bool CompleteTree()//判断是否为完全二叉树
	{
		if (_proot == NULL)
			return true;

		stack<Node*> s;
		s.push(_proot);
		bool flag = false;
		while (!s.empty())
		{
			Node* cur = s.top();
			if (flag)
			{
				if (cur->_pleft || cur->_pright)
					return false;
			}
			else
			{
				if (cur->_pleft && cur->_pright)
				{
					s.push(cur->_pleft);
					s.push(cur->_pright);
				}
				else if (cur->_pleft)
					flag = true;
				else if (cur->_pright)
					return false;
				else
					flag = true;
			}
			s.pop();
		}
		return true;
	}

private:
	void CreatTree(Node*& proot, const T*& p, size_t size, const T& invalid, size_t& index)
	{
		if (index < size && p[index] != invalid)
		{
			proot = new Node(p[index]);
			CreatTree(proot->_pleft, p, size, invalid, ++index);
			CreatTree(proot->_pright, p, size, invalid, ++index);
		}
	}

	Node* Copy(Node* proot)
	{
		Node* New = NULL;
		if (proot != NULL)
		{
			New = new Node(proot->_data);
			New->_pleft = Copy(proot->_pleft);
			New->_pright = Copy(proot->_pright);
		}
		return New;
	}

	void Distroy(Node*& proot)
	{
		if (proot)
		{
			Distroy(proot->_pleft);
			Distroy(proot->_pright);
			delete proot;
			proot = NULL;
		}
	}


	void _PreOrder(Node* proot)
	{
		if (proot)
		{
			cout << proot->_data << " ";
			_PreOrder(proot->_pleft);
			_PreOrder(proot->_pright);
		}
	}

	void _InOrder(Node* proot)
	{
		if (proot)
		{
			_InOrder(proot->_pleft);
			cout << proot->_data << " ";
			_InOrder(proot->_pright);
		}
	}

	void _PostOrder(Node* proot)
	{
		if (proot)
		{
			_PostOrder(proot->_pleft);
			_PostOrder(proot->_pright);
			cout << proot->_data << " ";
		}
	}

	size_t _Size(Node* proot)
	{
		if (proot == NULL)
			return 0;
		return _Size(proot->_pleft) + _Size(proot->_pright) + 1;
	}

	size_t _Height(Node* proot)
	{
		if (proot == NULL)
			return 0;
		return _Height(proot->_pleft) > _Height(proot->_pright) ? (_Height(proot->_pleft) + 1) : (_Height(proot->_pright) + 1);
	}

	size_t _LeafCount(Node* proot)
	{
		if (proot == NULL)
			return 0;
		if (proot->_pleft == NULL && proot->_pright == NULL)
			return 1;
		return _LeafCount(proot->_pleft) + _LeafCount(proot->_pright);
	}

	size_t _LevelNodeCount(Node* proot, size_t k)
	{
		if (proot == NULL)
			return 0;
		if (k == 1)
			return 1;
		return _LevelNodeCount(proot->_pleft, k - 1) + _LevelNodeCount(proot->_pright, k - 1);
	}


	Node* _Find(Node* proot, const T& data)
	{
		if (proot == NULL)
			return NULL;
		if (proot->_data == data)
			return proot;

		Node* tmp = NULL;
		if (tmp = _Find(proot->_pleft, data))
			return tmp;

		return _Find(proot->_pright, data);
	}

	void _Mirror(Node* proot)
	{
		if (proot)
		{
			swap(proot->_pleft, proot->_pright);
			_Mirror(proot->_pleft);
			_Mirror(proot->_pright);
		}
	}
private:
	Node* _proot;
};

int main()
{
	char* p = "abc#d###ef";
	BinaryTree<char> bt1(p, strlen(p), '#');
	BinaryTree<char> bt2(bt1);
	bt1.PreOrder();
	bt2.PreOrderNor();
	bt1.InOrder();
	bt2.InOrderNor();
	bt1.PostOrder();
	bt2.PostOrderNor();
	bt1.Mirror();
	bt1.MirrorNor();
	bt1.LevelOrder();

	BinaryTreeNode<char>* tmp = bt1.Find('d');
	if(tmp)
		cout <<"find: d  " <<tmp << "->_data:" << tmp->_data << endl;
	cout << "size:" << bt1.Size() << endl;
	cout << "height:" << bt2.Height() << endl;
	cout << "leafcount:" << bt1.LeafCount() << endl;
	cout << "levelnodecount:" << bt2.LevelNodeCount(3) << endl;
	cout << "complete:" << bt1.CompleteTree() << endl;
	system("pause");
	return 0;
}