1. Toy模板网首页
  2. > Toy博客

【数据结构】二叉树遍历的实现（超详细解析，小白必看系列）

8月前 作者：sunny-ll 分类：Toy博客 阅读(37) 违法举报

这篇具有很好参考价值的文章主要介绍了【数据结构】二叉树遍历的实现（超详细解析，小白必看系列）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

一、前言

🍎为何使用链式二叉树 

 🍐何为链式二叉树

 🍉二叉树的构建

💦创建二叉链结构

💦手动构建一颗树 

🍓二叉树的遍历 （重点）

💦前序遍历

 💦中序遍历

 💦后续遍历

 🍌二叉树的经典问题（重点）

💦二叉树节点个数

 💦二叉树叶子节点的个数

 💦二叉树第K层节点个数

 💦二叉树的深度

 💦二叉树查找值为x的节点 

 💦二叉树的销毁

🍊总代码和演示图

二、共勉

一、前言

在之前的文章中，已经详细的讲解了二叉树、堆等问题，所以本次博客将继续延续之前的知识点，讲解链式二叉树的遍历和一些经典问题。

🍎为何使用链式二叉树 

在前几篇博文中，我们学习的都是完全二叉树或满二叉树，而这两个都是可以用数组来实现的，但是如果不是完全二叉树呢？回顾下曾经学过的知识点：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

 
由上图得知，普通二叉树也可以使用数组来存储，但是会存在大量的空间浪费，而完全二叉树就不会这样，因为其空间利用率是％100的。既然这样，那普通二叉树该如何进行存储呢？答案是使用链式结构进行存储。

 🍐何为链式二叉树

  •  链式结构分为两种：二叉链和三叉链

💦先看下代码结构：

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};
// 三叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pParent; // 指向当前节点的双亲
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};
💦 画图演示：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


⚠ 注意：链式二叉树和我们之前的学习略有差别。以前我们学习的数据结构无非就是增删查改这些东西，而链式二叉树不太关注这块的增删查改。因为普通二叉树的增删查改没有意义。如下的二叉树：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


链式二叉树是要比之前链表啥的更加复杂的，如果只是单纯的让链式二叉树存储数据的话，价值就不大了，不如使用线性表。接下来，我将通过其遍历方式，结点个数……为大家展开讨论。此节内容是为了后续学习更复杂的搜索二叉树打基础，具体是啥后面再谈。
 

在具体讲解之前，再回顾下二叉树，二叉树是：

  1. 空树
  2. 非空：根节点，根节点的左子树、根节点的右子树组成的。

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

 🍉二叉树的构建

💦创建二叉链结构

创建二叉链结构其实就很easy了，也就是创建一个结构体罢了，这种在先前已经写过很多，咱就是说直接上代码：

// 二叉树结构体
typedef struct BrinyTree
{
	struct BrinyTree* left;
	struct BrinyTree* right;
	int data;
}BT;

💦手动构建一颗树 

其实构建一棵树的思想还是挺简单的，按照图示创建6个节点，并根据图中的样子将节点顺次链接起来

// 创建一个节点 （有返回值，返回值类型为---结构体指针）
BT* BuyNode(int x)
{
	BT* newnode = (BT*)malloc(sizeof(BT));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

// 创建一个树
BT* CreatBinaryTree()
{
	// 创建6个节点
	BT* node1 = BuyNode(1);
	BT* node2 = BuyNode(2);
	BT* node3 = BuyNode(3);
	BT* node4 = BuyNode(4);
	BT* node5 = BuyNode(5);
	BT* node6 = BuyNode(6);

	//将结点连接起来，构成自己想要的树
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

🍓二叉树的遍历 （重点）

以一颗二叉树为例：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

后续的遍历均是建立在次二叉树基础上展开。 
 

💦前序遍历

  •  遍历规则：

前序遍历，也叫先根遍历

遍历顺序：根 -> 左子树 -> 右子树

  • 思路：

既然先从根走，根就是1，接下来访问1的左子树，此时又要先访问其左子树的根为2，接着再访问2的左子树->根：3，接着访问其左子树和右子树，不过均为空，递归返回，此时3作为2的左子树访问完毕，访问2的右子树为NULL，再递归返回此时1的左子树就访问完毕了，访问其右子树，同理访问左树4，再访问左树5，接着左右子树NULL，递归返回访问4的右树，……类似的

  • 图示：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

  •  代码演示：

前序遍历的代码非常简洁，短短几行即可操作，先看代码：

// 前序遍历 根 左 右
void  PrevOrder(BT* root)
{
	if (root == NULL)
	{
		printf("NULL "); // 如果为空，就打印
		return;      // 当前函数结束
	}
	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}
  • 效果如下：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言
跟我们先前画的图一模一样，让我们通过一副递归图来深刻理解其原理：

  • 递归图：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

 💦中序遍历

  •  遍历规则：

中序遍历，也叫中根遍历

遍历顺序：左子树 -> 根结点 -> 右子树

  • 思路：

根据遍历顺序，我们得知，如若想访问1，得先访问其左子树2，访问2还得先访问其左子树3，类似的，再访问其左子树为NULL，递归返回访问根结点3，再访问右子树NULL，递归返回访问根结点2，再访问右子树NULL，递归返回访问根结点1，再访问其右子树，1的右子树访问规律同1的左子树，这里不过多赘述。

  • 画图演示：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


 

  •  代码演示：

中序遍历的代码和前序遍历一样，看起来都非常简洁：

// 中序遍历  左 根 右
void InOrder(BT* root)
{
	if (root == NULL)
	{
		printf("NULL "); // 如果为空，就打印
		return;      // 当前函数结束
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}
  • 效果如下：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


单纯看代码看不出啥头绪，还得是画递归图。

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


 

 💦后续遍历

  •  遍历规则：

后续遍历，也叫后根遍历

遍历顺序：左子树 -> 右子树 -> 根结点

  • 思路：

要访问1得先访问1的左子树2，继而得先访问2的左子树3，再先访问3的左子树NULL，右子树NULL，根3，递归返回访问2的右子树NULL，根2，再递归返回访问1的右子树……类似的

  • 画图演示：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

  • 代码演示：
// 后序 左 右 根
void PosOrder(BT* root)
{
	if (root == NULL)
	{
		printf("NULL "); // 如果为空，就打印
		return;      // 当前函数结束
	}
	PosOrder(root->left);
	PosOrder(root->right);
	printf("%d ", root->data);
}
  • 效果如下：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

  • 画图演示递归过程：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言
 

 🍌二叉树的经典问题（重点）

💦二叉树节点个数

  •  思想：

求结点个数，这里我将提供如下几种方法，但不都是可行的，要对比着看，本质都是递归的思想：

  • 法一：遍历

在前文中，我们已经学习了如何遍历链式二叉树，现在想求结点的个数，那么只需要随便采用一种遍历方式，并把打印换成计数++来求个数即可，听起来非常容易，先看代码：

//节点个数
void BTreeSize(BTNode* root)
{
	int count = 0; //局部变量
	if (root == NULL) //如果为空
		return;
	++count;
	BTreeSize(root->left);
	BTreeSize(root->right);
}

难道上述代码能够准确求出结点个数吗？其实不然，根本求不出来。


具体解释起来需要借用栈帧的思想，因为这里用的是递归，而递归是每递归一次在栈帧里头都会开辟一块空间，每一块栈帧都会有一个count，而我希望的是只需要有一个count，然后所有的count均加在一起，可是现在每递归一次，重新开辟一个count，count即局部变量。递归完就销毁，同形参的改变不会影响实参一样，一个道理。所有此法根本就行不通，得换。
 

  • 法二：定义局部静态变量count

在法一中，我们定义的是局部变量count，会导致每递归一次就开辟栈帧，并创建count，每次递归结束返回就销毁栈帧。那如果可以把count放在静态区里头，不久可以保留住count吗

//节点个数
int BTreeSize(BTNode* root)
{
	static int count = 0; //局部静态变量
	if (root == NULL) //如果为空
		return count;
	++count;
	BTreeSize(root->left);
	BTreeSize(root->right);
	return count;
}
  • 效果如下：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

看似好像是成功了，确实结点个数为6，但真的就是成功了吗？当然不是，如果我们现在想多打印几次呢？
什么鬼？怎么size还呈现等差数列递增呢？就是因为这里运用了static关键字，将count扣在静态区，导致多次调用没办法初始化为0，使其每次递归调用累计加加，但是当你再重新调用自己时，count不会重新置为0，会依旧保留为曾经++的结果。局部的静态变量有一个好处，它的生命周期在全局，但是只能在局部去访问。它的初始化为0只有第一次调用会访问，其余均不会。由此可见，局部的静态也是不行的，还得再优化。
 

  • 法三：定义全局变量count

法二的局部静态变量行不通，那就把count设定为全局变量。要知道全局变量是存在静态区的。虽然也在静态区，但是其初始化为0是可以重复访问的。
 

//节点个数
int count = 0;
void BTreeSize(BTNode* root)
{
	if (root == NULL) //如果为空
		return;
	++count;
	BTreeSize(root->left);
	BTreeSize(root->right);
}
  • 效果如下：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


确实可以求出结点个数，并且也不会出现像法二一样的问题。但是其实定义全局变量也会存在一个小问题：线程安全的问题，这个等以后学到Linux再来讨论，我们这边考虑再换一种更优解。

  • 法四：最优解

我们这里可以考虑多套一层，可以考虑把变量的地址传过去。这样操作不会存在任何问题，上代码：
 

//节点个数
void BTreeSize(BTNode* root, int* pCount)
{
	if (root == NULL) //如果为空
		return;
	++(*pCount);
	BTreeSize(root->left, pCount);
	BTreeSize(root->right, pCount);
}

确实可以求出结点个数，并且也不会出现像法二一样的问题。但是其实定义全局变量也会存在一个小问题：线程安全的问题，这个等以后学到Linux再来讨论，我们这边考虑再换一种更优解。

  • 法五：新思路

直接利用子问题的思想来写，返回当root为空为0，不是就递归左树+右树+1。

  1. 空树，最小规模子问题，结点个数返回0
  2. 非空，左子树结点个数+右子树结点个数 + 1（自己）
int BTreeSize(BTNode* root)
{
	return root == NULL ? 0 : 
    BTreeSize(root->left) + 
    BTreeSize(root->right) + 1;
}

此法非常巧妙，很灵活的运用了递归的思想，我们通过递归图来深刻理解下：
 

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


 

 💦二叉树叶子节点的个数

  •  思路1：遍历+计数

在遍历的基础上如果结点的左右子树均为空则count++。但是此题我们依旧采用分治思想。

// 计算叶子节点个数
// 遍历 + 计数
void TreeLeveSize1(BT* root, int* count)
{
    if(root==NULL)
    {
        return ;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        (*count)++;
    }
    TreeLeveSize1(root->left,count);
    TreeLeveSize1(root->right,count);

}
  •  思路2：遍历+递归
// 叶子节点个数
int TreeLeveSize2(BT*root)
{
    if(root==NULL)
    {
        return 0;
    }
    int left = TreeLeveSize2(root->left);
    int right = TreeLeveSize2(root->right);
    if(left==0&&right==0)
    {
        return 1;
    }
    return left+right;
}
  • 思路3：分治思想

首先，如果为空，直接返回0，如若结点的左子树和右子树均为空，则为叶节点，此时返回1，其它的继续分治递归。

  • 代码演示：
/ 计算叶子节点个数
int TreeLeveSize(BT* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    return TreeLeveSize(root->left)+TreeLeveSize(root->right);
}
  • 递归图：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言


 

 💦二叉树第K层节点个数

  •  思路：

假设K=3

  1. 空树，返回0
  2. 非空，且K == 1，返回1
  3. 非空，且K>1，转换成左子树K-1层节点个数 + 右子树K-1层节点个数
  • 代码演示：
// 树的第K层节点个数
// 1. 当前树的第K层 = 左子树的第K-1层 + 右子树的第K-1层
int TreeKSize(BT* root, int k)
{
	assert(k > 0);
	// 给出 所问 问题 能成成立的条件（所问，问题的的结束条件）
	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		return 1;
	}

	return TreeKSize(root->left, k - 1) + TreeKSize(root->right, k - 1);

}
  • 递归图：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言
 

 💦二叉树的深度

  •  思路：

此题同样是运用分治的思想来解决，要比较左子树的高度和右子树的高度，大的那个就+1，因为还有根结点也算1个高度。

  • 代码演示：
// 树的深度
int TreeDeep(BT* root)
{
    if(root==NULL)
    {
        return 0;
    }
    int left = TreeDeep(root->left);
    int right = TreeDeep(root->right);
    if(left>right)
    {
        return left+1;
    }
    else
    {
        return right+1;
    }

}
  • 递归图：

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言
 

 💦二叉树查找值为x的节点 

  •  思路：

还是利用分治的思想，将其递归化成子问题去解决

  1. 先去根结点寻找，是就返回此节点
  2. 此时去左子树查找有无节点x
  3. 最后再去右子数去查找有无节点x
  4. 若左右子树均找不到节点x，直接返回空
  • 代码演示：
// 查询 树中的某一个节点是否存在
BT* TreeNode(BT* root,TreeDatatype x)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->data==x)
    {
        return root;
    }
    BT* left = TreeNode(root->left,x);
    BT* right = TreeNode(root->right,x);

    if(left!=NULL)
    {
        return left;
    }
    if(right!=NULL)
    {
        return right;
    }
    return NULL;
}
  • 递归图：

假设我们寻找的是数字5
从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言
 

 💦二叉树的销毁

  •  思路：

销毁的思想和遍历类似，如若我挨个遍历的同时，没遍历一次就销毁一次，岂不能达到效果，但是又会存在一个问题，那就是你要采用什么样的遍历方式？倘若你采用前序遍历，刚开始就把根销毁了，那么后面的子树还怎么销毁呢？因为此时根没了，子树找不到了就，所以要采用倒着销毁的规则，也就是后续的思想

  • 代码演示：
// 二叉树的销毁
// 从后往前销毁-------后续思想
// 进行遍历然后在销毁
void DestoryTree(BT*root)
{
    if(root==NULL)
    {
        return;
    }
    DestoryTree(root->left);
    DestoryTree(root->right);
    free(root);
}

思想和后续遍历类似，不做递归图演示。
 

🍊总代码和演示图

 💦代码

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

typedef int TreeDatatype;

typedef struct BinaryTree
{
    struct BinaryTree* left;
    struct BinaryTree* right;
    TreeDatatype data;
}BT;


BT* BuyTreenode(TreeDatatype x)
{
    BT* tree = (BT*)malloc(sizeof(BT));

    if(tree==NULL)
    {
        perror(" fail");
        exit(-1);
    }
    tree->data = x;
    tree->left = tree->right = NULL;

    return tree;
}

BT* CreatTree()
{
    BT* node1 = BuyTreenode(1);
    BT* node2 = BuyTreenode(2);
    BT* node3 = BuyTreenode(3);
    BT* node4 = BuyTreenode(4);
    BT* node5 = BuyTreenode(5);
    BT* node6 = BuyTreenode(6);
    //BT* node7 = BuyTreenode(7);

    node1->left = node2;
    node1->right = node4;
    node2->left = node3;
    //node2->right = node7;
    node4->left = node5;
    node4->right = node6;

    return node1;
}


// 前序遍历：根 左 右
void PreOrder(BT* root)
{
    if(root==NULL)
    {
        printf("NULL ");
        return;
    }
    printf("%d ",root->data);
    PreOrder(root->left);
    PreOrder(root->right);
}

// 中序遍历
void InOrder(BT*root)
{
    if(root==NULL)
    {
        printf("NULL");
        return;
    }
    InOrder(root->left);
    printf("%d ",root->data);
    InOrder(root->right);
}


// 后序遍历
void PastOrder(BT* root)
{
    if(root==NULL)
    {
        printf("NULL");
        return;
    }
    PastOrder(root->left);
    PastOrder(root->right);
    printf("%d ",root->data);
}


// 计算一颗树的节点个数
int TreeSize(BT* root)
{
    if(root==NULL)
    {
        return 0;
    }

    return TreeSize(root->left)+TreeSize(root->right)+1;
}

// 计算叶子节点个数
int TreeLeveSize(BT* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    return TreeLeveSize(root->left)+TreeLeveSize(root->right);
}

// 计算叶子节点个数
// 遍历 + 计数
void TreeLeveSize1(BT* root, int* count)
{
    if(root==NULL)
    {
        return ;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        (*count)++;
    }
    TreeLeveSize1(root->left,count);
    TreeLeveSize1(root->right,count);

}

// 叶子节点个数
int TreeLeveSize2(BT*root)
{
    if(root==NULL)
    {
        return 0;
    }
    int left = TreeLeveSize2(root->left);
    int right = TreeLeveSize2(root->right);
    if(left==0&&right==0)
    {
        return 1;
    }
    return left+right;
}


// 树的第 K 层的节点
int TreeKLeveSize(BT* root,int k)
{
    if(root==NULL)
    {
        return 0;
    }
    if(k==1)
    {
        return 1;
    }
    return TreeKLeveSize(root->left,k-1)+TreeKLeveSize(root->right,k-1);
}

// 树的深度
int TreeDeep(BT* root)
{
    if(root==NULL)
    {
        return 0;
    }
    int left = TreeDeep(root->left);
    int right = TreeDeep(root->right);
    if(left>right)
    {
        return left+1;
    }
    else
    {
        return right+1;
    }

}


// 查询 树中的某一个节点是否存在
BT* TreeNode(BT* root,TreeDatatype x)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->data==x)
    {
        return root;
    }
    BT* left = TreeNode(root->left,x);
    BT* right = TreeNode(root->right,x);

    if(left!=NULL)
    {
        return left;
    }
    if(right!=NULL)
    {
        return right;
    }
    return NULL;
}

// 二叉树的销毁
// 从后往前销毁-------后续思想
// 进行遍历然后在销毁
void DestoryTree(BT*root)
{
    if(root==NULL)
    {
        return;
    }
    DestoryTree(root->left);
    DestoryTree(root->right);
    free(root);
}



int main()
{
    BT* tree = CreatTree();

    printf("树的前序遍历 >\n");
    PreOrder(tree);
    printf("\n");
    printf("\n");
    printf("树的中序遍历 >\n");
    InOrder(tree);
    printf("\n");
    printf("\n");

    printf("树的后序遍历 >\n");
    PastOrder(tree);
    printf("\n");
    printf("\n");

    int size = 0;
    printf("树的节点个数\n");
    size = TreeSize(tree);
    printf("%d\n",size);

    printf("\n");
    int sizeLeve = 0;
    printf("树的叶子节点个数\n");
    int i = 0;
    TreeLeveSize1(tree,&i);
    printf("%d\n",i);
    printf("\n");

    int SizeLeve = 0;
    printf("树的叶子节点个数1\n");
    SizeLeve = TreeLeveSize2(tree);
    printf("%d\n",SizeLeve);
    printf("\n");

    int ksize = 0;
    printf("树的第K层节点个数\n");
    ksize = TreeKLeveSize(tree,3);
    printf("%d \n",ksize);
    printf("\n");

    int deep = 0;
    printf("树的深度\n");
    deep = TreeDeep(tree);
    printf("%d \n",deep);
    printf("\n");
    printf("\n");

    BT* tre;
    int x;
    printf("请输入你要在树中查询的数值：>\n");
    scanf("%d",&x);
    tre = TreeNode(tree,x);
    if(tre==NULL)
    {
        printf("没有你要查询的数据");
    }
    else
    {
         printf("查询到了：%d\n",tre->data);
    }

    // 销毁这颗树
    DestoryTree(tree);
    tree = NULL;
    return 0;
}

💦视图
从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言

二、共勉

以下就是我对数据结构---二叉树遍历的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对数据结构-------二叉树的面试题型，请持续关注我哦！！！！！  

从此节点开始遍历二叉树,数据结构,数据结构,算法,c语言文章来源地址https://www.toymoban.com/news/detail-786627.html

到了这里，关于【数据结构】二叉树遍历的实现（超详细解析，小白必看系列）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构|二叉树遍历】递归与非递归实现前序遍历、中序遍历、后序遍历

    【数据结构|二叉树遍历】递归与非递归实现前序遍历、中序遍历、后序遍历

    递归与非递归实现二叉树的前序遍历、中序遍历、后序遍历。 二叉树图 定义 前序遍历（Preorder Traversal）： 前序遍历的顺序是先访问根节点，然后按照先左后右的顺序访问子节点。对于上面的二叉树，前序遍历的结果是：4 - 2 - 1 - 3 - 6 - 5 - 7。 中序遍历（Inorder Traversal）： 中

    2024年02月14日
    浏览(34)
  • 数据结构——二叉树（先序、中序、后序及层次四种遍历（C语言版））超详细~ (✧∇✧) Q_Q

    数据结构——二叉树（先序、中序、后序及层次四种遍历（C语言版））超详细~ (✧∇✧) Q_Q

    目录     二叉树的定义： *特殊的二叉树：  二叉树的性质：  二叉树的声明：   二叉树的先序遍历：  二叉树的中序遍历：  二叉树的后序遍历： 二叉树的层序遍历：  二叉树的节点个数： 二叉树叶节点个数：   最后完整代码： 运行结果：  二叉树是n（n≥0）个结点的

    2024年02月01日
    浏览(29)
  • Java 数据结构篇-二叉树的深度优先遍历（实现：递归方式、非递归方式）

    Java 数据结构篇-二叉树的深度优先遍历（实现：递归方式、非递归方式）

    🔥博客主页： 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍    文章目录         1.0 二叉树的说明         1.1 二叉树的实现         2.0 二叉树的优先遍历说明         3.0 用递归方式实现二叉树遍历         3.1 用递归方式实现遍历 - 前序遍历         3.2 用递归

    2024年02月05日
    浏览(40)
  • 【算法与数据结构】二叉树的三种遍历代码实现（下）—— 非递归方式实现（大量图解）

    【算法与数据结构】二叉树的三种遍历代码实现（下）—— 非递归方式实现（大量图解）

     上篇： 【算法与数据结构】二叉树的三种遍历代码实现（上）—— 用递归序知识点讲解_Hacynn的博客-CSDN博客 https://blog.csdn.net/zzzzzhxxx/article/details/133609612?spm=1001.2014.3001.5502 目录 前言 1、先序遍历 1.1、详细图解描述 1.2、先序遍历非递归代码实现  2、中序遍历 2.1、详细图解描

    2024年02月08日
    浏览(28)
  • 【数据结构】二叉树＜遍历＞

    【数据结构】二叉树＜遍历＞

    在学习二叉树遍历之前我们先了解下二叉树的概念。 二叉树是： 1.空树 2.非空：根节点，根节点的左子树，根节点的右子树构造。 学习二叉树结构，最简单的方式就是遍历了。 二叉树的遍历就是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个节点只

    2023年04月11日
    浏览(44)
  • 【数据结构】二叉树（遍历，递归）

    【数据结构】二叉树（遍历，递归）

     🌈个人主页： 秦jh__https://blog.csdn.net/qinjh_?spm=1010.2135.3001.5343 🔥 系列专栏： 《数据结构》https://blog.csdn.net/qinjh_/category_12536791.html?spm=1001.2014.3001.5482 ​​​ 目录 二叉树遍历规则 前序遍历 ​ 中序遍历  后序遍历 递归结构遍历 前序 中序  求节点个数 求叶子节点个数  求树

    2024年01月19日
    浏览(31)
  • 【算法与数据结构】二叉树的三种遍历代码实现（上）—— 用递归序知识点讲解

    【算法与数据结构】二叉树的三种遍历代码实现（上）—— 用递归序知识点讲解

      本篇博客 （上篇） 先带大家学习 递归方式 进行三种遍历， 而在后续的 （下篇） 中将为大家详细讲解非递归的三种遍历方式。 目录 1、二叉树 2、二叉树的递归遍历 2.1、先序遍历 2.2、中序遍历 2.3、后序遍历  二叉树（Binary tree）是树形结构的一个重要类型。许多实际问

    2024年02月08日
    浏览(31)
  • 【数据结构】二叉树的遍历

    【数据结构】二叉树的遍历

      Yan-英杰的主页 悟已往之不谏 知来者之可追    C++程序员，2024届电子信息研究生 目录 前序、中序以及后序遍历 前序遍历 中序遍历 后序遍历                  学习二叉树结构，最简单的方式就是遍历。所谓 二叉树遍历 (Traversal) 是按照某种特定的规则，依次对二叉

    2023年04月23日
    浏览(32)
  • 数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似

    数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似

       建立一棵二叉树，试编程实现二叉树的如下基本操作。    1.创建一棵一棵二叉算法。    2.对这棵二叉树进行遍历：先序或中序或后序，分别输出结点的遍历序列。    3.求二叉树的深度/节点数目/叶节点数目。（选做一个）    4.计算二叉树中度为1 的结点数；

    2024年02月06日
    浏览(38)
  • 数据结构——二叉树层序遍历

    数据结构——二叉树层序遍历

    来喽来喽~ 二叉树的层序遍历来喽~ 层序遍历那是相当有趣滴！ 我的朋友，请不要迷惘，你要记住，你终有鲲鹏一日！ 加油吧！从现在开始~ 层序遍历 ：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所

    2024年02月07日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包