二叉树的遍历（递归）

二叉树 :二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。
满二叉树 :高度为N的满二叉树有2^N- 1个节点的二叉树。
完全二叉树: 若设二叉树的深度为h，除第h 层外，其它各层(1～h-1) 的结点数都达到最大个数，第h 层所有的结点都连续集中在最左
边，这就是完全二叉树。

如图，是一个完全二叉树。

★前序遍历(先根遍历):【1 2 3 4 5 6】

（1）：先访问根节点； 

（2）：前序访问左子树；

（3）：前序访问右子树；

代码如下：

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

template <typename T>
struct BinaryTreeNode
{
	BinaryTreeNode<T>* _Left;
	BinaryTreeNode<T>* _Right;
	T _data;

	BinaryTreeNode(const T& x)
		:_Left(NULL)
		, _Right(NULL)
		,_data(x)
	{
	}
};

template <typename T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_root(NULL)
	{
	}
	BinaryTree(const T *a, size_t size, int invalid)
	{
		int index = 0;
		_root=_CreatBinaryTree(a, size,invalid,index);
	}
	BinaryTree(const BinaryTree<T>& t)
	{
		_root = _Copy(t._root);
	}

	BinaryTree& operator=(const BinaryTree<T>& t)
	{
		if (this != &t)
		{
			_Destory(_root);
			_root = _Copy(t._root);
		}
		return *this;
	}

	~BinaryTree()
	{
		_Destory(_root);
		_root = NULL;
	}

	void PreOrder()
	{
		 _PreOrder(_root);
		 cout << endl;
	}

	void InOrder()
	{
		 _InOrder(_root);
		 cout << endl;
	}

	void PostOrder()
	{
		 _PostOrder(_root);
		 cout << endl;
	}

	
protected:
	Node* _root;

	Node* _CreatBinaryTree(const T* a, size_t size, const T& invalid, int& index)
	{
		Node* root = NULL;
		if (index < size && a[index] !=invalid)
		{
			root = new Node(a[index]);
			root->_Left = _CreatBinaryTree(a, size, invalid, ++index);
			root->_Right = _CreatBinaryTree(a, size, invalid, ++index);
		}
		return root;
	}

	Node* _Copy(Node* root)
	{
		if (root == NULL)
		{
			return NULL;
		}
		else
		{
			Node* newroot = new Node(root->_data);
			newroot->_Left = _Copy(root->_Left);
			newroot->_Right = _Copy(root->_Right);
		}
		return newroot;
	}

	void _Destory(Node* &root)
	{
		if (root == NULL)
		{
			return;
		}
		if (root->_Left == NULL&&root->_Right == NULL)
		{
			delete root;
			root = NULL;
			return;
		}

		_Destory(root->_Left);
		_Destory(root->_Right);
		delete root;
	}

	void _PreOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		cout << root->_data << " ";
		_PreOrder(root->_Left);
		_PreOrder(root->_Right);
		
	}

（1）：中序访问左子树；

（2）：访问根节点；

（3）：中序访问右子树； 

代码如下：

void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		else
		{
			_InOrder(root->_Left);
			cout << root->_data << " ";
			_InOrder(root->_Right);
		}
	}

（1）：后序访问左子树；

（2）：后序访问右子树；

（3）：访问根节点； 

代码如下：

void _PostOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		else
		{
			_PostOrder(root->_Left);
			_PostOrder(root->_Right);
			cout << root->_data << " ";
		}
	}