二叉树的遍历的应用

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MAXSIZE 100
typedef char ElemType;
typedef struct Node
{
ElemType data;
struct Node *lchild;
struct Node *rchild;
}*BitTree,BitNode;
/*二叉树的基本操作*/
void InitBitTree(BitTree *T);//二叉树的初始化操作
void DestroyBitTree(BitTree *T);//销毁二叉树
void CreateBitTree(BitTree *T);//递归创建二叉树
void CreateBitTree2(BitTree *T,char str[]);//非递归创建二叉树
int InsertLeftChild(BitTree p,BitTree c);//二叉树的左插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的左子树，使p所指结点的左子树成为c的右子树
int InsertRightChild(BitTree p,BitTree c);//二叉树的右插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的右子树，使p所指结点的右子树成为c的右子树
BitTree Point(BitTree T,ElemType e);//返回二叉树结点的指针操作
ElemType LeftChild(BitTree T,ElemType e);//返回二叉树的结点的左孩子元素值操作
ElemType RightChild(BitTree T,ElemType e);//返回二叉树的结点的右孩子元素值操作
int DeleteLeftChild(BitTree p);//二叉树的左删除操作
int DeleteRightChild(BitTree p);//二叉树的右删除操作
void PreOrderTraverse(BitTree T);//先序遍历二叉树的递归实现
void InOrderTraverse(BitTree T);//中序遍历二叉树的递归实现
void PostOrderTraverse(BitTree T);//后序遍历二叉树的递归实现
void PostOrderTraverse2(BitTree T);//后序遍历二叉树的非递归实现
void PreOrderTraverse2(BitTree T);//先序遍历二叉树的非递归实现
void InOrderTraverse2(BitTree T);//中序遍历二叉树的非递归实现

#include "LinkBiTree.h"
void InitBitTree(BitTree *T)//二叉树的初始化操作
{
*T = NULL;
}
void DestroyBitTree(BitTree *T)//销毁二叉树
{
if(*T)
{
if((*T)->lchild)
{
DestroyBitTree(&((*T)->lchild));
}
if((*T)->rchild)
{
DestroyBitTree(&((*T)->rchild));
}
free(*T);
*T = NULL;
}
}
void CreateBitTree(BitTree *T)//递归创建二叉树
{
ElemType ch;
scanf("%c",&ch);
if(ch == '#')
{
*T = NULL;
}
else
{
*T = (BitTree)malloc(sizeof(BitNode));
if(!(*T))
{
exit(-1);
}
else
{
(*T)->data = ch;
CreateBitTree(&((*T)->lchild));
CreateBitTree(&((*T)->rchild));
}
}
}
void CreateBitTree2(BitTree *T,char str[])//递归创建二叉树
{
char ch;
BitTree stack[MAXSIZE];
int top = -1;
int flag,k;
BitNode *p;
*T = NULL,k = 0;
ch = str[k];
while(ch != '\0')
{
switch(ch)
{
case '(':
stack[++top] = p;
flag = 1;
break;
case ')':
top--;
break;
case ',':
flag = 2;
break;
default:
p = (BitTree)malloc(sizeof(BitNode));
p->data = ch;
p->lchild = NULL;
p->rchild = NULL;
if(*T == NULL)
{
*T = p;
}
else
{
switch(flag)
{
case 1:
stack[top]->lchild = p;
break;
case 2:
stack[top]->rchild = p;
break;
}
}
}
ch = str[++k];
}
}
int InsertLeftChild(BitTree p,BitTree c)//二叉树的左插入操作
{
if(p)
{
c->rchild = p->lchild;
p->lchild = c;
return 1;
}
return 0;
}
int InsertRightChild(BitTree p,BitTree c)//二叉树的右插入操作
{
if(p)
{
c->rchild = p->rchild ;
p->rchild = c;
return 1;
}
return 0;
}
BitTree Point(BitTree T,ElemType e)//返回二叉树结点的指针操作
{
BitTree Q[MAXSIZE];
int front = 0,rear = 0;
BitNode *p;
if(T)
{
Q[rear] = T;
rear++;
while(front != rear)
{
p = Q[front];
front++;
if(p->data == e)
{
return p;
}
if(p->lchild)
{
Q[rear] = p->lchild ;
rear++;
}
if(p->rchild)
{
Q[rear] = p->rchild ;
rear++;
}
}
}
return NULL;
}
ElemType LeftChild(BitTree T,ElemType e)//返回二叉树的结点的左孩子元素值操作
{
BitTree p;
if(T)
{
p = Point(T,e);
if(p && p->lchild)
{
return p->lchild->data;
}
}
exit(-1);
}
ElemType RightChild(BitTree T,ElemType e)//返回二叉树的结点的右孩子元素值操作
{
BitTree p;
if(T)
{
p = Point(T,e);
if(p && p->rchild)
{
return p->rchild->data;
}
}
exit(-1);
}
int DeleteLeftChild(BitTree p)//二叉树的左删除操作
{
if(p)
{
DestroyBitTree(&(p->lchild));
return 1;
}
return 0;
}
int DeleteRightChild(BitTree p)//二叉树的右删除操作
{
if(p)
{
DestroyBitTree(&(p->rchild));
return 1;
}
return 0;
}
void PreOrderTraverse(BitTree T)//先序遍历二叉树的递归实现
{
if(T)
{
printf("%2c",T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void InOrderTraverse(BitTree T)//中序遍历二叉树的递归实现
{
if(T)
{
InOrderTraverse(T->lchild);
printf("%2c",T->data);
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BitTree T)//后序遍历二叉树的递归实现
{
if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%2c",T->data);
}
}
void PreOrderTraverse2(BitTree T)//后序遍历二叉树的非递归实现
{
BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
int top;//定义栈顶指针
BitNode *p;//定义一个结点指针
top = 0;//初始化栈
p = T;
while(p != NULL || top > 0)
{
while(p != NULL)//如果栈不空访问根结点，遍历左子树
{
printf("%2c",p->data);//访问根结点
stack[top++] = p;//将p入栈
p = p->lchild ;//遍历左子树
}
if(top > 0)//如果栈不空
{
p = stack[--top];//栈顶元素出栈
p = p->rchild ;//遍历右子树
}
}
}
void InOrderTraverse2(BitTree T)//先序遍历二叉树的非递归实现
{
BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
int top;//定义栈顶指针
BitNode *p;//定义结点指针
top = 0;//初始化栈
p = T;
while(p != NULL || top > 0)
{
while(p != NULL)//如果栈不空访问根结点，遍历左子树
{
stack[top++] = p;//将p入栈
p = p->lchild ;//遍历左子树
}
if(top > 0)//如果栈不空
{
p = stack[--top];//栈顶元素出栈
printf("%2c",p->data);//访问根结点
p = p->rchild ;//遍历右子树
}
}
}
void PostOrderTraverse2(BitTree T)//中序遍历二叉树的非递归实现
{
BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
int top;//定义栈顶指针
BitNode *p,*q;//定义一个结点指针
top = 0;//初始化栈
p = T;
q = NULL;
while(p != NULL || top > 0)
{
while(p != NULL)//如果栈不空访问根结点，遍历左子树
{
stack[top++] = p;//将p入栈
p = p->lchild ;//遍历左子树
}
if(top > 0)//如果栈不空
{
p = stack[top-1];//栈顶元素出栈
if(p->rchild == NULL || p->rchild == q)
{
printf("%2c",p->data);//访问根结点
q = p;
p = NULL;
top--;
}
else
{
p = p->rchild ;//遍历右子树
}
}
}
}

#include "LinkBiTree.h"

int main(void)
{
BitTree T,root;
InitBitTree(&T);
printf("根据输入二叉树的先序序列创建二叉树（‘#’表示结束）：\n");
CreateBitTree(&T);
printf("二叉树的先序序列：\n");
printf("递归：");
PreOrderTraverse(T);
printf("\n");
printf("非递归：");
PreOrderTraverse2(T);
printf("\n");
printf("二叉树的中序序列：\n");
printf("递归：");
InOrderTraverse(T);
printf("\n");
printf("非递归：");
InOrderTraverse2(T);
printf("\n");
printf("二叉树的后序序列：\n");
printf("递归：");
PostOrderTraverse(T);
printf("\n");
printf("非递归：");
PostOrderTraverse2(T);
printf("\n");
printf("根据括号嵌套的字符串建立二叉树：\n");
CreateBitTree2(&root,"(a(b(c,d),e(f,(,g),h(i))))");
printf("二叉树的先序序列：\n");
PreOrderTraverse(root);
printf("\n");
printf("二叉树的中序序列：\n");
InOrderTraverse(root);
printf("\n");
printf("二叉树的后序序列：\n");
PostOrderTraverse(root);
printf("\n");
DestroyBitTree(&T);
DestroyBitTree(&root);
return 0;
}