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

最新推荐文章于 2024-07-03 20:18:43 发布
最新推荐文章于 2024-07-03 20:18:43 发布
阅读量213 收藏 1
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：https://my.oschina.net/ervinfly/blog/309218
版权 
//二叉树遍历
//原作者：nuaazdh
//原作时间：2011年12月1日
//修改者：会飞的猪喵喵
//修改时间：2014年9月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); // 根指针入栈
	p=T;
	while(!StackEmpty(S)){
		while(p){
            if(p->lchild) {
                Push(&S,p->lchild);    //向左走到尽头
            }
            p = p->lchild;
		}
		//Pop(&S,&p);     //空指针出栈
		if(!StackEmpty(S)){//访问结点，向右一步
			Pop(&S,&p);
			if(!Visit(p->data)) return ERROR;
			if(p->rchild) {Push(&S,p->rchild); p = 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)){
				if(p->rchild)Push(&S,p->rchild);		// 右子树入栈
				if(p->lchild)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&&p->lchild)   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;
			}
			if(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;
}


转载于:https://my.oschina.net/ervinfly/blog/309218

chubi6554
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构以及应用算法教程参考答案（10）第六章
VAN
04-01 1046
6.37 解： // 先序遍历的非递归算法 Status POTraverse(BiTree& T,Status (*Visit)(TElemType e)) { BiTree p; Stack s; InitStack(s); p=T; while(p||!StackEmpty(s)){ if§{ // 如果根指针不空，访问根结点， // 右指针域压栈，继续遍历左子树 if(!Visit(p->data)) return ERROR; Push(s,p->rchild); p=p-&
二叉树后序遍历非递归算法(C/C++语言实现)
sgcls的专栏
08-19 5513
二叉树的三种遍历非递归版本是数据结构
非递归先、中、后序遍历二叉树（C语言）
qq_62353814的博客
10-23 5591
本程序采用C语言编写，栈和二叉树的基本操作函数基于严蔚敏老师的《数据结构（C语言版）》（清华大学出版社）一书，但参数的传递使用的是C语言中的二级指针，而不是C++中的引用，在CodeBlocks的C语言运行环境下无错误。
数据结构单链表应用
隔壁老王三金的博客
11-09 286
#include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; #define LIST_INIT_SIZE 100
数据结构树的基本操作_数据结构树的基本操作(主要遍历）
weixin_30412847的博客
01-17 696
一． 实验目的将树的基本操作C语言实现，主要考察树的先序，中序，后序和层次遍历。二.主要内容本文所使用的二叉树如图：显然先序：ABCDEGF中序：CBEGDFA后序：CGEFDBA层次：ABCDEFGBiTree.h内容C++typedef char TElemType;typedef int Status;typedef struct BiTNode{TElemType data;struct ...
二叉树先序遍历非递归算法(C/C++语言实现)
sgcls的专栏
08-19 2085
先序遍历的非递归版本是三种遍历里面最 /* 二叉树节点结构 */ struct BinaryTreeNode { int data; BinaryTreeNode* lchild; BinaryTreeNode* rchild; BinaryTreeNode(int _data = -1): data(_data),lchild(NUL
C语言二叉树的非递归遍历实例分析
09-04
二叉树遍历是访问二叉树中所有节点的过程，通常分为三种基本方法：先序遍历、中序遍历和后序遍历。在C语言中，我们可以使用递归或非递归的方式来实现这些遍历。本文主要关注非递归遍历方法。 **先序遍历**： 先序...
二叉树遍历C语言(递归-非递归)六种算法-综合文档
05-22
二叉树遍历C语言(递归-非递归)六种算法 一、设计思想 在计算机科学中，二叉树是一种常用的数据结构。它由节点和边组成，每个节点都含有一个值和两个孩子节点，分别是左孩子和右孩子。二叉树的遍历是指从树的根节点...
erchashu.rar_C语言 二叉树 遍历 C语言_二叉树遍历
09-22
总结来说，二叉树遍历是C语言中处理二叉树数据结构的关键技能，包括先根、中根和后根三种方式，它们各有应用场景，且都可以通过递归或非递归方法实现。熟悉并掌握这些知识，将有助于在解决实际问题时更加得心应手。
二叉树遍历C语言(递归-非递归)六种算法.rar-综合文档
05-11
二叉树遍历是计算机科学中的一个重要概念，特别是在数据结构和算法的学习中。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是指按照特定顺序访问二叉树的所有...
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
关于二叉树的一些操作
学历只能代表过去，能力代表着现在，而学习代表的是未来。
10-11 459
struct NODE { int iData; struct NODE *pLeft;   struct NODE *pRight; }; 根节点为pRoot Status Search(BiTree T,int n) { if(!T) return ERROR; if(n==T->data)  return OK; else if(ndata)
数据结构(二叉树的遍历)
WJI777的博客
11-12 1166
数据结构 二叉树的遍历 （包括先序，中序，后序遍历，以 及先序的非递归调用）相关代码如下： #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #define STACK_INIT_SIZE 100 //宏定义 栈区的容量 #define STACKINCREMENT 10 //当容量不充足的时候增加的容量大小
中序遍历的非递归算法
lyy的博客
10-08 2万+
话不多说直接上代码: Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)){ InitStack(S);Push(S,T);//根指针进栈 while(!StackEmpty(S)){ while(GetTop(S,p)&amp;&amp;p) Push(S,p-&gt;lchild);//...
二叉树的遍历（先序、中序、后序和层次遍历）
热门推荐
DX奥特曼的博客
12-29 3万+
采用二叉链表结构实现二叉树，并以递归遍历思想实现二叉树的创建、二叉树的遍历（先序、中序、后序和层次遍历）、二叉树叶子节点统计、二叉树深度统计的算法；同时，结合课件和实例代码，实现二叉树的中序非递归遍历算法。存储结构和操作接口定义如下: /*①二叉树的二叉链表存储结构定义*/ typedef struct BiTNode { ElemType data; struct BiTNode *l
c++习题08-计算星期几
最新发布
码到成龚的博客
07-03 586
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
c语言先序遍历递归算法
02-07
c语言的先序遍历递归算法的基本框架如下： ``` void preorder(struct node *root) { if (root != NULL) { printf("%d ", root->data); // 访问根节点 preorder(root->left); // 递归访问左子树 preorder(root->...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值