二叉树的遍历递归与非递归实现（完整代码）

最新推荐文章于 2024-05-18 10:53:04 发布

Jhze

最新推荐文章于 2024-05-18 10:53:04 发布

阅读量7.3k

点赞数 10

文章标签：二叉树遍历算法递归遍历非递归遍历

本文链接：https://blog.csdn.net/sinat_38812250/article/details/89464214

版权

二叉树的遍历

一. 对遍历的理解

找到一条搜索路径，来查看二叉树的所有结点，使得每个结点都能被访问一次，而且仅被访问一次。这种访问多种多样，可以给结点赋值、也可以改变结点信息、或输出结点的值等。二叉树，与前面我所学的线性结构（只有一个后继）不同。二叉树是一种非线性结构，那我们应该怎么样遍历呢？

二．二叉树搜索路径

按照从左到右有三种遍历。
（1）先（根）序的遍历算法
（2）中（根）序的遍历算法
（3）后（根）序的遍历算法

对（根）的理解：

三.二叉树先序、中序和后序遍历的算法描述

若二叉树不为空的条件下。
先（根）序遍历算法：
（1）访问根节点
（2）先序遍历左子树
（3）先序遍历右子树
中（根）序的遍历算法：
（1）中序遍历左子树
（2）访问根节点
（3）中序遍历右子树
后（根）序遍历算法：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根节点
在这里插入图片描述
这里方便理解的是，我们假设每次访问都是和上图这种类似的结构，

如果是先序遍历，（1）则优先访问根节点，（2）再递归遍历左子树，（3）递归遍历右子树
先序遍历序列为：ABC

如果是中序遍历，（1）则先递归遍历左子树，（2）再访问根节点，（3）递归遍历右子树
>中序遍历序列为：BAC

如果是后序序遍历，（1）则优先访问根节点，（2）再递归遍历左子树，（3）递归遍历右子树
后序遍历序列为：BCA

请读者观察黄色的部分、遍历序列和上述图片，是不是已经有了自己的想法呢？
那么我们接下来看一下代码实现。
在这里插入图片描述
以上图为例

先序递归遍历二叉树

void PreOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		cout << B->data;
		PreOrderBiTNode(B->lchild);
		PreOrderBiTNode(B->rchild);
	}
}

中序递归遍历二叉树

void MidOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		MidOrderBiTNode(B->lchild);
		cout << B->data;
		MidOrderBiTNode(B->rchild);
	}
}

后序遍历递归实现

void PostOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		PostOrderBiTNode(B->lchild);
		PostOrderBiTNode(B->rchild);
		cout << B->data;
	}
}

运行截图:
在这里插入图片描述

二.叉树遍历算法递归与非递归描述：

四.非递归用栈来实现

先序遍历非递归实现

void PreOrderBiTNode1(BiTNode* B) {
	StackBiTNode* S;
	struct BiTNode* e;
	initStack(S);
	Push(S, B);
	while (!StackEmpty(S)) {
		Pop(S, e);
		B = e;
		cout << e->data;
		if (B->rchild) {
			Push(S, B->rchild);
		}
		if (B->lchild) {
			Push(S, B->lchild);
		}
	}
}

中序遍历非递归实现

BiTNode* GoForBiTNode(BiTNode* B, StackBiTNode* S) {
	if (!B)
		return NULL;
	while (B->lchild) {
		Push(S, B);
		B = B->lchild;
	}
	return B;
}
void MidOrderBiTNode1(BiTNode* B) {
	StackBiTNode *S;
	initStack(S);
	struct BiTNode* e;
	BiTNode* t = GoForBiTNode(B, S);
	while (t) {
		cout << t->data;
		if (t->rchild) {
			t = GoForBiTNode(t->rchild, S);
		}
		else if (!StackEmpty(S)) {
			Pop(S, e);
			t = e;
		}
		else {
			t = NULL;
		}	
	}
}

后序遍历非递归实现

void PostOrderBiTNode1(BiTNode* B) {
	StackBiTNode *S;
	struct BiTNode* e;
	initStack(S);
	bool flag;
	BiTNode* p, * r;
		p = B;
		do {
			while (p != NULL) {
				Push(S, p);
				p = p->lchild;
			}
			r = NULL;
			flag = true;
			while (!StackEmpty(S) && flag) {
				p = GetElemType(S);
				if (p->rchild == r) {
					cout << p->data;
					Pop(S, e);
					p = e;
					r = p;
				}
				else {
					p = p->rchild;
					flag = false;
				}
			}
		} while (!StackEmpty(S));
		cout << endl;
}

运行截图：
在这里插入图片描述

五.完整的代码

#include<iostream>
#include<cstdio>
#include<stdlib.h>
using namespace std;


#define Maxsize 50
typedef char ElemType;
typedef struct BiTNode* ElemTypes;
const char* str = "ABDH#K###E##CFI###G#J##";
int index = 0;

//创建二叉树
typedef struct BiTNode {
	ElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode;


// 创建栈
typedef struct {
	struct BiTNode* data[Maxsize];
	int top;
}StackBiTNode;

//初始化栈
void initStack(StackBiTNode* &s) {
	s = (StackBiTNode*)malloc(sizeof(StackBiTNode));
	s->top = -1;
}

//入栈
void Push(StackBiTNode*& s, ElemTypes t) {
	if (s->top >= Maxsize)
		return;
	else {
		s->top++;
		s->data[s->top] = t;
	}
}
//出栈
void Pop(StackBiTNode*& s, ElemTypes  &r) {
	if (s->top == -1)
		return;
	else {
		r = s->data[s->top];
		s->top--;
	}
}
// 判断栈是否为空
bool StackEmpty(StackBiTNode* s) {
	return(s->top == -1);
}

// 获取栈顶元素
struct BiTNode* GetElemType(StackBiTNode* s) {
	return s->data[s->top];
}

//先序遍历创建二叉树
void PreCreateBiTNode(BiTNode* &B) {
	char ch = str[index++];
	if (ch == '#')
		B = NULL;
	else {
		B = (BiTNode*)malloc(sizeof(BiTNode));
		B->data = ch;
		PreCreateBiTNode(B->lchild);
		PreCreateBiTNode(B->rchild);
	}
}

//先序递归遍历二叉树
void PreOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		cout << B->data;
		PreOrderBiTNode(B->lchild);
		PreOrderBiTNode(B->rchild);
	}
}

//中序递归遍历二叉树
void MidOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		MidOrderBiTNode(B->lchild);
		cout << B->data;
		MidOrderBiTNode(B->rchild);
	}
}

//后序遍历递归实现
void PostOrderBiTNode(BiTNode* B) {
	if (B == NULL)
		return;
	else {
		PostOrderBiTNode(B->lchild);
		PostOrderBiTNode(B->rchild);
		cout << B->data;
	}
}

//先序遍历非递归实现
void PreOrderBiTNode1(BiTNode* B) {
	StackBiTNode* S;
	struct BiTNode* e;
	initStack(S);
	Push(S, B);
	while (!StackEmpty(S)) {
		Pop(S, e);
		B = e;
		cout << e->data;
		if (B->rchild) {
			Push(S, B->rchild);
		}
		if (B->lchild) {
			Push(S, B->lchild);
		}
	}
}


//中序遍历非递归
BiTNode* GoForBiTNode(BiTNode* B, StackBiTNode* S) {
	if (!B)
		return NULL;
	while (B->lchild) {
		Push(S, B);
		B = B->lchild;
	}
	return B;
}
void MidOrderBiTNode1(BiTNode* B) {
	StackBiTNode *S;
	initStack(S);
	struct BiTNode* e;
	BiTNode* t = GoForBiTNode(B, S);
	while (t) {
		cout << t->data;
		if (t->rchild) {
			t = GoForBiTNode(t->rchild, S);
		}
		else if (!StackEmpty(S)) {
			Pop(S, e);
			t = e;
		}
		else {
			t = NULL;
		}	
	}
}

//后序遍历递归实现
void PostOrderBiTNode1(BiTNode* B) {
	StackBiTNode *S;
	struct BiTNode* e;
	initStack(S);
	bool flag;
	BiTNode* p, * r;
		p = B;
		do {
			while (p != NULL) {
				Push(S, p);
				p = p->lchild;
			}
			r = NULL;
			flag = true;
			while (!StackEmpty(S) && flag) {
				p = GetElemType(S);
				if (p->rchild == r) {
					cout << p->data;
					Pop(S, e);
					p = e;
					r = p;
				}
				else {
					p = p->rchild;
					flag = false;
				}
			}
		} while (!StackEmpty(S));
		cout << endl;
}

int main() {

	StackBiTNode* s;
	BiTNode* B;
	initStack(s);
	PreCreateBiTNode(B);  //创建二叉树
	cout << "*************__二叉树递归遍历__*****************"<<endl;
	cout << "先序遍历：";
	PreOrderBiTNode(B);
	cout << endl;
	cout << "中序遍历：";
	MidOrderBiTNode(B);
	cout << endl;
	cout << "后序遍历：";
	PostOrderBiTNode(B);
	cout << endl;
	cout << "*************__二叉树非递归遍历__*****************" << endl;
	cout << "先序遍历:";
	PreOrderBiTNode1(B);
	cout << endl;
	cout << "中序遍历：";
	MidOrderBiTNode1(B);
	cout << endl;
	cout << "后序序遍历:";
	PostOrderBiTNode1(B);
	cout << endl;
	system("pause");
	return 0;
}

运行截图：
在这里插入图片描述

Jhze

关注

10
点赞
踩
80

收藏

觉得还不错? 一键收藏
0
评论
二叉树的遍历递归与非递归实现（完整代码）

二叉树的遍历一. 对遍历的理解找到一条搜索路径，来查看二叉树的所有结点，使得每个结点都能被访问一次，而且仅被访问一次。这种访问多种多样，可以给结点赋值、也可以改变结点信息、或输出结点的值等。二叉树，与前面我所学的线性结构（只有一个后继）不同。二叉树是一种非线性结构，那我们应该怎么样遍历呢？二．二叉树搜索路径按照从左到右有三种遍历。（1）先（根）序的遍历算法（2）中（根）序的遍历算法...
复制链接

扫一扫