基于任务分析的非递归遍历二叉树

#include<stdio.h>
#include<stdlib.h>

typedef char ElemType;
typedef char DataType;

//二叉链表存储结构
typedef struct BiTNode
{
	DataType data;
	struct BiTNode *lchild;
	struct BiTNode *rchild;
}BiTNode,*BiTree; //BiTNode为结点类型，BiTree为指向二叉链表结点的指针类型

//栈的数据类型
typedef struct
{
	BiTree ptr;   //指向根节点的指针
	int task;     //任务性质，1表示遍历，0表示访问
}SElemType;

//顺序栈的存储结构

typedef struct stack
{
	SElemType *data;
	int top;		 //指示栈顶的位置
	int stackSize;	//栈的容量
}SqStack;

//1.栈的初始化
int initStack(SqStack *S,int max)
{
	S->data=(SElemType *)malloc(max*sizeof(SElemType));
	if(!S->data){printf("空间申请失败!");exit(0);}
	S->top=-1;
	S->stackSize=max;
	return 1;
}

//2.判断栈空
int StackEmpty(SqStack S)
{
	if(S.top==-1) return 1; //栈空返回1
	else return 0;  
}

//5.进栈
int Push(SqStack *S,SElemType e)
{
	if(S->stackSize==S->top+1) return 0;
	S->top++;
	S->data[S->top]=e;
	return 1;
}

//6.出栈
int Pop(SqStack *S,SElemType *e)
{
	if(S->top==-1) return 0;
	*e=S->data[S->top];
	S->top--;
	return 1;
}

//DLR
void preorder(BiTree T)
{
	SqStack S;
	BiTree p;
	SElemType e;
	initStack(&S,100);
	e.ptr=T;e.task=1;
	if(T)
	{Push(&S,e);}  //有根结点布置初始任务
	while(!StackEmpty(S))
	{
		Pop(&S,&e);				//每次处理一项任务
		if(e.task==0)printf("%c",e.ptr->data); //如果e.task==1，永远只会打印根结点
		else
		{
			e.task=0;
			Push(&S,e);          //访问根结点
			p=e.ptr;
			e.ptr=p->lchild;
			e.task=1;
			if(e.ptr)
			{Push(&S,e);}         //遍历左子树	
			e.ptr=p->rchild;
			if(e.ptr)  
			{Push(&S,e);}        //遍历右子树
		}
	}
}

//LDR
void inorder(BiTree T)
{
	SqStack S;
	BiTree p;
	SElemType e;
	initStack(&S,100);
	e.ptr=T;e.task=1;
	if(T)
	{Push(&S,e);}  //有根结点布置初始任务
	while(!StackEmpty(S))
	{
		Pop(&S,&e);				//每次处理一项任务
		if(e.task==0)printf("%c",e.ptr->data); //如果e.task==1，永远只会打印根结点
		else
		{
			p=e.ptr;
			e.ptr=p->rchild;
			if(e.ptr)
			{Push(&S,e);}         //遍历左子树
			e.ptr=p;
			e.task=0;
			Push(&S,e);          //访问根结点
			e.ptr=p->lchild;
			e.task=1;
			if(e.ptr)  
			{Push(&S,e);}        //遍历右子树
		}
	}
}

//LRD
void postorder(BiTree T)
{
	SqStack S;
	BiTree p;
	SElemType e;
	initStack(&S,100);
	e.ptr=T;e.task=1;
	if(T)
	{Push(&S,e);}  //有根结点布置初始任务
	while(!StackEmpty(S))
	{
		Pop(&S,&e);				//每次处理一项任务
		if(e.task==0)printf("%c",e.ptr->data); //如果e.task==1，永远只会打印根结点
		else
		{
			p=e.ptr;
			e.ptr=p->lchild;
			if(e.ptr)
			{Push(&S,e);}         //遍历左子树
			e.ptr=p->rchild;
			if(e.ptr)  
			{Push(&S,e);}        //遍历右子树
			e.ptr=p;
			e.task=0;
			Push(&S,e);          //访问根结点
		}
	}
}

void main()
{
	BiTree T=(BiTree)malloc(sizeof(BiTNode));
	//初始化一个二叉树，其根节点是A,没有左右孩子
	T->data='A';
	T->lchild=NULL;
	T->rchild=NULL;
	inorder(T);
	printf("\n");

	T->lchild=(BiTree)malloc(sizeof(BiTNode));
	T->lchild->data='B';
	T->lchild->lchild=NULL;
	T->lchild->rchild=NULL;

	T->rchild=(BiTree)malloc(sizeof(BiTNode));
	T->rchild->data='C';
	T->rchild->lchild=NULL;
	T->rchild->rchild=NULL;
	inorder(T);
	printf("\n");

	T->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
	T->lchild->lchild->data='D';
	T->lchild->lchild->lchild=NULL;
	T->lchild->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));
	T->lchild->lchild->rchild->data='G';
	T->lchild->lchild->rchild->lchild=NULL;
	T->lchild->lchild->rchild->rchild=NULL;

	T->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
	T->rchild->lchild->data='E';
	T->rchild->lchild->lchild=NULL;
	T->rchild->lchild->rchild=NULL;
	T->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
	T->rchild->rchild->data='F';
	T->rchild->rchild->lchild=NULL;
	T->rchild->rchild->rchild=NULL;
	printf("先序遍历:");
	preorder(T);
	printf("\n");
	printf("中序遍历:");	
	inorder(T);
	printf("\n");
	printf("后序遍历:");
	postorder(T);
	printf("\n");
}

运行结果

中序遍历是教材上给的，与实际情况吻合，先序遍历和后续遍历是自己改动的，运行结果与实际情况相反，先序遍历本该是ABDGCEF