二叉树的前序，中序，后序，层序遍历

二叉树见下图，打印的顺序是：A，B，C，D，E，F，G，H，I；先要打印根节点，之后打印第二层从左到右,依次类推。根据队列先进先出的特点，就用队列来存储每个结点。。
1、取出数中的第一个结点，压入队列中，并且打印，同时将该节点的左右节点（不为空的节点，空节点不用插入）依次压入队列中，则此时队列中有：B，C两个节点。

2.、然后继续步骤1.取出节点B，并插入B的左右子节点D，E，此时队列：C，D，E；

3、然后继续步骤1.取出节点C，并插入2的左右子节点F，此时队列：D，E，F；以此循环直至队列为空才停止；（如果没有结点，直接跳过）
我还写了三种遍历,第一次写，就。。。。比较简单，就练练手

#include<stdio.h>
#include<malloc.h>

//树的结点
typedef struct BiTree
{
	char data;
	struct BiTree* lchild, *rchild;
}Bitree;

//统计树的结点的个数
static int n=0;

//队列的结点
typedef struct Node
{
	BiTree* data;//队列中存储的树的结点
	Node* next;
}Node;

//表示队列
typedef struct NodeQueue
{
	Node* tail;//队列的头结点
	Node* head;//队列的尾结点
}NodeQueue;
//先序遍历
void PreorderTraversal(struct BiTree** T)
{
	if ((*T != NULL))
	{
		printf("%c,", (*T)->data);
		PreorderTraversal(&(*T)->lchild);
		PreorderTraversal(&(*T)->rchild);
		printf("\b;");
	}
	else
	{
		printf("#,");
	}
}

//中序遍历
void MidsequenceTraversal(struct BiTree** T)
{
	if ((*T != NULL))
	{
		MidsequenceTraversal(&(*T)->lchild);
		printf("%c,", (*T)->data);
		MidsequenceTraversal(&(*T)->rchild);
		printf("\b;");
	}
	else
	{
		printf("#,");
	}
}

//后序遍历
void PostorderTraversal(struct BiTree** T)
{
	if ((*T != NULL))
	{
		
		PostorderTraversal(&(*T)->lchild);
		PostorderTraversal(&(*T)->rchild);
		printf("%c,", (*T)->data);
		printf("\b;");
	}
	else
	{
		printf("#,");
	}
}

//创造树
void CreateBiTree(struct BiTree** T)
{
	char ch;
	scanf("%c", &ch);


	if (ch == '#')
	{
		(*T) = NULL;
	}
	else
	{
		(*T) = (Bitree*)malloc(sizeof(Bitree));
		(*T)->data = ch;	n++;
		CreateBiTree(&(*T)->lchild);
		CreateBiTree(&(*T)->rchild);
	}
}

//入队操作
bool LInkQueue_in(Node** tail, Bitree** T)
{
	if ((*T) == NULL)
	{
		return false;
	}
	else
	{
		Node* s = (Node*)malloc(sizeof(Node));//队列
		s->data = (*T);
		(*tail)->next = s;
		(*tail) = s;
		return true;
	}
}

//出队操作
bool LInkQueue_out(Node** head)
{
	printf("%c,", (*head)->data->data);

	(*head) = (*head)->next;

	return true;
}

//层序遍历
void SequenceTraversal(struct BiTree** T)
{
	NodeQueue* L = (NodeQueue*)malloc(sizeof(NodeQueue));//队列中的结点 
	Node* N = (Node*)malloc(sizeof(Node));//队列
	BiTree** _T = T;

	N->data = (*_T);

	L->head = N;
	L->tail = N;

	while (n--)
	{
		LInkQueue_in(&(L->tail), &(*_T)->lchild);//_T的左结点入队
		LInkQueue_in(&(L->tail), &(*_T)->rchild);//_T的右结点入队
		LInkQueue_out(&(L->head));//将队列的头结点打印并出队
		if (n)
		{
			(*_T) = L->head->data;
		}
	}
	printf("\b;\n");
}

int main()
{
	BiTree* T;
	Node* head;
	head = (Node*)malloc(sizeof(Node));
	head->data = NULL;
	head->next = NULL;

	CreateBiTree(&T);
	PreorderTraversal(&T);
	printf("\n");
	MidsequenceTraversal(&T);
	printf("\n");
	PostorderTraversal(&T);
	printf("\n");
	//CreateQueue(&T, &head,&Q);
	SequenceTraversal(&T);
	printf("\n");
	return 0;
}
//ABDG###E#H##C#FI###

typedef struct TreeNode
{
	char value;
	TreeNode* m_pLeft;
	TreeNode* m_pRight;
}TreeNode;

TreeNode* CreateTree(TreeNode* pNode)
{
	char ch;
	cin >> ch;

	if (ch == '$')
	{
		pNode = NULL;
	}
	else
	{
		pNode = new (TreeNode);
		pNode->value = ch;
		pNode->m_pLeft = CreateTree(pNode->m_pLeft);
		pNode->m_pRight = CreateTree(pNode->m_pRight);
	}
	return pNode;
}

void Treequenue(TreeNode* pNode)
{
	if (pNode == NULL)
	{
		return;
	}
	queue<TreeNode*> q;

	q.push(pNode);

	while (!q.empty())
	{
		cout<<q.front()->value;
		if (q.front()->m_pLeft != NULL)
		{
			q.push(q.front()->m_pLeft);
		}
		if (q.front()->m_pRight != NULL)
		{
			q.push(q.front()->m_pRight);
		}
		q.pop();
	}
	cout << endl;
}