【算法与数据结构】二叉树 （二叉树遍历、递归与非递归实现先中后序遍历、层次遍历）

最新推荐文章于 2024-10-02 08:00:00 发布
最新推荐文章于 2024-10-02 08:00:00 发布
阅读量616 收藏 3
点赞数
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51086862/article/details/121203787
版权
本文详细介绍了二叉树的基础概念，包括节点度、树度、叶节点与非叶节点等，重点阐述了二叉树的性质、存储结构，递归与非递归遍历方法，以及先序-中序-后序的转换技巧。深入探讨了层次遍历和非顺序存储的运用，适合理解二叉树核心概念和技术应用。
摘要由CSDN通过智能技术生成

二叉树

树的知识点

1.1名词解释

1.节点的度: 一个节点含有的子树的个数称为该节点的度;
2.树的度: 一棵树中，最大的节点的度称为树的度;
3.叶节点或终端节点: 度为的节点;
4.非终端节点或分支节点: 度不为零的节点;
5.父亲节点或父节点: 若-一个节点含有子节点，则这个节点称为其子节点的父节点;
6.孩子节点或子节点: 一个节点含有的子树的根节点称为该节点的子节点;
7，兄弟节点: 具有相同父节点的节点互称为兄弟节点;
8.节点的层次: 从根开始定义起，根为第1层，根的子节点为第2层，以此类推;
9.深度: 对于任意节点n,n的深度为从根到n的唯一路径长, 根的深度为0;
10.高度:对于任意节点n,n的高度为从n到- -片树叶的最长路径长,所有树叶的高度为0;
11.堂兄弟节点:父节点在同一层的节点互为堂兄弟;
12.节点的祖先:从根到该节点所经分支上的所有节点;
13.子孙:以某节点为恨的子树中任一节点都称为该节点的子孙q
14. 森林:由m (m>=0)棵互不相交的树的集合称为森林;
15.树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树。反之是有序树。

在这里插入图片描述

二叉树

2.1二叉树的性质

2.1.1性质

●若二叉树的层次从0开始 则在二 叉树的第i层最多有2i个结点。(i>= 0) [证明用数学归纳法
●高度为k的二叉树最多有2*+1-1个结点。 (k>= -1) [证明用求等比级数前 k项和的公式
●对任何一棵二叉树如果其叶结点个数为n0,度为2的非叶结点个数为n2,则有n0=n2+ 1.
定义:满二叉树(Full Binary Tree):每一 个层的结点数都达到最大值，则这个二叉树就是满二叉树。
在这里插入图片描述
定义:完全二叉树(Complete Binary Tree):若设二 叉树的高度为h,则共有h+1层。除第h层外，其它各层(0 - h- 1)的结点数部达到最大个数，第h层从右向左连续缺若干结点，这就是完全二叉树。
在这里插入图片描述

●具有n 个结点的完全二叉树的高度为「log2(n+1)7 -1
证明:设完全二叉树的高度为h，则有2h-1<n≤(2h+1)-1 => 2h<n+1≤2h+1=>取对数h< log2^(n+1)<= h+1

2.1.2存储结构

●数据元素之间的关系有两种不同的表示方法: 顺序映象和非顺序映象,并由此得到两种不同的存储
结构:顺序存储结构和链式存储结构。数据的存储结构是指数据的逻辑结构在计算机中的表示。
1.顺序存储表示：
在这里插入图片描述
在这里插入图片描述

2.链式存储表示
满二叉树与完全二叉树适合用数组进行顺序存储，不浪费空间，如果普通二叉树用数组存储的话太浪费内存，数组有好多空缺，所以使用链式存储形式。
在这里插入图片描述
3.二叉链表的静态结构

在这里插入图片描述

2.2 二叉树遍历

二叉树遍历(Binary Tree Traversal)，所谓树的遍历，就是按某种次序访问树中的结点，要求每个结点访问一次且仅访问一次。
设访问根结点记作V;
遍历根的左子树记作L;
遍历根的右子树记作 R;

则可能的遍历次序有:

遍历方法表示镜像表示
前序VLR镜像VRL
中序LVR镜像RVL
后序LRV镜像RLV

做个题：
在这里插入图片描述
前序遍历：ABCDEFGH
中序遍历：CBEDFAGH
后序遍历：CEFDBHGA
代码讲解：
使用链式存储，递归实现二叉树的遍历
代码头

#include<stack>
#include<queue>
#include<list>
#include<unordered_map>
#include<stdlib.h>
#include<algorithm>
#include<iostream>

using namespace std;

#define END '#'
typedef char ElemType;
/*//三叉链表的定义
typedef struct BtNode
{
	BtNode* leftchild;
	BtNode* parent;
	BtNode* rightchild;
	ElemType data;
};
*/
//二叉
typedef struct BtNode
{
	BtNode* leftchild;
	//BtNode* parent;
	BtNode* rightchild;
	ElemType data;
}BtNode, * BinaryTree;;

//买节点操作
BtNode*  Buynode() { 
	BtNode* s = (BtNode*)malloc(sizeof(BtNode));
	if (NULL == s) 
		exit(1);//弄死它
	memset(s, 0, sizeof(BtNode));//s 的值变为 0
	return s;
}

定义一个结构体 。
定义一个买节点的函数。

2.2.1递归实现三种遍历

typedef struct BtNode
{
	BtNode* leftchild;
	BtNode* rightchild;
	ElemType data;
}BtNode, * BinaryTree;;

//前序遍历
void PreOrder(BtNode* ptr) {
	if (ptr != NULL) {
		cout << ptr->data;
		PreOrder(ptr->leftchild);
		PreOrder(ptr->rightchild);
	}
}
//中序遍历
void InOrder(BtNode* ptr) {
	if (ptr != NULL) {
		InOrder(ptr->leftchild);
		cout << ptr->data;
		InOrder(ptr->rightchild);
	}
}
//后序遍历
void PastOrder(BtNode* ptr) {
	if (ptr != NULL) {
		PastOrder(ptr->leftchild);
		PastOrder(ptr->rightchild);
		cout << ptr->data;
	}
}

//创建一个二叉树
BtNode* CreateTree() {

	ElemType ch;
	BtNode* s = NULL;
	cin >> ch; 
	if (ch != END) {
		s = Buynode(); //购买一个节点
		s->data = ch;
		s->leftchild = CreateTree();
		s->rightchild = CreateTree();
	}
	return s;
}

int main() {

	//输入 ABC##DE##F##G3H##
	BinaryTree root = NULL;
	root = CreateTree();
	PreOrder(root);
	cout <<endl;
	InOrder(root);
	cout << endl;
	PastOrder(root);
	cout << endl;
	return 0;
}
升级二推一

这基本太简单，一般出题都是二推一，
给出先序和中序推后序
给出中序和后序推先序
但先序和后序无法推中序（ 无法确定根节点，并且会出现多种情况）
接下来看代码。

1.先序和中序推后序
//寻找pos 在中序中寻找这个值
int FindPos(const char* is, int n, ElemType val) {
	int pos = -1;
	for (int i = 0; i < n; i++) {
		if (is[i] == val) {
			pos = i;//返回它的下标
			break;
		}
	}
	return pos;
}

// 先序和中序推后续
BtNode* CreatePI(const char* ps, const char* is, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();//购买一个节点
		s->data = ps[0];
		int pos = FindPos(is, n, ps[0]);// 寻找pos
		if (pos == -1)exit(1);// 如果没找到  终止程序
		s->leftchild = CreatePI(ps + 1, is, pos);// pos 数据变小 
		s->rightchild = CreatePI(ps + 1+pos, is+1+pos, n-1-pos);//从树根节点后面的数据进行
	}
	return s;
}

BtNode* CreateBTreePI(const char* ps,const char* is, int n) {
	if (ps == NULL || is == NULL || n < 1) {
		return NULL;
	}
	else return CreatePI(ps, is, n);
}
2.中序和后序推先序
//寻找pos 在中序中寻找这个值
int FindPos(const char* is, int n, ElemType val) {
	int pos = -1;
	for (int i = 0; i < n; i++) {
		if (is[i] == val) {
			pos = i;//返回它的下标
			break;
		}
	}
	return pos;
}

//中序和后序推先序
BtNode* CreateIL(const char* is, const char* ls, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();
		s->data = ls[n - 1];
		int pos = FindPos(is, n, ls[n - 1]);
		if (pos == -1)exit(1);
		s->leftchild = CreateIL( is, ls,pos );
		s->rightchild = CreateIL( is+pos+1,ls+pos ,n-pos-1 );
	}
	return s;
}

//创建二叉树
BtNode* CreateBTreeIL(const char* ls, const char* is, int  n) {
	if (ls == NULL || is == NULL || n < 1) {
		return NULL;
	}
	else return CreateIL(ls, is, n);
}

实现递归遍历并不能满足我们的需求，再看非递归实现

2.2.2非递归实现三种遍历

二叉树遍历——栈实现

代码：

/*
* 
* 使用栈实现
*/

// 先序遍历非递归
void NicePreOrder(BtNode* ptr)
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	st.push(ptr);
	while (!st.empty())
	{
		ptr = st.top(); st.pop();
		cout << ptr->data << " ";
		if (ptr->rightchild != NULL)
			st.push(ptr->rightchild);
		if (ptr->leftchild  != NULL)
			st.push(ptr->leftchild );
	}
	cout << endl;
}
// 中序遍历非递归
void NiceInOrder(BtNode* ptr)
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	while (!st.empty() || ptr !=NULL )
	{
		while (ptr != NULL)
		{
			st.push(ptr);// 入栈
			ptr = ptr->leftchild;
		}
		ptr = st.top();//取栈顶指针
		st.pop();//出栈
		cout << ptr->data << " ";//输出
		ptr = ptr->rightchild;
	}
	cout << endl;
}
// 后序遍历非递归
void NicePastOrder(BtNode* ptr) 
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	BtNode* tag = NULL;
	while (!st.empty() || ptr != NULL)
	{
		while (ptr != NULL)
		{
			st.push(ptr);// 入栈
			ptr = ptr->leftchild;
		}
		ptr = st.top();//取栈顶指针
		st.pop();//出栈
		if (ptr->rightchild == NULL || ptr->rightchild == tag)
		{
			cout << ptr->data << " ";//输出
			tag = ptr;//tag 跟着打印出来的数据
			ptr = NULL;//注意  一定要为空！！！
		}
		else
		{
			st.push(ptr);
			ptr = ptr->rightchild;
		}
	}
	cout << endl;
}
层次遍历—— 队列实现
/*
使用层次遍历
 队列
*/

void NiceLevelOrder(BtNode* ptr) 
{
	if (ptr == NULL) return;
	queue<BtNode*> st; // 使用队列
	st.push(ptr);
	while (!st.empty())
	{
		ptr = st.front(); st.pop();
		cout << ptr->data << " ";

		if (ptr->leftchild != NULL)
			st.push(ptr->leftchild);
		if (ptr->rightchild != NULL)
			st.push(ptr->rightchild);
	}
	cout << endl;
}

附完整代码：
递归遍历

#include<stack>
#include<queue>
#include<list>
#include<unordered_map>
#include<stdlib.h>
#include<algorithm>
#include<iostream>

using namespace std;

#define END '#'
typedef char ElemType;
#if 1
/*//三叉链表的定义
typedef struct BtNode
{
	BtNode* leftchild;
	BtNode* parent;
	BtNode* rightchild;
	ElemType data;
};
*/
//二叉
typedef struct BtNode
{
	BtNode* leftchild;
	//BtNode* parent;
	BtNode* rightchild;
	ElemType data;
}BtNode, * BinaryTree;;


BtNode*  Buynode() {
	BtNode* s = (BtNode*)malloc(sizeof(BtNode));
	if (NULL == s) 
		exit(1);//弄死它
	memset(s, 0, sizeof(BtNode));//s 的值变为 0
	return s;
}


//前序遍历
void PreOrder(BtNode* ptr) {
	if (ptr != NULL) {
		cout << ptr->data;
		PreOrder(ptr->leftchild);
		PreOrder(ptr->rightchild);
	}
}
//中序遍历
void InOrder(BtNode* ptr) {
	if (ptr != NULL) {
		InOrder(ptr->leftchild);
		cout << ptr->data;
		InOrder(ptr->rightchild);
	}
}
//后序遍历
void PastOrder(BtNode* ptr) {
	if (ptr != NULL) {
		PastOrder(ptr->leftchild);
		PastOrder(ptr->rightchild);
		cout << ptr->data;
	}
}

BtNode* CreateTree() {

	ElemType ch;
	BtNode* s = NULL;
	cin >> ch; 
	if (ch != END) {
		s = Buynode(); //购买一个节点
		s->data = ch;
		s->leftchild = CreateTree();
		s->rightchild = CreateTree();
	}
	return s;
}
#if 0
int main() {

	//输入 ABC##DE##F##G3H##
	BinaryTree root = NULL;
	root = CreateTree();
	PreOrder(root);
	cout <<endl;
	InOrder(root);
	cout << endl;
	PastOrder(root);
	cout << endl;
	return 0;
}
#endif

//寻找pos 在中序中寻找这个值
int FindPos(const char* is, int n, ElemType val) {
	int pos = -1;
	for (int i = 0; i < n; i++) {
		if (is[i] == val) {
			pos = i;//返回它的下标
			break;
		}
	}
	return pos;
}
// 先序和中序推后续
BtNode* CreatePI(const char* ps, const char* is, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();//购买一个节点
		s->data = ps[0];
		int pos = FindPos(is, n, ps[0]);// 寻找pos
		if (pos == -1)exit(1);// 如果没找到  终止程序
		s->leftchild = CreatePI(ps + 1, is, pos);// pos 数据变小 
		s->rightchild = CreatePI(ps + 1+pos, is+1+pos, n-1-pos);//从树根节点后面的数据进行
	}
	return s;
}

//实现不了先序和后序推中序
BtNode* CreatePL(const char* ps, const char* ls, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();
		s->data = ps[0];
		int pos = FindPos(ls, n, ps[0]);
		if (pos == -1)exit(1);
		s->leftchild = CreatePL(ps+1,ls ,pos );
		s->rightchild = CreatePL(ps+pos+1 ,ls+pos ,n-pos -1);
	}
	return s;
}


//中序和后序推先序
BtNode* CreateIL(const char* is, const char* ls, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();
		s->data = ls[n - 1];
		int pos = FindPos(is, n, ls[n - 1]);
		if (pos == -1)exit(1);
		s->leftchild = CreateIL( is, ls,pos );
		s->rightchild = CreateIL( is+pos+1,ls+pos ,n-pos-1 );
	}
	return s;
}

//创建二叉树
BtNode* CreateBTreePI(const char* ps,const char* is, int n) {
	if (ps == NULL || is == NULL || n < 1) {
		return NULL;
	}
	else return CreatePI(ps, is, n);
}

BtNode* CreateBTreePL(const char* ps, const char* ls, int  n) {
	if (ps == NULL ||ls == NULL || n < 1) {
		return NULL;
	}
	else return CreatePL(ps, ls, n);
}

BtNode* CreateBTreeIL(const char* ls, const char* is, int  n) {
	if (ls == NULL || is == NULL || n < 1) {
		return NULL;
	}
	else return CreateIL(ls, is, n);
}
int main() {
	const char ps[] = "ABCDEFGH";
	const char is[] = "CBEDFAGH";
	const char ls[] = "CEFDBHGA";

	int n = strlen(ps);

	BinaryTree root = NULL;
	//root = CreateBTreePI(ps,is, n);
	//root = CreateBTreePL(ps,ls, n);//不能根据先序和后序推中序
	//root = CreateBTreeIL(is,ls, n);

	PreOrder(root);
	cout << endl;
	InOrder(root);
	cout << endl;
	PastOrder(root);
	cout << endl;
}

#endif

非递归遍历

#include<stack>
#include<queue>
#include<list>
#include<unordered_map>
#include<stdlib.h>
#include<algorithm>
#include<iostream>

using namespace std;

#define END '#'
typedef char ElemType;

typedef struct BtNode
{
	BtNode* leftchild;
	//BtNode* parent;
	BtNode* rightchild;
	ElemType data;
}BtNode, * BinaryTree;;


BtNode* Buynode() {
	BtNode* s = (BtNode*)malloc(sizeof(BtNode));
	if (NULL == s)
		exit(1);//弄死它
	memset(s, 0, sizeof(BtNode));//s 的值变为 0
	return s;
}

//寻找pos 在中序中寻找这个值
int FindPos(const char* is, int n, ElemType val) {
	int pos = -1;
	for (int i = 0; i < n; i++) {
		if (is[i] == val) {
			pos = i;//返回它的下标
			break;
		}
	}
	return pos;
}

/*
* 
* 使用栈实现
*/

// 先序遍历非递归
void NicePreOrder(BtNode* ptr)
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	st.push(ptr);
	while (!st.empty())
	{
		ptr = st.top(); st.pop();
		cout << ptr->data << " ";
		if (ptr->rightchild != NULL)
			st.push(ptr->rightchild);
		if (ptr->leftchild  != NULL)
			st.push(ptr->leftchild );
	}
	cout << endl;
}
// 中序遍历非递归
void NiceInOrder(BtNode* ptr)
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	while (!st.empty() || ptr !=NULL )
	{
		while (ptr != NULL)
		{
			st.push(ptr);// 入栈
			ptr = ptr->leftchild;
		}
		ptr = st.top();//取栈顶指针
		st.pop();//出栈
		cout << ptr->data << " ";//输出
		ptr = ptr->rightchild;
	}
	cout << endl;
}
// 后序遍历非递归
void NicePastOrder(BtNode* ptr) 
{
	if (ptr == NULL) return;
	stack<BtNode*> st; // 使用栈
	BtNode* tag = NULL;
	while (!st.empty() || ptr != NULL)
	{
		while (ptr != NULL)
		{
			st.push(ptr);// 入栈
			ptr = ptr->leftchild;
		}
		ptr = st.top();//取栈顶指针
		st.pop();//出栈
		if (ptr->rightchild == NULL || ptr->rightchild == tag)
		{
			cout << ptr->data << " ";//输出
			tag = ptr;//tag 跟着打印出来的数据
			ptr = NULL;//注意  一定要为空！！！
		}
		else
		{
			st.push(ptr);
			ptr = ptr->rightchild;
		}
	}
	cout << endl;
}


/*
使用层次遍历
 队列
*/

void NiceLevelOrder(BtNode* ptr) 
{
	if (ptr == NULL) return;
	queue<BtNode*> st; // 使用队列
	st.push(ptr);
	while (!st.empty())
	{
		ptr = st.front(); st.pop();
		cout << ptr->data << " ";

		if (ptr->leftchild != NULL)
			st.push(ptr->leftchild);
		if (ptr->rightchild != NULL)
			st.push(ptr->rightchild);
	}
	cout << endl;
}

//中序和后序推先序
BtNode* CreateIL(const char* is, const char* ls, int n) {
	BtNode* s = NULL;
	if (n > 0) {
		s = Buynode();
		s->data = ls[n - 1];
		int pos = FindPos(is, n, ls[n - 1]);
		if (pos == -1)exit(1);
		s->leftchild = CreateIL(is, ls, pos);
		s->rightchild = CreateIL(is + pos + 1, ls + pos, n - pos - 1);
	}
	return s;
}

BtNode* CreateBTreeIL(const char* ls, const char* is, int  n) {
	if (ls == NULL || is == NULL || n < 1) {
		return NULL;
	}
	else return CreateIL(ls, is, n);
}

int main() {
	const char ps[] = "ABCDEFGH";
	const char is[] = "CBEDFAGH";
	const char ls[] = "CEFDBHGA";

	int n = strlen(ps);

	BinaryTree root = NULL;
	
	root = CreateBTreeIL(is,ls, n);
	NicePreOrder(root);
	NiceInOrder(root);
	NicePastOrder(root);
	NiceLevelOrder(root);// 层次遍历
	cout << endl;
}

小结：

1.现阶段二叉树的遍历就要求掌握三种：先序 ，中序，后序
二叉树的遍历还可以进行多样形式的遍历：

  • 层次遍历 （上面有提到）

  • s 型层次遍历.

  • 反s 型层次遍历。

  • …

2.先序中序推后序，后序中序推前序，得记住前后不能推中。
3.熟悉掌握队列、栈、链表的使用，以及运行过程，解决二叉树不是问题。

猿来&如此
关注
数据结构--二叉树先序、中序、后序 递归、非递归遍历
weixin_72407838的博客
03-09 373
二叉树遍历 递归实现先序、中序、后序、层序遍历 非递归实现先序、中序、后序 递归遍历、非递归遍历完整代码
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
上述代码中的三个函数都是基于栈实现的非递归遍历，它们能够有效地处理任意大小的二叉树，而不会受到递归深度限制的影响。 在实际应用中，二叉树遍历可以用来进行多种操作，如查找、复制、排序等。比如，在编译器中...
二叉树的先序、中序、后序递归与非递归实现遍历
MA201506的博客
12-04 184
//定义二叉树结点 struct BiTreeNode { int data; BiTreeNode* left; BiTreeNode* right; }; 一、递归实现 //先序 void preOrder(BiTreeNode *root){ cout<<root->data; ...
二叉树的遍历（递归非递归、先序中序后序层次遍历）
heliotrope_jin的博客
05-05 107
【代码】二叉树的遍历（递归非递归、先序中序后序层次遍历）
[二叉树]分别用递归和非递归方式实现二叉树先序、中序和后序遍历
ltcz99的博客
11-13 587
题目：用递归和非递归两种方式，分别按照二叉树先序、中序和后序打印所有的节点。我们约定先遍历顺序为根、左、右；中序遍历顺序为左、根、右；后序遍历为左、右、根。 前提知识： 递归的遍历： 树的遍历与递归 最近做一个统计工作，需要遍历一些文件，一个文件夹下面有很多层的小文件，如何算出这个文件夹下面有多少文件？相信很多人第一时间都能想到递归遍历，这是最直接，最简单的办法。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧...
二叉树基本操作的递归实现（二叉树建立，先序，中序，后序，深度的递归遍历。广度优先，高度优先的非递归遍历）
HZC的专栏
04-23 1412
树的特点： 1. 每个结点有零个或多个子结点   2. 每一个子结点只有一个父结点 3. 没有前驱的结点为根结点 4. 除了根结点外，每个子结点可以分为m个不相交的子树 树相关的术语: 节点的度：一个节点含有的子树的个数称为该节点的度 叶节点或终端节点：度为零的节点称为叶节点 非终端节点或分支节点：度不为零的节点 双亲节点或父节点：若一个
二叉树：后序遍历非递归算法
花间半盘棋
11-15 2万+
分析：后序遍历是三种遍历中最难的一种，后序遍历的特点为左右根，并且也需要借助一个栈来完成，如图，虚线表示p,q最开始的位置，用r指向最近访问过的结点。首先从根节点开始，沿着根的左孩子，将左孩子依次进行入栈。当D入栈之后，由于D没有右孩子，所以将D出栈，此时r指向D。 D出栈之后读栈顶元素B，p指向B，发现B有右孩子，然后将右孩子E入栈。 然后判断栈顶元素E，E没有右孩子了，所以将E出栈，此时r指向E。 然后判断栈顶元素B，B的两个孩子都已经操作过了，所以B出栈，p指向A，判断栈顶元素A，A有右孩子，右孩
二叉树后序遍历的非递归算法
2301_80150315的博客
07-17 1116
二叉树后序遍历的非递归算法,严格按照上述伪代码的形式
C语言经典算法之二叉树的后序遍历（递归实现）
weixin_56154577的博客
01-31 1432
在C语言中，二叉树的后序遍历（Postorder Traversal）是一种按照“左子树-右子树-根节点”的顺序访问每个节点的算法。递归实现的思路非常直观：首先递归地遍历左子树，然后递归地遍历右子树，最后访问当前根节点。
【数据结构】--- 二叉树的递归遍历和非递归遍历【C语言实现】
热门推荐
mike_jun的博客
07-17 3万+
目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 4.递归后序遍历二叉树 5. 测试递归打印二叉树代码 6. 非-递归前序遍历二叉树 7.非-递归实现中序遍历二叉树 8.非 - 递归实现后序遍历【较为复杂的方法】 9.非 - 递归实现后序遍历【简单的方法】 10. 二叉树的层次遍历 11. 最后：附全部代码： 对于二叉树的非递归 深度优先遍历，使用的都是栈 对于二叉树的层次遍历，使用的是队列 1. 创建一颗二叉树 依据前序遍...
各种二叉树的数据结构.rar_二叉树_二叉树 遍历_实现二叉树的先、中、后序递归遍历算_数据结构_数据结构 算法
09-23
非递归遍历通常需要维护一个辅助数据结构，如栈或队列，来跟踪遍历的顺序。 此外，压缩包中的`depth.cpp`文件可能实现了计算二叉树深度的功能。二叉树的深度是从根节点到最远叶节点的最长路径上边的数目。计算深度...
C语言数据结构之二叉树的非递归后序遍历算法
08-29
主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
二叉树的非递归后序遍历算法实例详解
09-04
后序遍历的基本顺序是：左子树 -> 右子树 -> 根节点，但在非递归实现中，由于不能直接利用函数调用的返回来控制顺序，我们需要借助数据结构（如栈）来辅助完成。以下是一种常见的非递归后序遍历算法： 1. 定义栈...
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1413
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 658
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 422
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 401
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
AI驱动TDSQL-C Serverless数据库技术实战营--- 操作与电商可视分析
chasemydreamidea的博客
09-27 740
本文将基于腾讯云的高性能应用服务HAI和TDSQL-C MYSQL Serverless版构建AI电商数据分析系统。HAI作为一个面向AI和科学计算的GPU应用服务产品，它具有强大的计算能力，让复杂的AI模型的快速部署和运行的可行性加大，进而支持自然语言处理和图形生成等高级任务。TDSQL-C MYSQL版是一款云原生关系型数据库，其100%的MySQL兼容性，以及极致的弹性、高性能和高可用性，是电商业务中处理海量数据存储和查询的理想选择。本文实践除了使用TDSQL-C MYSQL外，通过python语言和
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 651
【C++】stack和queue的使用及注意事项
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值