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

最新推荐文章于 2024-08-17 14:41:09 发布
最新推荐文章于 2024-08-17 14:41:09 发布
阅读量1.8k 收藏 32
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45031801/article/details/133747485
版权

目录

一、前言

🍎为何使用链式二叉树 

 🍐何为链式二叉树

 🍉二叉树的构建

💦创建二叉链结构

💦手动构建一颗树 

🍓二叉树的遍历 （重点）

💦前序遍历

 💦中序遍历

 💦后续遍历

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

💦二叉树节点个数

 💦二叉树叶子节点的个数

 💦二叉树第K层节点个数

 💦二叉树的深度

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

 💦二叉树的销毁

🍊总代码和演示图

二、共勉

一、前言

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

🍎为何使用链式二叉树 

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

 
由上图得知，普通二叉树也可以使用数组来存储，但是会存在大量的空间浪费，而完全二叉树就不会这样，因为其空间利用率是％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; // 当前节点值域
};
💦 画图演示：


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


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

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

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


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

 🍉二叉树的构建

💦创建二叉链结构

创建二叉链结构其实就很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;
}

🍓二叉树的遍历 （重点）

以一颗二叉树为例：

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

💦前序遍历

  •  遍历规则：

前序遍历，也叫先根遍历

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

  • 思路：

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

  • 图示：

  •  代码演示：

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

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


跟我们先前画的图一模一样，让我们通过一副递归图来深刻理解其原理：

  • 递归图：

 💦中序遍历

  •  遍历规则：

中序遍历，也叫中根遍历

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

  • 思路：

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

  • 画图演示：


 

  •  代码演示：

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

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


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


 

 💦后续遍历

  •  遍历规则：

后续遍历，也叫后根遍历

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

  • 思路：

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

  • 画图演示：

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

  • 画图演示递归过程：


 

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

💦二叉树节点个数

  •  思想：

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

  • 法一：遍历

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

//节点个数
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;
}
  • 效果如下：

看似好像是成功了，确实结点个数为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);
}
  • 效果如下：


确实可以求出结点个数，并且也不会出现像法二一样的问题。但是其实定义全局变量也会存在一个小问题：线程安全的问题，这个等以后学到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;
}

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


 

 💦二叉树叶子节点的个数

  •  思路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);
}
  • 递归图：


 

 💦二叉树第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);

}
  • 递归图：


 

 💦二叉树的深度

  •  思路：

此题同样是运用分治的思想来解决，要比较左子树的高度和右子树的高度，大的那个就+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;
    }

}
  • 递归图：


 

 💦二叉树查找值为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

 

 💦二叉树的销毁

  •  思路：

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

  • 代码演示：
// 二叉树的销毁
// 从后往前销毁-------后续思想
// 进行遍历然后在销毁
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;
}

💦视图

二、共勉

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

sunny-ll
关注
专栏目录
【数据结构 Java 版】二叉树的实现（超多图、超详解）(1)
2401_84408780的博客
04-20 893
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
二叉树遍历算法实现(C#2.0)
akpaul6677的博客
09-23 180
二叉树遍历算法实现(C#2.0) Posted on 2006-09-20 17:42 xuanfeng 阅读(828) 评论(8) 编辑收藏 引用 收藏至365Key 本人用C#2.0实现了二叉树的定义，怎么构造一颗已知的二叉树，用几种常规的算法（先序，中序，后序，层次）遍历二叉树。希望能给有需要人带来帮助，也希望能得到大家的指点。有关C#数据结构的书在书店里找...
二叉树层序遍历讲解+题目
最新发布
2302_81982408的博客
08-17 430
层序遍历详解+算法题
二叉树的遍历及实现
aebe49167的博客
11-08 82
树是一种非线性的二维数据结构。 这里要说的是一种特殊的二叉树，叫对分查找树。特点在于：左子树的所有值都比根节点小，右子树的所有值都比根节点大。 对分查找树的三种遍历： 中序遍历(inOrder) 遍历左子树；处理节点中的值；遍历右子树。 前序遍历(preOrder) 处理节点中的值；遍历左子树；遍历右子树。 后序遍历...
数据结构——二叉树遍历
weixin_33840661的博客
06-20 260
二叉树遍历原理 二叉树的遍历：是指从根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次且仅被访问一次。 这里有两个关键词：访问和次序。 访问其实是要根据实际的需要来确定具体做什么，比如对每个结点进行相关计算，输出打印等。它算作是一个抽象操作。 二叉树的遍历次序不同于线性结构，最多也就是从头到尾、循环和双向等简单的遍历方式。树的结点之间不存在唯一的前驱和后继关系，在访问一个结...
数据结构之二叉树的遍历
weixin_30394981的博客
03-06 115
二叉树的遍历分为前序遍历，中序遍历，后序遍历，层序遍历，在本文中，前三种由递归实现，层序遍历由队列实现。 #include "stdio.h" #include "stdlib.h" #include "windows.h" typedef struct Node { char data; struct Node *Left; struct Nod...
10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等.rar
04-08
【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或...
105. 从前序与中序遍历序列构造二叉树
qq_36854740的博客
09-25 184
题目描述： 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 解题思路： 递归 class Solution: def buildTree(self, preorder: List[int], inorder: List[...
二叉树的四种遍历算法实现
tanqingbo的博客
03-21 222
你想要的IT学习资源，这里全都有点击上方蓝字“轮子工厂”一起玩耍二叉树的遍历我用下图的树为例，做树的遍历：二叉树结构树节点的定义：public class TreeNod...
二叉树遍历方法
qq_44813266的博客
05-27 469
方法一：先序遍历： 遍历顺序：根节点–>左孩子–>右孩子 遍历顺序：A–>B–>D–>H–>I–>E–>J–>C–>F–>G 先序遍历的递归实现： 很简单，自己想一下递归的过程就行 代码如下： #include<bits/stdc++.h. using namespace std; struct node//这是二叉树的基本结...
二叉树的遍历实现
LiYi
01-05 180
二叉树 tree 如图所示： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 根节点 root节点（所有节点由它开始，它没有父节点，只有孩子节点） 节点的度：节点拥有子树的个数 树的度：一棵树中所有节点的度的最大值 叶子节点：度为0的节点，没有子树的节点，终端节点（A,D,F,G） 分支节点：度不为0的节点，非终端节点(D,C,E) 兄弟节点：拥...
二叉树遍历实现
qq_41648804的博客
08-24 363
在二叉树的操作中，二叉树的遍历是基本的操作，对于二叉树的遍历操作，主要分为： 前序遍历 中序遍历 后序遍历 层次遍历 直接见代码： #include <iostream> #include <stack> #include <queue> #include <malloc.h> using namespace std; typedef struct BiTNode { int data; struct BiTNode *left,
【数据结构】二叉树遍历的实现
Black_Customer的博客
06-12 8267
递归实现二叉树遍历算法思想（1）先序遍历：（2）中序遍历（3）后序遍历二叉树示意图先序遍历中序遍历后续遍历代码实现 算法思想 按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示 （1）先序遍历： 访问根结点 先序遍历左子树 先序遍历右子树 （2）中序遍历 中序遍历左子树 访问根节点 中序遍历右子树 （3）后序遍历二叉树 后序遍历左子树 后序遍历右子树 访问根节点 示意图 先
数据结构-树-遍历二叉树
suxiaorui的博客
08-07 282
二叉树的存储结构 二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系。 将这棵二叉树存入数组中，相应的下标对应其同样的位置。 但是如果有一棵深度为k的右斜树，它只有k个结点，却需要分配个存储单元，很浪费空间，所以说，顺序存储结构一般只适用于完全二叉树。 二叉链表 二叉树每个结点最多有两个孩子，所以设计一个数据域和...
数据结构-二叉树的遍历
菜菜子&的博客
06-03 623
二叉树的遍历，数据结构复习！
二叉树遍历解析：Java实现与数据结构深度探讨
"二叉树的递归定义，遍历二叉树的策略，线索二叉树的概念，数据结构的基本组成，算法与算法分析" 在计算机科学中，数据结构是组织和存储数据的方式，以便更有效地执行算法。二叉树是一种重要的数据结构，它的递归...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值