二叉树的构造与遍历—先根构造，一维数组存储按层构造，先根，中根，后根遍历输出

// bTreeNode.h
#include <iostream>
template <class Type> class bTree;
template <class Type> class bTreeNode {
	friend class bTree<Type>;
// this template class is not a common used template class
// it is used only in template class bTree	
private:
	bTreeNode(): data(Type()), lchild(NULL), rchild(NULL) { }
	Type data;
	bTreeNode* lchild;
	bTreeNode* rchild;
};

// bTree.h
#include "bTreeNode.h"
template <class Type> class bTree {
public:
	bTree() // constructor for first root input node,
	{       // when left/right child is empty input child node
	        // data '#'
		root = new bTreeNode<Type>;
		PreOrderCreate(root);
	}
	bTree(Type* q, int n)
	{
		root = new bTreeNode<Type>;
		LeverCreate(root, q, 0, n);
	}
	void PrintPreOrder() // print preorder
	{
		PreOrder(root);
		std::cout << std::endl;
	}
	void PrintInOrder() // print inorder
	{
		InOrder(root);
		std::cout << std::endl;
	}
	void PrintPostOrder() // print postorder
	{
		PostOrder(root);
		std::cout << std::endl;
	}
private:
	void PreOrderCreate(bTreeNode<Type>* p) // create tree preorder
	{
		std::cin >> p->data;
		if ('#' != p->data)
		{
			p->lchild = new bTreeNode<Type>;
			p->rchild = new bTreeNode<Type>;
			PreOrderCreate(p->lchild);
			if ('#' == p->lchild->data)
			{
				delete p->lchild;
				p->lchild = NULL;
			}
			PreOrderCreate(p->rchild);
			if ('#' == p->rchild->data)
			{
				delete p->rchild;
				p->rchild = NULL;
			}
		}
		else
		{
		}
	}
	void LeverCreate(bTreeNode<Type>* p, Type* q, int i, int n)
	{
		if ('#' != q[i] && i < n)
		{
			p->data = q[i];
			p->lchild = new bTreeNode<Type>;
			p->rchild = new bTreeNode<Type>;
			LeverCreate(p->lchild, q, 2 * i + 1, n);
			if ('/0' == p->lchild->data)
			{
				delete p->lchild;
				p->lchild = NULL;
			}
			LeverCreate(p->rchild, q, 2 * i + 2, n);
			if ('/0' == p->rchild->data)
			{
				delete p->rchild;
				p->rchild = NULL;
			}
		}
	}
	void PreOrder(bTreeNode<Type>* p) // first root print
	{
		if (NULL != p)
		{
			std::cout << p->data << " ";
			PreOrder(p->lchild);
			PreOrder(p->rchild);
		}
	}
	void InOrder(bTreeNode<Type>* p) // middle root print
	{
		if (NULL != p)
		{
			InOrder(p->lchild);
			std::cout << p->data << " ";
			InOrder(p->rchild);
		}
	}
	void PostOrder(bTreeNode<Type>* p) // post-root print
	{
		if (NULL != p)
		{
			PostOrder(p->lchild);
			PostOrder(p->rchild);
			std::cout << p->data << " ";
		}
	}
private:
	bTreeNode<Type>* root;
};

// main.cpp
#include "bTree.h"
int main()
{
	// the below three trees is one tree
	// '#' means a node has no left/right child
	// one lever array store.
	char* cc = "abcdeg###f##h";
	bTree<char> a(cc, 13);
	a.PrintPreOrder();
	a.PrintInOrder();
	a.PrintPostOrder();
	// first root
	// enter abd##ef###cg#h###
	bTree<char> b;
	b.PrintPreOrder();
	b.PrintInOrder();
	b.PrintPostOrder();
	// '#' asc code is equal to 35
	// a  b  d   #  #  e   f   #  #  #  c  g   #  h   #  #  #
	// 97 98 100 35 35 101 102 35 35 35 99 103 35 104 35 35 35
	bTree<int> c;
	c.PrintPreOrder();
	c.PrintInOrder();
	c.PrintPostOrder();
	return 0;
}