二叉树的基本操作<1>-----四种遍历

//二叉树的操作实现
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef char TreeNodeType;
//二叉树结点结构体
typedef struct TreeNode{
TreeNodeType data;
struct TreeNode* lchild;
struct TreeNode* rchild;
}TreeNode;


//队列结构体
typedef struct queue{
int cur;
TreeNode arr[100];
int size;
}Queue;


//二叉树结点的创建
TreeNode* CreatTreeNode(TreeNodeType value){
TreeNode* new = (TreeNode*)malloc(sizeof(TreeNode));
new->data = value;
new->lchild = NULL;
new->rchild = NULL;
return new;
}


//二叉树的遍历
//方式一：先序遍历
//原理：基于二叉树的递归构造，其遍历也可以采取递归的方式，先序遍历<先访问本身结点，再访问左子树，
//最后访问右子树>
void PreOrder(TreeNode* root){
if(root == NULL){
//空树
return;
}
printf("%c ",root->data);
PreOrder(root->lchild);
PreOrder(root->rchild);
}


//先序遍历的检测函数
void textPreOrder(){
//创建二叉树
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
PreOrder(A);
printf("\n");
return;
}


//方式二；中序遍历
//原理：同先序遍历，只是访问顺序有所差异，中序遍历<先访问左子树，再访问本身结点，最后访问右子树>
void InOrder(TreeNode* root){
if(root == NULL){
//空树
return;
}
InOrder(root->lchild);
printf("%c ",root->data);
InOrder(root->rchild);
}


//中序遍历的检测函数
void textInOrder(){
//创建二叉树
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
InOrder(A);
printf("\n");
return;
}


//方式三：后序遍历
//原理：同先序遍历，只是访问顺序有所差异，后序遍历<先访问左子树，再访问右子树，最后访问本身结点>
void PostOrder(TreeNode* root){
if(root == NULL){
//空树
return;
}
PostOrder(root->lchild);
PostOrder(root->rchild);
printf("%c ",root->data);
}


//后序遍历的检测函数
void textPostOrder(){
//创建二叉树
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
PostOrder(A);
printf("\n");
return;
}


//方式四：层序遍历
//原理：层序遍历与以上几种遍历方式右所不同，先序遍历是将访问结点的左子树与右子树入队，再将本身结点
//出队并访问自身结点，以此循环，直到队列为空，访问结束。
//此遍历中将会用到队列函数，故在此处将先实现队列的出队与入队操作函数的实现


//队列的入队操作
void PushQueue(Queue* head,TreeNode* value){
if(head == NULL){
//非法输入
return;
}
if(head->size>=100){
//队满
return;
}
if(value == NULL){
return;
}
head->arr[(head->size+head->cur)%100] = (*value);
++head->size;
return;
}
//队列的出队操作
void PopQueue(Queue* head){
if(head == NULL){
//非法输入
return;
}
if(head->size == 0){
//空队
return;
}
++head->cur;
--head->size;
return;
}
//获得队列的队首元素
void QueueTop(Queue*head,TreeNode* value){
if(head == NULL){
//非法输入
return;
}
if(head->size == 0){
//空队
return;
}
(*value) = head->arr[head->cur%100];
   return;
}
//层序遍历的实现
void _levelOrder(Queue* que){
TreeNode value;
if(que == NULL){
//非法输入
return;
}
while(1){
if(que->size == 0){
//空队
return;
}
QueueTop(que,&value);
printf("%c ",value.data);
PushQueue(que,value.lchild);
PushQueue(que,value.rchild);
PopQueue(que);
}
}


void levelOrder(TreeNode* root){
if(root == NULL){
//空树
return;
}
Queue que = {
0,
{0},
0
};
PushQueue(&que,root);
_levelOrder(&que);

}