【数据结构之二叉树系列】万字深剖普通二叉树的遍历+分治算法思想

已于 2023-01-27 19:06:33 修改
阅读量866 收藏 11
点赞数 20
文章标签： 数据结构 算法 java
于 2023-01-25 23:37:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63019745/article/details/128762781
版权

目录

前言

前面我们学习的数据结构主要是线性表，我们在学习的时候主要是学习对数据结构中的数据进行增删查改，但是我们会发现，对于普通的二叉树而言，插入一个数据可以在很多地方进行插入，删除数据也可以在很多地方进行删除，同样的道理，在没有一定规律的情况下，想要在普通的二叉树中进行查找数据也是很麻烦的，修改也是一样的道理，所以，学习普通二叉树的增删查改是没有任何意义的，今天我们重点学习的是二叉树的几种重要的遍历方式：前序遍历，中序遍历，后序遍历，层序遍历。其中，前面三种遍历方式需要我们对递归有一个很深层次的理解才能够搞懂！！！今天我们主要以下面这棵树作为例子进行讲解。
在这里插入图片描述

一、背景知识

在学习二叉树的遍历之前我们需要知道，二叉树中可以分为很多的子树，每一棵子树都是由对应的根节点和左右子树组成的，其中根节点和左右子树都是有可能为空的，这个视具体情况而定。这个基本知识可以为后面学习递归和分治算法思想做很大的铺垫。任何的子树可能存在的情况为：空树，只有根节点，只有左子树，只有右子树，同时存在左右子树。

  • 空树：即根节点为空指针的情况
  • 只有根节点：根节点不为空，但是左右子树均为空
  • 只有左子树：根节点和左子树不为空，右子树为空
  • 只有右子树：根节点和右子树不为空，左子树为空
  • 同时存在左右子树：根节点和左右子树均不为空

对应的就是下图的情况：
在这里插入图片描述

二、前序遍历

我们知道，树中的任何子树都是由根节点和左右子树构成的，对于每一棵子树而言，前序遍历方式的规则是：根节点，左子树，右子树。也就是说，我们可以将一棵树想象成很多的子树，我们在遍历一棵二叉树的时候，需要将所有的子树全部遍历完，而遍历方式就是规定了树中的遍历规则，即每一棵子树应该按照什么样的顺序去遍历访问。下面我们使用前序遍历的方式来详细介绍下图的遍历：
在这里插入图片描述

遍历过程：首先访问的是A结点对应的树，而A结点对应的树是由A结点和对应的左右子树构成的，根据前序遍历的方式，先访问的是A结点，然后访问A结点的左子树，A结点对应的左子树的根节点是B结点，所以接下来访问的就是B结点对应的树，B结点对应的树同样是由B结点和对应的左右子树构成，根据前序遍历的方式，先访问的是B结点，然后访问B结点的左子树，B结点对应的左子树就是D节点对应的树了，D结点对应的树是由D结点和对应的左右子树构成的，访问D结点的树时，先访问D结点，然后访问D结点对应的左子树，D结点对应的左子树是H结点对应的树，H结点对应的树同样是由D结点和对应的左右子树构成，访问H结点的树时先访问H结点，然后再访问H结点对应的左子树，我们会发现，当我们在访问H结点的左子树时，发现H结点的左子树是空，所以此时就会返回到H结点，此时对于H结点对应的树而言，H结点对应的树的根节点和左子树已经访问完成，所以接下来访问的就是H结点的右子树了，H结点的右子树是K结点对应的树，K结点对应的树是由K结点和对应的左右子树构成，访问K结点时，先访问的是K结点，然后访问K结点的树的左子树，访问K结点的左子树时，发现为空，所以此时应该访问K结点的右子树，发现也为空，所以此时会返回到H结点，H结点遍历完成，返回到D结点，此时相当于D结点的左子树遍历完成，所以接下来访问的是D结点的右子树，发现为空，返回到B结点，此时B结点对应的左子树访问完成，继续访问B结点的右子树，也就是E结点对应的树，E结点对应的树是由E结点和对应的左右子树构成，访问E树时，先访问E结点，再访问E树的左子树，访问E树的左子树时，发现为空，返回到E树，再访问右子树，发现为空，返回到B树，此时B树访问完成，也就是A树的左子树访问完成，接下来访问的就是A树的右子树了，情况和上面一样。

最后的遍历顺序为：
在这里插入图片描述
即：
在这里插入图片描述

  • 代码实现
typedef int BTDataType;
// 链式二叉树的定义
typedef struct BinaryTreeNode
{
	BTDataType data;  // 数据域
	struct BinaryTreeNode* left;// 指向左子树的指针
	struct BinaryTreeNode* right;// 指向右子树的指针
}BTNode;

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

BTNode* CreateBinaryTree(BTDataType data)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		return NULL;
	}
	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;
	return newnode;
}

int main()
{
// 手动创建树的结点
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);
// 手动将创建的结点链接起来
	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	PrevOrder(Node1);
	return 0;
}
  • 实验结果
    在这里插入图片描述
    根据上面对于前序遍历的分析，这里不难分析出这个结果。

三、中序遍历

中序遍历方式的规则是：左子树，根节点，右子树。注意在分析的过程是要将树分成很多子树进行访问的。这里同样以上面这棵树作为例子进行分析：
在这里插入图片描述

遍历过程： 首先给到树的根节点，所以先访问到A树，但是访问A树时，需要先访问A树的左子树，所以接下来访问A树的左子树，A树的左子树是B树，访问B树时，需要先访问B树的左子树，接下来访问B树的左子树，B树的左子树是D树，访问D树时，需要先访问D树的左子树，D树的左子树是H树，访问H树时需要先访问H树的左子树，当我们访问H树的左子树时，我们发现H树的左子树是空树，所以直接返回到H树，那么H树的左子树访问完成之后就应该访问H树的根节点也就是H结点，H结点返回完之后返回H树的右子树，H树的右子树是K树，访问K树时需要先访问K树的左子树，当我们访问K树的左子树时，发现K树的左子树为空，所以返回到K树，继续访问K树的根节点，也就是K结点，再访问K树的右子树，K树的右子树为空，所以返回到H树，H树的右子树访问完成，返回到D树，D树的左子树访问完成，继续访问D树的根节点，也就是D结点，再访问D树的右子树，D树的右子树为空，返回到B树，B树的左子树访问完成，继续访问B树的根节点，也就是B结点，再访问B树的右子树，B树的右子树为E树，访问E树时需要先访问E树的左子树，E树的左子树为空，返回到E树，继续访问E树的根节点，也就是E结点，再访问E树的右子树，E树的右子树为空，返回到B树，B树的右子树访问完成，即B树访问完成，即A树的左子树访问完成，这个时候才可以访问A树的根节点，也就是A结点，再继续访问A树的右子树，访问A树的右子树的过程和访问A树的左子树一模一样。

最终的访问顺序为：
在这里插入图片描述
即：
在这里插入图片描述

  • 代码实现
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

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

BTNode* CreateBinaryTree(BTDataType data)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		return NULL;
	}
	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;
	return newnode;
}

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	InOrder(Node1);
	return 0;
}
  • 实验结果
    在这里插入图片描述

四、后序遍历

后序遍历的规则是：左子树，右子树，根节点。
在遍历的过程中同样需要将待分析的树分成很多的子树，然后依次分析每棵子树的访问，访问每一棵子树的时候，都需要知道每一棵子树都是由根节点和左右子树构成，根据后序遍历的规则，需要先遍历左子树，再遍历右子树，最后遍历根节点。这里同样以上面这棵树作为例子进行分析：
在这里插入图片描述

遍历过程： 首先给到的条件是树的根节点，所以肯定从根节点进行分析，首先访问A树，访问A树时，需要先访问A树的左子树，A树的左子树是B树，访问B树时需要先访问B树的左子树，B树的左子树是D树，访问D树时，需要先访问D树的左子树，D树的左子树是H树，访问H树时，需要先访问H树的左子树，H树的左子树是空树，所以返回到H树，继续访问H树的右子树，H树的右子树是K树，访问K树时，先访问K树的左子树，K树的左子树是空树，返回到K树，继续访问K树的右子树，K树的右子树为空树，返回到K树，再访问K树的根节点，也就是K结点，K树访问完成之后，H树的右子树访问完成，继续访问H树的根节点，也就是H结点，H树访问完成之后，相当于D树的左子树访问完成，继续访问D树的右子树，D树的右子树为空，返回到D树，继续访问D树的根节点，也就是D结点，D树访问完成之后，相当于B树的左子树访问完成，继续访问B树的右子树，B树的右子树是E树，访问E树时，需要先访问E树的左子树，E树的左子树是空，返回到E树，继续访问E树的右子树，E树的右子树为空，返回到E树，继续访问E树的根节点，也就是E结点，E树访问完成之后，相当于B树的右子树访问完成，返回到B树，继续访问B树的根节点，也就是B结点，B树访问完成之后，相当于A树的左子树访问完成，然后继续访问A树的右子树，访问过程和访问A树的左子树一模一样，当A树的右子树访问完成之后，最后再继续访问A树的根节点，也就是A结点，当A树访问完成之后，整棵树的遍历即完成。

  • 最终的访问顺序为：
    在这里插入图片描述
    即：
    在这里插入图片描述

  • 代码实现：

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

typedef int BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

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

BTNode* CreateBinaryTree(BTDataType data)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		return NULL;
	}
	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;
	return newnode;
}

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	PostOrder(Node1);
	return 0;
}
  • 实验结果：
    在这里插入图片描述

五、求二叉树中结点的个数

1. 遍历+计数

（1）前序遍历+计数
  • 代码实现
// 求结点个数
int count = 0;
void TreeNodeSize1(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	// 前序遍历
	count++;
	TreeNodeSize1(root->left);
	TreeNodeSize1(root->right);
}

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);
	return 0;
}
  • 实验结果
    在这里插入图片描述
（2）中序遍历+计数
  • 代码实现
// 求结点个数
void TreeNodeSize2(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	// 中序遍历
	
	TreeNodeSize2(root->left);
	count++;
	TreeNodeSize2(root->right);
}

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	TreeNodeSize2(Node1);

	printf("TreeNodeSize:%d\n", count);
	return 0;
}
  • 实验结果
    在这里插入图片描述
（3）后序遍历+计数
  • 代码实现
// 求结点个数
void TreeNodeSize3(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	// 后序遍历

	TreeNodeSize3(root->left);
	TreeNodeSize3(root->right);
	count++;
}

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;


	TreeNodeSize3(Node1);

	printf("TreeNodeSize:%d\n", count);
	return 0;
}
  • 实验结果
    在这里插入图片描述
    注意：
    上面三种遍历+计数的方式虽然通过上面的测试可以计算出二叉树中结点的个数，但是如果多次调用就会出现一些问题，我们以前序为例：
int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;


	 TreeNodeSize1(Node1);
	 printf("TreeNodeSize:%d\n", count);

	TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);

	TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);
	return 0;
}
  • 实验结果
    在这里插入图片描述
    我们会发现，上面的结果显然被累加了，所以结果显然是错误，因为我们是通过一个全局变量的计数器count来计数二叉树中结点的个数，所以我们每次在进行计数之前需要对计数器进行清零，防止累加。
  • 代码实现
int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	count = 0;
	 TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);
	
	count = 0;
	TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);

	count = 0;
	TreeNodeSize1(Node1);
	printf("TreeNodeSize:%d\n", count);
	return 0;
}
  • 实验结果
    在这里插入图片描述

2.分治算法思想（推荐）

分治算法思想的本质其实也是一种递归的算法思想，其原理是通过将原来的问题分解为子问题，直到不能再分解为止。
像在使用分治算法思想求解二叉树的结点个数时，我们可以将求解的结点个数转换成：待求树的左子树的结点个数+右子树的结点个数+根节点，树中的每一棵子树都是采用这种递归的形式进行求解，直到递归到叶子节点时，叶子节点的左右子树均是空，此时返回的就是叶子结点本身的个数，也就是1，然后依次返回，最终即可求得结果。

  • 代码实现
// 求结点个数
size_t TreeNodeSize4(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return TreeNodeSize4(root->left) + TreeNodeSize4(root->right) + 1;

int main()
{
	BTNode* Node1 = CreateBinaryTree(1);
	BTNode* Node2 = CreateBinaryTree(2);
	BTNode* Node3 = CreateBinaryTree(3);
	BTNode* Node4 = CreateBinaryTree(4);
	BTNode* Node5 = CreateBinaryTree(5);
	BTNode* Node6 = CreateBinaryTree(6);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	
	printf("TreeNodeSize:%zu\n", TreeNodeSize4(Node1));

	
	return 0;
}
}
  • 实验结果
    在这里插入图片描述

六、求叶子结点个数

我们知道叶子结点就是左右孩子均为空的结点，明白这一点之后，我们就很好处理了。

  • 代码实现
// 求树中叶子结点的个数
int TreeLeafSize(TreeNode* root)
{
	if (root == NULL)
	{
		// 空树
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

  • 思路分析：

  • 测试代码：


// 创建并初始化树的结点
TreeNode* BuyTreeNode(TreeDataType data)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		return NULL;
	}

	newnode->data = data;
	newnode->left = newnode->right = NULL;
	return newnode;
}
// 创建树
TreeNode* CreateTree()
{
	TreeNode* Node1 = BuyTreeNode(1);
	TreeNode* Node2 = BuyTreeNode(2);
	TreeNode* Node3 = BuyTreeNode(3);
	TreeNode* Node4 = BuyTreeNode(4);
	TreeNode* Node5 = BuyTreeNode(5);
	TreeNode* Node6 = BuyTreeNode(6);

	// 手动链接
	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;

	return Node1;
}

int main()
{
	TreeNode* root = CreateTree();

	// 叶子结点个数
	int leaf = TreeLeafSize(root);
	printf("Tree Leaf Size:%d\n", leaf);

	return 0;
}
  • 测试结果：
    在这里插入图片描述

七、求第K层的结点个数

这个问题首先需要分析K的取值，首先K作为层数的话，K肯定不能为负数。

  • 代码实现
// 求第K层的结点个数
int TreeKLevelSize(TreeNode* root ,int k)
{
	assert(k > 0);
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}

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

  • 思路分析

  • 测试代码：

int main()
{
	TreeNode* root = CreateTree();

	int first = TreeKLevelSize(root, 1);
	printf("First Size:%d\n", first);

	int second = TreeKLevelSize(root, 2);
	printf("Second Size:%d\n", second);

	int third = TreeKLevelSize(root, 3);
	printf("Third Size:%d\n", third);


	return 0;
}
  • 测试结果
    在这里插入图片描述

八、树的深度

  • 代码实现
// 树的深度
int TreeDepth(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int leftDepth = TreeDepth(root->left);
	int rightDepth = TreeDepth(root->right);

	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

  • 思路分析

  • 测试代码

int main()
{
	TreeNode* root = CreateTree();

	// 树的深度
	printf("Tree Depth:%d\n", TreeDepth(root));

	return 0;
}
  • 测试结果
    在这里插入图片描述

九、树的销毁

  • 代码实现

  • 思路分析

  • 测试结果

销毁前
在这里插入图片描述
销毁后
在这里插入图片描述

楠鹤晴
关注
  • 20
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
【数据结构】二叉树的分治
ProcedureStone的博客
04-01 758
在【数据结构】二叉树的遍历中，我们学习了二叉树的遍历，并通过动图演示加深了印象。在文章最后，我提到了二叉树的其他操作，列如求二叉树的节点个数等，这些操作采用的算法思想并非遍历，而是分治。本文将为你介绍二叉树的分治。二叉树的分治是一种常用的算法思想，它利用二叉树的递归结构，将复杂的问题分解为两个或多个相同或相似的子问题，然后递归地求解子问题，最后合并子问题的解得到原问题的解。二叉树的分治可以有效地降低时间复杂度和空间复杂度，提高算法的效率和可读性。
【遍历】LeetCode二叉树的遍历、深度系列
鹏啊鹏
07-06 300
LeetCode中树的前序、中序、后序遍历，以及树的最大最小深度等。
使用分治法求解二叉树的相关问题
CL2426的博客
04-10 1311
用分治法求二叉树的节点个数，树的深度，第K层节点个数，判断是否为单值二叉树
二叉树之求解节点个数类算法归纳
bradyM的博客
04-14 5242
二叉树求解节点个数类一、求二叉树中节点总数二、求二叉树中度为0的节点个数三、求二叉树中度为1的节点个数四、求二叉树中度为2的节点个数五、求二叉树第k层节点个数六、结果展示 以此树为例： 一、求二叉树中节点总数 int getNodeNumRec(BiTree* T) { if (T == NULL) { return 0; } else { return getNodeNumRec(T->lchild) + getNodeNumRec(T->rchild) + 1 ; }
【数据结构】树和二叉树
hhhkkksa的博客
01-11 172
数据结构
JavaScript数据结构之二叉树的遍历算法示例
10-20
在JavaScript中，理解并实现二叉树的遍历算法对于处理复杂的数据操作至关重要。本篇文章将详细介绍二叉树的三种遍历方法：中序遍历、先序遍历和后序遍历，并通过具体的JavaScript代码示例来阐述这些算法。 1. **...
JavaScript+二叉树+算法+广度遍历和深度遍历+前端面试
最新发布
02-04
给定一个二叉树的数据结构，通过JavaScript实现二叉树的广度遍历和深度遍历。
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
Java实现二叉树的深度优先遍历和广度优先遍历算法示例 本文主要介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，结合实例形式详细分析了二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现...
二叉树的操作之统计二叉树中节点的个数
weixin_34200628的博客
04-19 4193
一，问题描述 给定一颗二叉树，已知其根结点。 ①计算二叉树所有结点的个数 ②计算二叉树中叶子结点的个数 ③计算二叉树中满节点（度为2）的个数   二，算法分析 找出各个问题的基准条件，然后采用递归的方式实现。 ①计算二叉树所有结点的个数 1)当树为空时，结点个数为0，否则为根节点个数 加上 根的左子树中节点个数 再加上 根的右子树中节点的个数 借助遍历二叉树的思路，每访问一个结...
【二叉树的分治思想】二叉树的基本操作
qq_43727529的博客
04-11 1006
文章目录一：分治算法二：基本思想三：解题步骤四：二叉树应用4.1 二叉树节点个数4.2 叶子节点个数4.3 二叉树深度4.4 二叉树第k层节点个数 一：分治算法 分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。即一种分目标完成程序算法，简单问题可用二分法完成。 二：基本思想 当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，.
分治法丨二叉树的前序遍历
一米阳光给的温暖
05-29 562
分治法在二叉树遍历中是一种深度优先遍历（DFS），将问题拆解成子问题后，然后合并子问题。 分解：拆解为规模更小的子问题，将问题拆解为足够小时，然后求解。 合并：将每个子问题结果进行合并，然后完成整体问题。 class Solution { public List<Integer> preorderTraversal(TreeNode root) { // 结束条件 if(root==null){ ArrayList<Int
【数据结构】二叉树 —— 遍历二叉树 + 递归的分治（链式存储）
上上谦. 的博客
04-22 2573
文章目录前言：1. 二叉树的四种遍历结构：1.1 二叉树结构划分：1.2 二叉树的遍历结构：2.递归的分治思想3. 链式二叉树的创建：（BinaryTree）1.1 具体函数实现：1.2 创建二叉树1.2 前序遍历1.3 中序 / 后序遍历1.4 树中结点个的数分治思想测试函数 前言： 学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。 访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运
剑指Offer--039-二叉树的深度
OSKernelLAB(gatieme)
05-07 2046
链接 牛客OJ：二叉树的深度 九度OJ：http://ac.jobdu.com/problem.php?pid=1350 GitHub代码： 039-二叉树的深度 CSDN题解：剑指Offer–039-二叉树的深度 牛客OJ 九度OJ CSDN题解 GitHub代码 039-二叉树的深度 1350-二叉树的深度 剑指Offer–039-二叉树
分治法求解二叉树深度
linyq@BambooFan ~
09-05 4246
算法 分治法 二叉树深度
qq_36523667的博客
11-08 1599
public class Test2 { static TreeNode t1; static int leftDepth = 1; static int rightDepth = 1; public static void main(final String[] args) throws Exception { initData();
计算二叉树中分支结点数的算法
小浦原的技术专栏
02-16 6220
//计算树中分支结点数int BranchNodes(BTNode *b){ int num1,num2,n; if(b==NULL) return 0; else if(b->lchild==NULL && b->rchild==NULL) n=0; else n=1; num1=BranchNodes(b->lchild); num2=Bra
求二叉树中分支结点的个数
认知 行动 坚持
11-05 8786
#include #define N 63 using namespace std; char str[] = "ab#d##c#e##"; int i = -1; typedef struct node { struct node *leftChild; struct node *rightChild; char data; }BiTreeNode, *Bi
计算给定二叉树的所有分支结点个数
vivi_and_qiao的博客
09-21 5973
二叉树存储结构定义： typedef struct Tnode { char data; struct Tnode *lnode; struct Tnode *rnode; }Tnode; typedef Tnode* type; 问题求解： int doublebranchcount8(Tnode *root) {//思路1：采用遍历算法遍历每一个结点，如果它既存在左孩子又存在右孩子则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值