二叉树的前序创建树以及中序后序非递归实现 以及节点个数，叶子节点个数第n层节点个数，深度

二叉树结构

二叉树构造函数

构造二叉树的实现函数

二叉树的拷贝构造与赋值运算符重载和析构

实现函数

前序遍历（递归）

实现函数

中序遍历

实现函数

递归

非递归

后序遍历

实现函数

递归

非递归

二叉树节点数量

实现函数

二叉树深度

实现函数

二叉树叶子节点

实现函数

二叉树第K层节点个数

实现函数

下面给出全部代码

#include<iostream>
using namespace std;
#include<assert.h>
#include<stack>
#include<queue>
template<class T>
struct TreeNode
{
	T _data;
	TreeNode<T>* _left;
	TreeNode<T>* _right;
	TreeNode(const T&data)
		:_data(data)
		, _left(NULL)
		, _right(NULL)
	{}
};
template<class T>
class BinaryTree
{
public:
	typedef TreeNode<T> Node;

	BinaryTree()
		:_root(NULL)
	{}
	BinaryTree(T*a,size_t size,const T& invalid)
	{
		assert(a);
		size_t index = 0;
		_root=_CreatTreeNode(a,size,invalid,index);
	}
	void prevorder()
	{
		_prevorder(_root);
	}
	void midorder()//中序非递归
	{
		_midorder(_root);
	}
	void Postorder()
	{
		_Postorder(_root);
	}
	size_t Size()
	{
		int ret=_size(_root);
		return ret;
	}
	size_t Depth()
	{
		return depth(_root);
	}
	size_t leavenum()
	{
		return _leafnum(_root);
	}
	size_t getklevesize(int k)
	{
		return _getklevesize(_root,k);
	}
protected:
	size_t _getklevesize(Node*root,size_t k) 
	{
		assert(k>=1);
		size_t count = 0;
		if (root == NULL)
			return 0;
		if (k == 1)
			count++;
		else
			count = _getklevesize(root->_left, k - 1) + _getklevesize(root->_right,k-1);
		return count;
	}
	size_t _leafnum(Node*root)
	{
		if (root == NULL)
			return 0;
		if (root->_left == NULL && root->_right == NULL)
			return 1;
		else
			return _leafnum(root->_left) + _leafnum(root->_right);
	}
	size_t depth(Node*root)
	{
		if (root == NULL)
			return 0;
		return depth(root->_left) > depth(root->_right) ? (depth(root->_left) + 1) : (depth(root->_right) + 1);
	}
	size_t _size(Node*root)
	{
		size_t count = 0;
		if (root == NULL)
			return 0;
		else
			count = _size(root->_left) + _size(root->_right) + 1;

		return count;
	}
	void _Postorder(Node*root)
	{
		stack<Node*> s;
		Node*cur = _root;
		Node*prev = NULL;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
			    cur = cur->_left;
			}
			Node*top = s.top();
			if (top->_right == prev || top->_right == NULL)
			{
				cout << top->_data << " ";
				prev = top;
				s.pop();
			}
			else
				cur = top->_right;
		}

	}
	Node* _CreatTreeNode(const T*a,size_t size,const T&invalid,size_t &index)
	{
		Node*root=NULL;
		if (a[index] != invalid && (index < size))
		{
			root = new Node(a[index]);
			root->_left = _CreatTreeNode(a,size,invalid,++index);
			root->_right = _CreatTreeNode(a, size, invalid, ++index);
		}
		return root;
	}
	void _prevorder(Node *root)
	{
		if (root)
		{
			cout << root->_data << " ";
			_prevorder(root->_left);
			_prevorder(root->_right);
		}
	}
	void _midorder(Node*root)
	{
		queue<Node*> s;
		if (root)
		{
			s.push(root);
		}
		while (!s.empty())
		{
			Node*top = s.front();
			s.pop();
			cout << top->_data<<" ";
			if (top->_left)
			{
				s.push(top->_left);
			}
			if (top->_right)
			{
				s.push(top->_right);
			}
		}
	}
protected:
	Node* _root;
};
int main()
{
	int a[] = {1,2,3,'#','#',4,'#','#',5,6,'#','#'};
	BinaryTree<int> b(a,12,'#');
	b.prevorder();
	cout << endl;
	b.midorder();
	cout << endl;
	b.Postorder();
	cout << b.Size() << endl;
	cout << endl;
	cout << b.Depth() << endl;
	cout << b.leavenum() << endl;
	cout<<b.getklevesize(3)<<endl;
	

}