C语言 二叉树的遍历 递归和(多种)非递归算法

原创 2012年05月31日 20:18:08
//二叉树遍历
//作者:nuaazdh
//时间:2011年12月1日

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

#define OK          1
#define ERROR       0
#define TRUE        1
#define FALSE       0
#define OVERFLOW    -1

#define STACK_INIT_SIZE     100
#define STACKINCREMENT      10

typedef int Status;
typedef char ElemType;  // 二叉树结点元素类型
typedef struct BiTNode{ // 二叉树结点结构
	char data;            // 结点数据
	struct BiTNode *lchild;        // 左孩子
	struct BiTNode *rchild;        // 右孩子
}BiTNode,*BiTree;

typedef BiTree SElemType;
typedef struct{//栈结构定义
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

Status InitStack(SqStack *S);
//构造一个空栈S
Status DestroyStack(SqStack *S);
//销毁栈S,S不再存在
Status ClearStack(SqStack *S);
//把栈S置为空栈
Status StackEmpty(SqStack S);
//若栈S为空栈,则返回TRUE,否则返回FALSE
int StackLength(SqStack S);
//返回S元素的个数,即栈的长度
Status GetTop(SqStack S,SElemType *e);
//若栈不为空,则用e返回S的栈顶元素,并返回OK;否则返回FALSE
Status Push(SqStack *S,SElemType e);
//插入元素e为新的栈顶元素
Status Pop(SqStack *S,SElemType *e);
//若栈S不为空,则删除S的栈顶元素,用e返回其值,并返回OK,否则返回ERROR
Status StackTraverse(const SqStack *S);
//从栈底到栈顶依次对每个元素进行访问

BiTree CreateBiTree(BiTree T);
// 按先后次序输入二叉树中结点的值(一个字符),空格表示空树
// 构造二叉链表表示的二叉树T
Status PreOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 先序遍历二叉树T的递归算法,对每个数据元素调用函数Visit
Status InOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 中序遍历二叉树T的递归算法,对每个数据元素调用函数Visit
Status PostOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 后序遍历二叉树T的递归算法,对每个数据元素调用函数Visit
Status PreOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 先序遍历二叉树T的非递归算法,对每个数据元素调用函数Visit
Status InOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 中序遍历二叉树T的非递归算法,对每个数据元素调用函数Visit
Status PostOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e));
// 采用二叉链表存储结结构,Visit是对数据元素操作的应用函数
// 后序遍历二叉树T的非递归算法,对每个数据元素调用函数Visit
Status Visit(ElemType e);
// 对二叉树中的数据元素访问

int main()
{
	BiTree T=NULL;
	Status(*visit)(ElemType e)=Visit;
	printf("请按先序遍历输入二叉树元素(每个结点一个字符,空结点为'#'):\n");
	T=CreateBiTree(T);
	printf("\n递归先序遍历:\n");
	PreOrderRecursionTraverse(T,visit);
	printf("\n递归中序遍历:\n");
	InOrderRecursionTraverse(T,visit);
	printf("\n递归后序遍历:\n");
	PostOrderRecursionTraverse(T,visit);
	printf("\n非递归先序遍历:\n");
	PreOrderNonRecursionTraverse(T,visit);
	printf("\n非递归中序遍历:\n");
	InOrderNonRecursionTraverse(T,visit);
	printf("\n非递归后序遍历:\n");
	PostOrderNonRecursionTraverse(T,visit);
	printf("\nEnd of main.\n");
	return 0;
}

BiTree CreateBiTree(BiTree T){
	// 按先后次序输入二叉树中结点的值(一个字符),空格表示空树
	// 构造二叉链表表示的二叉树T
	char ch;
	scanf("%c",&ch);
	if(ch=='#') T=NULL;
	else{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		T->data=ch;                 // 生成根节点
		T->lchild=CreateBiTree(T->lchild);    // 构造左子树
		T->rchild=CreateBiTree(T->rchild);    // 构造右子树
	}
	return T;
}

Status PreOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e))
{   // 先序遍历递归算法

	if(T){
		if(!Visit(T->data)) return ERROR;
		PreOrderRecursionTraverse(T->lchild,Visit);
		PreOrderRecursionTraverse(T->rchild,Visit);
	}
	return OK;
}

Status InOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e))
{   // 中序遍历递归算法
	if(T){
		InOrderRecursionTraverse(T->lchild,Visit);
		if(!Visit(T->data)) return ERROR;;
		InOrderRecursionTraverse(T->rchild,Visit);
	}
	return OK;
}


Status PostOrderRecursionTraverse(BiTree T,Status (*Visit)(ElemType e))
{   //后序遍历递归算法
	if(T){
		PostOrderRecursionTraverse(T->lchild,Visit);
		PostOrderRecursionTraverse(T->rchild,Visit);
		if(!Visit(T->data)) return ERROR;;
	}
	return OK;
}

Status PreOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e)){
	// 先序遍历二叉树T的非递归算法
	SqStack S;
	SElemType p;
	InitStack(&S);      Push(&S,T); // 根指针入栈
	while(!StackEmpty(S)){
		Pop(&S,&p);	//访问根节点
		if(!Visit(p->data)) return ERROR;
		if (p->rchild)
			Push(&S,p->rchild);
		if(p->lchild)
			Push(&S,p->lchild);
	}//while
	DestroyStack(&S);
	return OK;
}

/**算法一
Status InOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e)){
	// 中序遍历二叉树T的非递归算法
	SqStack S;
	SElemType p;
	InitStack(&S);      Push(&S,T); // 根指针入栈
	while(!StackEmpty(S)){
		while(GetTop(S,&p)&&p)   Push(&S,p->lchild);    //向左走到尽头
		Pop(&S,&p);     //空指针出栈
		if(!StackEmpty(S)){//访问结点,向右一步
			Pop(&S,&p);
			if(!Visit(p->data)) return ERROR;
			Push(&S,p->rchild);
		}//if
	}//while
	DestroyStack(&S);
	return OK;

}
*/

Status InOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e)){
	// 中序遍历二叉树T的非递归算法
	SqStack S;
	SElemType p;
	InitStack(&S);      p=T;
	while (p||!StackEmpty(S)){
		if (p){
			Push(&S,p);p=p->lchild;	//根指针进栈,遍历左子树
		}else{//根指针退栈,访问根节点,遍历右子树
			Pop(&S,&p);	if(!Visit(p->data))	return ERROR;
			p=p->rchild;
		}//else
	}//while
	DestroyStack(&S);
	return OK;

}
/**算法一
Status PostOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e)){
	// 后序遍历二叉树T的非递归算法
	SqStack S;
	SElemType p,q;
	InitStack(&S);      Push(&S,T); // 根指针入栈
	while(!StackEmpty(S)){
		while(GetTop(S,&p)&&p&&(p->lchild||p->rchild)){
				Push(&S,p->rchild);		// 右子树入栈
				Push(&S,p->lchild);		// 左子树入栈
		}//注意栈中存在空指针,表示某个结点的右子树为空
		if(!StackEmpty(S)){//访问结点
			Pop(&S,&p);
			if (p){
				if(!Visit(p->data)) return ERROR;
			}else{		// 存在右子树为空的结点,继续向上返回
				Pop(&S,&p);
				if(!Visit(p->data)) return ERROR;
			}			
			while (GetTop(S,&q)&&q&&p==q->rchild){//若当前为右子树,则继续出栈
				Pop(&S,&p);
				if(!Visit(p->data)) return ERROR;
				GetTop(S,&q);
			}
		}//if
	}//while
	DestroyStack(&S);
	return OK;
}
*/

/***算法二*/
Status PostOrderNonRecursionTraverse(BiTree T,Status (*Visit)(ElemType e)){
	// 后序遍历二叉树T的非递归算法
	SqStack S;
	SElemType p,q;
	InitStack(&S);      Push(&S,T); // 根指针入栈
	while(!StackEmpty(S)){
		while(GetTop(S,&p)&&p)   Push(&S,p->lchild);    //向左走到尽头
		Pop(&S,&p);     //空指针出栈
		GetTop(S,&p);
		if(p->rchild){
			Push(&S,p->rchild);
			continue;
		}
		if(!StackEmpty(S)){//访问结点,向右一步
			Pop(&S,&p);
			if(!Visit(p->data)) return ERROR;
			while (GetTop(S,&q)&&q&&p==q->rchild){//若当前为右子树,则继续出栈
				Pop(&S,&p);
				if(!Visit(p->data)) return ERROR;
			}
			GetTop(S,&p);
			if(p->rchild){
				Push(&S,p->rchild);
				continue;
			}else{
				Pop(&S,&p);
				if(!Visit(p->data)) return ERROR;
			}
		}//if
	}//while
	DestroyStack(&S);
	return OK;
}
Status Visit(ElemType e){
	// 对二叉树中的数据元素访问
	if(e=='\0'){
		return ERROR;
	}else{
		printf("%c",e);
	}
	return OK;
}

//-----------顺序栈操作--------------//

Status InitStack(SqStack *S){
	//构造一个空栈S
	S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!S->base)//分配失败
	{
		printf("分配内存失败.\n");
		exit(0);
	}
	S->top=S->base;
	S->stacksize=STACK_INIT_SIZE;
	return OK;
}

Status DestroyStack(SqStack *S){
	//销毁栈S,S不再存在
	if(!S)//S为空
	{
		printf("指针为空,释放失败.\n");
		exit(0);
	}
	free(S->base);
	return OK;
}

Status ClearStack(SqStack *S){
	//把栈S置为空栈
	if(!S)//S不存在
		return FALSE;
	S->top=S->base;//直接将栈顶指针指向栈底
	return OK;
}

Status StackEmpty(SqStack S){
	//若栈S为空栈,则返回TRUE,否则返回FALSE
	if(S.top==S.base)
		return TRUE;
	else
		return FALSE;
}

int StackLength(SqStack S){
	//返回S元素的个数,即栈的长度
	return S.stacksize;
}

Status GetTop(SqStack S,SElemType *e){
	//若栈不为空,则用e返回S的栈顶元素,并返回OK;否则返回FALSE
	if(S.top==S.base){
		return FALSE;
	}else{
		*e=*(S.top-1);
		return OK;
	}
}

Status Push(SqStack *S,SElemType e){
	//插入元素e为新的栈顶元素
	if(S->top-S->base>=S->stacksize){//栈已满,追加存储空间
		S->base=(SElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S->base)
		{
			printf("重新申请空间失败.\n");
			exit(0);
		}
		S->top=S->base+S->stacksize;//更改栈顶指针
		S->stacksize+=STACKINCREMENT;
	}
	*S->top++=e;
	return OK;
}

Status Pop(SqStack *S,SElemType *e){
	//若栈S不为空,则删除S的栈顶元素,用e返回其值,并返回OK,否则返回ERROR
	if(S->top==S->base){//栈为空
		return ERROR;
	}
	*e=*(--S->top);
	return OK;
}


运行结果:

二叉树的三种遍历方式的递归算法C代码

基本概念 树形结构是一类重要的非线性数据结构,其中以树和二叉树最为常用。 二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”(left subtree)和“右子树”(right ...
  • u014488381
  • u014488381
  • 2014年11月30日 21:54
  • 6027

【算法】二叉树的递归遍历C语言实现

二叉树是一种极其重要的数据结构,以下是二叉树的结构定义 创建 和递归先序 中序 后序 遍历的代码. #include #include typedef char ElemType; /*二...
  • lchad
  • lchad
  • 2015年02月07日 18:18
  • 5008

数据结构 二叉树的递归算法、前序、中序、后序遍历(c语言实现)

实验目的 1、掌握二叉树的表示与实现。 2、掌握二叉树的定义、创建、遍历等基本操作的实现。 3、熟悉求二叉树深度等递归算法的设计与实现。 实验内容 问题描述:已知二叉树t,分别采用顺序存储结...
  • catkint
  • catkint
  • 2015年12月18日 23:08
  • 5559

<数据结构>二叉树的递归、非递归以及层次遍历算法C语言实现

二叉树是数据结构中一种非常重要的结构,熟练的掌握二叉树的创建,遍历是打好编程基础的关键。对于遍历,不能仅仅只掌握递归遍历,还应掌握效率更高地非递归遍历。对于非递归的先序、中序、后序遍历要用到栈(在之前...
  • fzh1900
  • fzh1900
  • 2013年11月02日 17:12
  • 3583

C语言基本数据结构之二(二叉树的三种遍历,节点数以及深度算法)

关于二叉树的定义,网上有比较好的介绍,在这里就简单介绍二叉树的一些性质 二叉树的基本性质 1)二叉树的第i层上至多有 2^(i-1)(i ≥1)个结点; 2)深度为 h 的二叉树中至多含有 2^h –...
  • to_perfect
  • to_perfect
  • 2016年12月05日 19:29
  • 2614

二叉树遍历之递归算法

二叉树的遍历算法有多种,典型的有先序遍历、中序遍历、后序遍历以及层序遍历。而且这些遍历的递归算法较为简单,代码很少,容易实现,本文就是汇总二叉树遍历的递归算法,非递归算法将在下一篇文章中进行总结。本文...
  • justheretobe
  • justheretobe
  • 2012年08月13日 18:21
  • 19388

C语言实现二叉树的递归遍历与非递归遍历

本文实现了对二叉树的递归遍历和非递归遍历,当然还包括了一些栈操作。           二叉树的遍历本质上其实就是入栈出栈的问题,递归算法简单且容易理解,但是效率始终是个问题。非递归算法可以清楚的知...
  • cqnuztq
  • cqnuztq
  • 2013年05月07日 20:38
  • 29459

<数据结构>二叉树的递归、非递归以及层次遍历算法C语言实现

二叉树是数据结构中一种非常重要的结构,熟练的掌握二叉树的创建,遍历是打好编程基础的关键。对于遍历,不能仅仅只掌握递归遍历,还应掌握效率更高地非递归遍历。对于非递归的先序、中序、后序遍历要用到栈(在之前...
  • fzh1900
  • fzh1900
  • 2013年11月02日 17:12
  • 3583

中序遍历二叉树(非递归算法 c语言)

#include "stdio.h" #include "string.h" #include "malloc.h" #define NULL 0 #define MAXSIZE 30 typedef...
  • u010660346
  • u010660346
  • 2015年07月24日 19:28
  • 1235

经典算法学习——非递归遍历二叉树

我们知道二叉树是一种递归定义的数据结构,包括二叉树的创建、遍历、求树高、叶子节点个数等等。使用递归来进行以上操作非常的简便,相关实现请参考 《C语言实现二叉树的基本操作》。但是今天我们剑走偏锋,使用非...
  • CHENYUFENG1991
  • CHENYUFENG1991
  • 2016年10月03日 12:28
  • 2279
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C语言 二叉树的遍历 递归和(多种)非递归算法
举报原因:
原因补充:

(最多只允许输入30个字)