二叉树层次遍历（单层输出）

每一层都是从左到右，但是每一层输出结束要换行（使用队列）

#include "stdio.h"
#include "stdlib.h"

#define MaxSize 50
/*************定义数据结构************/
typedef struct TreeNode {
	int data;
	struct TreeNode *lchild;
	struct TreeNode *rchild;
}BinTreeNode,*BinTree;

typedef struct QNode {
	BinTree data;
	int front;
	int rear;
}QueueNode,*Queue;

/*************************定义队列部分************************/
Queue CreatQueue(void) {
	Queue Q = (Queue)malloc(MaxSize*sizeof(QueueNode)); 
	Q -> data = (BinTree)malloc(MaxSize*sizeof(BinTreeNode));
	Q -> front = 0;
	Q -> rear = 0;
	return Q;
}

void AddQ(Queue PtrQ,BinTreeNode B) {
	if((PtrQ -> rear + 1) % MaxSize == PtrQ -> front) {
		printf("队列满");
		return;		
	}
	PtrQ -> rear = (PtrQ -> rear + 1) % MaxSize;
	PtrQ -> data[PtrQ -> rear] = B;
}

BinTree DeleteQ(Queue PtrQ) {
	if(PtrQ -> front == PtrQ -> rear) {
		printf("队列空");
		return NULL;	
	}	
	else {
		PtrQ -> front = (PtrQ -> front + 1) % MaxSize;	
		return 	&(PtrQ -> data[PtrQ -> front]);
	}	
}

/*************************定义树部分************************/
BinTree CreatTree(BinTree Tree) {
	int temp = 0;
	scanf("%d",&temp);
	if(temp == 0) 
		Tree = NULL;
	else {
		Tree = (BinTree)malloc(sizeof(BinTreeNode));
		Tree -> data = temp;
		Tree -> lchild = CreatTree(Tree -> lchild);
		Tree -> rchild = CreatTree(Tree -> rchild);
		//Tree -> Count = 0;
	}
	return Tree;
}

/**************************树的遍历***************************/
void Preorder_traversal(BinTree Tree) {  //先序递归实现
	if(Tree) {
		printf("%d ",Tree -> data);
		Preorder_traversal(Tree -> lchild);
		Preorder_traversal(Tree -> rchild);
	}
}

void Levelorder_traversal(BinTree Tree) {  //层次遍历
	Queue Q = NULL; 
	int temp = Tree -> data, ntemp = Tree -> data;
 	Q = CreatQueue();
 	if(Tree) {
 		AddQ(Q,*Tree);
 		while(!(Q -> front == Q -> rear)) {
 			Tree = DeleteQ(Q);
 			if(Tree -> lchild) { AddQ(Q,*Tree -> lchild);  ntemp = Tree -> lchild -> data;}
 			if(Tree -> rchild) { AddQ(Q,*Tree -> rchild);  ntemp = Tree -> rchild -> data;}
 			if(Tree -> data == temp) {
 				temp = ntemp;
 				printf("%d\n",Tree -> data);
 			}
 			else
 				printf("%d ",Tree -> data);
 		}	
 	}
}

/**************************主函数***************************/
int main()
{
    BinTree Tree = NULL;
    Tree = CreatTree(Tree);//ABC##DE#G##F###  1 2 3 0 0 4 5 0 6 0 0 7 0 0 0
    printf("递归先序遍历结果:\n"); //1 2 4 7 0 0 8 0 0 0 3 5 9 0 0 0 6 0 10 0 0 
    Preorder_traversal(Tree);
    printf("\n层次遍历结果:\n");
    Levelorder_traversal(Tree);
    return 0;
}

在上面基础上要求相邻层反向输出（使用二个栈）

#include "stdio.h"
#include "stdlib.h"

/*************定义数据结构************/
typedef struct TreeNode {
	int data;
	struct TreeNode *lchild;
	struct TreeNode *rchild;
}BinTreeNode,*BinTree;

typedef struct StackNode {
	BinTree data;
	int Top;
	int MaxSize;
}StackNode,*Stack;

/*************************定义堆栈部分************************/
Stack CreatStack(int MaxSize) {
	Stack S = (Stack)malloc(MaxSize*sizeof(StackNode));
	S -> data = (BinTree)malloc(MaxSize*sizeof(BinTreeNode));
	S -> Top = -1;
	S -> MaxSize = MaxSize;
	return S;
}

void Push(Stack Temp,BinTreeNode B) {
	if(Temp -> Top == Temp -> MaxSize - 1) {
		printf("堆栈满");
		return;	
	}
	else {
		Temp -> data[++(Temp -> Top)] = B;
		return;
	}
}

BinTree Pop(Stack Temp) {
	if(Temp -> Top ==  -1) {
		printf("堆栈空");
		return NULL;	
	}
	else {
		return	&(Temp -> data[(Temp -> Top)--]);	
	}
}

/*************************定义树部分************************/
BinTree CreatTree(BinTree Tree) {
	int temp = 0;
	scanf("%d",&temp);
	if(temp == 0) 
		Tree = NULL;
	else {
		Tree = (BinTree)malloc(sizeof(BinTreeNode));
		Tree -> data = temp;
		Tree -> lchild = CreatTree(Tree -> lchild);
		Tree -> rchild = CreatTree(Tree -> rchild);
		//Tree -> Count = 0;
	}
	return Tree;
}

/**************************树的遍历***************************/
void Preorder_traversal(BinTree Tree) {  //先序递归实现
	if(Tree) {
		printf("%d ",Tree -> data);
		Preorder_traversal(Tree -> lchild);
		Preorder_traversal(Tree -> rchild);
	}
}

void Levelorder_traversal(BinTree Tree) {  //层次遍历
	Stack S1 = CreatStack(50);  
	Stack S2 = CreatStack(50);
	Stack S3 = CreatStack(50);  
	int flag = 0;
	BinTree T = NULL;
	Push(S1,*Tree);
 	while(!(S1 -> Top ==  -1)) {
 			T = Pop(S1);
 			printf("%d ",T -> data);
  			if(flag == 0) {
 				if(T -> lchild) Push(S2,*(T -> lchild));
 				if(T -> rchild) Push(S2,*(T -> rchild));
 			}
  			else if(flag == 1) {
 				if(T -> rchild) Push(S2,*(T -> rchild));
 				if(T -> lchild) Push(S2,*(T -> lchild));
  			} 			
  			if(S1 -> Top ==  -1) {
				flag = 1 - flag;
				S3 = S1; 
				S1 = S2;
				S2 = S3;
				printf("\n");
 			}
 		}	
} 

/**************************主函数***************************/
int main()
{
    BinTree Tree = NULL;
    Tree = CreatTree(Tree);//ABC##DE#G##F###  1 2 3 0 0 4 5 0 6 0 0 7 0 0 0
    printf("递归先序遍历结果:\n"); //1 2 4 7 0 0 8 0 0 0 3 5 9 0 0 0 6 0 10 0 0 
    Preorder_traversal(Tree);
    printf("\n层次遍历结果:\n");
    Levelorder_traversal(Tree);
    return 0;
}