二叉树遍历

前序遍历，中序遍历，后序遍历的递归和非递归实现（堆栈）：

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

/*************定义数据结构************/
typedef struct TreeNode {
	int data;
	struct TreeNode *lchild;
	struct TreeNode *rchild;
	int Count;
}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 Stack_preorder_traversal(Stack S,BinTree Tree) {  //先序非递归实现
	BinTree T = Tree;
	while(T || !(S -> Top ==  -1)) {
		if(T) {
			printf("%d ",T -> data);
			Push(S,*T);
			T = T -> lchild;
		}
		else {
			T = Pop(S);
			T = T -> rchild;			
		}		
	}	
}

void Inorder_traversal(BinTree Tree) {  //中序递归实现
	if(Tree) {
		Inorder_traversal(Tree -> lchild);
		printf("%d ",Tree -> data);
		Inorder_traversal(Tree -> rchild);
	}
}

void Stack_Inorder_traversal(Stack S,BinTree Tree) {  //中序非递归实现
	BinTree T = Tree;
	while(T || !(S -> Top ==  -1)) {
		if(T) {
			Push(S,*T);
			T = T -> lchild;
		}
		else {
			T = Pop(S);
			printf("%d ",T -> data);
			T = T -> rchild;			
		}		
	}	
}

void Postorder_traversal(BinTree Tree) {  //后序递归实现
	if(Tree) {
		Postorder_traversal(Tree -> lchild);
		Postorder_traversal(Tree -> rchild);
		printf("%d ",Tree -> data);
	}
}

void Stack_Postorder_traversal(Stack S,BinTree Tree) {  //后序非递归实现
	BinTree T = Tree;
	while(T || !(S -> Top ==  -1)) {
		if(T) {
			T -> Count = 1;
			Push(S,*T);
			T = T -> lchild;
		}
		else {
			T = Pop(S);
			if(T -> Count == 1) {
				Push(S,*T);
				T -> Count = 2;
				T = T -> rchild;
			}
			else {
				printf("%d ",T -> data);
				T = NULL;
			}						
		}		
	}	
}

/**************************主函数***************************/
int main()
{
	int MaxSize = 50;
	BinTree Tree = NULL;
    Stack S = CreatStack(MaxSize);
    Tree = CreatTree(Tree);//ABC##DE#G##F###  1 2 3 0 0 4 5 0 6 0 0 7 0 0 0
    printf("递归先序遍历结果:\n");
    Preorder_traversal(Tree);
    printf("\n非递归先序遍历结果:\n");
    Stack_preorder_traversal(S,Tree);
    printf("\n递归中序遍历结果:\n");
    Inorder_traversal(Tree);
    printf("\n非递归中序遍历结果:\n");
    Stack_Inorder_traversal(S,Tree);
    printf("\n递归后序遍历结果:\n");
    Postorder_traversal(Tree);
    printf("\n非递归后序遍历结果:\n");
    Stack_Postorder_traversal(S,Tree);
    return 0;
}

 

层次遍历（队列）：

/* Note:Your choice is C IDE */
#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);
	}
	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; 
 	Q = CreatQueue();
 	if(Tree) {
 		AddQ(Q,*Tree);
 		while(!(Q -> front == Q -> rear)) {
 			Tree = DeleteQ(Q);
 			printf("%d ",Tree -> data);
 			if(Tree -> lchild) AddQ(Q,*Tree -> lchild);
 			if(Tree -> rchild) AddQ(Q,*Tree -> rchild);
 		}	
 	}
}

/**************************主函数***************************/
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");
    Preorder_traversal(Tree);
    printf("\n层次遍历结果:\n");
    Levelorder_traversal(Tree);
    return 0;
}