//二叉树的操作实现
#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);
}
#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);
}