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

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

9月前 作者：鳄鱼麻薯球 分类：Toy博客 阅读(57) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

数据结构上机实验

1.要求

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

            

2.二叉树的实现

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

2.1创建一颗二叉树

  我们现在可以简单实现一个二叉树的结构，其中包括一个二叉树节点（BNode）和一个二叉树（BTree）类。

  我们定义了一个名为BNode的结构体，它代表二叉树的节点。每个节点包含一个数据元素（data，其类型为int）和两个指向其左右子节点的指针（left和right）。

  然后定义了一个名为BTree的类，它包含一个私有成员变量_root，这是一个指向BNode的指针。这个指针表示了树的根节点。这个类还包含一个默认的构造函数，该构造函数将_root初始化为nullptr，即没有初始的根节点。

#define BTDataType int

//定义二叉树节点
typedef struct BTreeNode
{
	BTDataType data;
	struct BTreeNode* left;
	struct BTreeNode* right;
}BNode;

//定义二叉树
class BTree
{
public:
	//构造函数
	BTree()
	{
		_root = nullptr;
	}
	
private:
	BNode* _root;
};

  
输入字符递归创建二叉树：
  我们先使用引用接受一个 BNode*类型的参数 root。这样我们就可以在函数内部，直接对 root 进行操作，最后返回给tmp，再赋给_root。

  这个函数首先从标准输入读取一个字符 val。如果 val 是 . ，则 root 被设置为 nullptr，表示该节点为空。如果 val 不是 .，则创建一个新的 BNode 对象，其 data 成员的值为 val 减去字符 ‘0’ 的 ASCII 值（这样可以获得一个整数），然后递归地创建这个新节点的左子树和右子树。最后，_BTCreate 返回，控制权回到调用该函数的代码。

//递归创建二叉树
void _BTCreate(BNode*& root)
{
	char val;
	cin >> val;
	if (val == '.') root = nullptr;
	else
	{
		root = new BNode(val - '0');
		_BTCreate(root->left);
		_BTCreate(root->right);
	}
}

//递归创建二叉树
void BTCreate()
{
	BNode* tmp;
	_BTCreate(tmp);
	_root = tmp;
}

  

2.2对这棵二叉树进行遍历

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

前序遍历：

  我们创建_PreOrder(BNode* root)这个函数是用来前序遍历。它的顺序是：先访问根节点，然后访问左子树，最后访问右子树。

  如果 root 是 nullptr（即当前节点为空），它将输出 “NULL” 并返回。如果 root 非空，它会输出当前节点的数据（root->data），然后递归地对左子树和右子树进行前序遍历。

  由于二叉树的前序遍历是一个递归算法，为了可以将根节点不断的更新，并且递归。 我们需要封装一下，对于后面需要递归的函数，我们都需要将根节点作为参数，进行递归操作。

//前序遍历
void _PreOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	cout << root->data << " ";
	_PreOrder(root->left);
	_PreOrder(root->right);
}

//前序遍历
void PreOrder()
{
	_PreOrder(_root);
	cout << endl;
}

  
中序遍历：

  我们创建 _InOrder(BNode* root) 来进行中序遍历，它的顺序是：先访问左子树，然后访问根节点，最后访问右子树。

  如果 root 是 nullptr，表示当前节点为空，输出 “NULL” 并返回。如果 root 非空，先递归地遍历左子树，然后输出当前节点的数据 root->data，最后递归地遍历右子树。

//中序遍历
void _InOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	_InOrder(root->left);
	cout << root->data << " ";
	_InOrder(root->right);
}

//中序遍历
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

  
后序遍历：

  我们创建 _PostOrder(BNode* root) 函数来进行进行后序遍历，它的顺序是：先访问左子树，然后访问右子树，最后访问根节点。

  如果 root 是 nullptr，表示当前节点为空，输出 “NULL” 并返回。如果 root 非空，先递归地遍历左子树，然后递归地遍历右子树，最后输出当前节点的数据 root->data。

//后序遍历
void _PostOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	_PostOrder(root->left);
	_PostOrder(root->right);
	cout << root->data << " ";
}

//后序遍历
void PostOrder()
{
	_PostOrder(_root);
	cout<<endl;
}

  

2.3求二叉树的深度/节点数目/叶节点数目

计算二叉树深度：

  我们使用递归的方式来实现计算二叉树的深度。二叉树的深度可以定义为左子树和右子树深度的最大值加1。

  函数接受的参数root 是 NULL，即当前节点为空，那么返回深度为0。否则，递归地计算左子树和右子树的深度，并返回其中较大的一个，并加上1（当前节点的深度）。

//计算二叉树深度
int _BTDepth(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		int left_Height = _BTDepth(root->left) + 1;
		int right_Height = _BTDepth(root->right) + 1;
		if (left_Height >= right_Height) return left_Height;
		else return right_Height;
	}
}

//计算二叉树深度
int	BTDepth()
{
	return _BTDepth(_root);
}

  
计算二叉树节点数目：

  我们递归实现_Num_Of_TreeNode来计算二叉树的节点数目。

  首先我们接收一个指向二叉树节点的指针 root 作为参数。如果 root 是 NULL（也就是说，当前节点不存在），函数返回0。否则，则说明该二叉树的节点存在，函数返回1（对于当前节点） 加上左子树和右子树的节点数目。这是通过递归调用 _Num_Of_TreeNode 函数得到的。

//计算二叉树节点数目
int _Num_Of_TreeNode(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		return 1 + _Num_Of_TreeNode(root->left) + 
		_Num_Of_TreeNode(root->right);
	}
}

//计算二叉树节点数目
int Num_Of_TreeNode()
{
	return _Num_Of_TreeNode(_root);
}

  
计算二叉树叶子节点的数目:

  我们同样创建递归函数 _Num_Of_LeafNode来计算二叉树的叶子节点。

  我们接收一个指向二叉树节点的指针 root 作为参数。如果 root 是 NULL（也就是说，当前节点不存在），函数返回0。否则，函数首先递归地计算左子树和右子树的叶子节点数量，分别存储在 left_Num 和 right_Num 中。

  注意：如果 left_Num 和 right_Num 的和为0，这意味着当前节点是叶子节点，因此返回1。 如果 left_Num 和 right_Num 的和不为0，这意味着当前节点不是叶子节点，因此返回 left_Num 和 right_Num 的和。

//计算二叉树叶子节点的数目
int _Num_Of_LeafNode(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		int left_Num = _Num_Of_LeafNode(root->left);
		int right_Num = _Num_Of_LeafNode(root->right);
		if (left_Num + right_Num == 0)
		{
			return 1;
		}
		else
		{
			return left_Num + right_Num;
		}
	}
}

//计算二叉树叶子节点的数目
int Num_Of_LeafNode()
{
	return _Num_Of_LeafNode(_root);
}

  

2.4计算二叉树中度为 1 或 2 的结点数

  
计算度为1的节点个数：

  二叉树的递归函数大差不差，我们对于求不同的节点，只要加以它们的性质判断即可。

  如果二叉树的节点度为2，说明它们均有左右节点。 所以，此时函数返回的是左子树和右子树中1度节点的总和。

  只有右节点: 如果一个节点只有右子节点，那么它是1度节点。 因此，这个分支计算了右子树中的1度节点数量，并加上1（表示当前节点）。

  只有左节点: 与上述逻辑类似，如果一个节点只有左子节点， 那么它也是1度节点。这个分支计算了左子树中的1度节点数量，并加上1（表示当前节点）。

  无左右节点: 如果一个节点既没有左子节点也没有右子节点，那么它不是1度节点。函数返回0。

//计算度为1的节点个数
int _Num_Of_Degree_1(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else if (root->left == NULL && root->right != NULL 
	|| root->left != NULL && root->right == NULL)
	{
		return 1 + _Num_Of_Degree_1(root->left) + 
		_Num_Of_Degree_1(root->right);
	}
	return  _Num_Of_Degree_1(root->left) + 
	_Num_Of_Degree_1(root->right);
}

//计算二叉树节点数目
int Num_Of_TreeNode()
{
	return _Num_Of_TreeNode(_root);
}

  
计算度为2的节点个数：

  和上面一样，我们实现计算一个二叉树中度为2的节点的数量。度为2的节点是指有两个子节点的节点。

  如果 root 的左右子节点都不为空(root->left != NULL and root->right != NULL)，则说明当前节点的度为2，返回1（对于当前节点）加上左子树和右子树的度为1的节点数量之和。

  只有右子节点不为空，则只返回右子树的度为1的节点数量。

  只有左子节点不为空，则只返回左子树的度为1的节点数量。

  左右子节点都为空，则当前节点不是度为2的节点，返回0。

//计算度为2的节点个数
int _Num_Of_Degree_2(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else if(root->left != NULL && root->right != NULL)//均有左右节点
	{
		return 1 + _Num_Of_Degree_2(root->left) 
		+ _Num_Of_Degree_2(root->right);
	}
	return _Num_Of_Degree_2(root->right)+ _Num_Of_Degree_2(root->left);
}

//计算度为2的节点个数
int Num_Of_Degree_2()
{
	return _Num_Of_Degree_2(_root);
}

  

2.5判断2棵二叉树是否相似，若相似返回1，否则返回0

  这个函数是用来判断两棵二叉树是否相似的。相似二叉树的定义是：如果两棵二叉树的结构相同，即它们的左子树和右子树都是相似的，那么这两棵二叉树就是相似的。

  这个函数使用递归的方式进行检查。首先，如果两个节点都为空，那么它们显然是相似的。然后，如果两个节点都不为空，并且它们的左子树和右子树都是相似的，那么这两个节点也是相似的。 最后，如果以上条件都不满足，那么这两个节点就不相似。

//判断二叉树是否相似
int Is_Similar(BNode* t1, BNode* t2)
{
	if (t1 == NULL && t2 == NULL)
	{
		return 1;
	}
	else if (t1 && t2 && Is_Similar(t1->left, t2->left)
	 && Is_Similar(t1->right, t2->right))
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

            

3.全部源码

测试：

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

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

BinaryTree.h

#pragma once

#define BTDataType int

//定义二叉树节点
typedef struct BTreeNode
{
	BTDataType data;
	struct BTreeNode* left;
	struct BTreeNode* right;

	BTreeNode() 
	{
		data = -1;
		left = nullptr;
		right = nullptr;
	}

	BTreeNode(const int& _data)
	{
		data = _data;
		left = nullptr;
		right = nullptr;
	}
}BNode;

//定义二叉树
class BTree
{
public:
	//构造函数
	BTree()
	{
		_root = nullptr;

	}

	//析构函数
	~BTree()
	{
		DestroyTree(_root);
	}

	//递归创建二叉树
	void BTCreate()
	{
		BNode* tmp;
		_BTCreate(tmp);
		_root = tmp;
	}

	//前序遍历
	void PreOrder()
	{
		_PreOrder(_root);
		cout << endl;
	}

	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	//后序遍历
	void PostOrder()
	{
		_PostOrder(_root);
		cout<<endl;
	}

	//计算二叉树深度
	int	BTDepth()
	{
		return _BTDepth(_root);
	}

	//计算二叉树节点数目
	int Num_Of_TreeNode()
	{
		return _Num_Of_TreeNode(_root);
	}

	//计算二叉树叶子节点的数目
	int Num_Of_LeafNode()
	{
		return _Num_Of_LeafNode(_root);
	}

	//计算度为1的节点个数
	int Num_Of_Degree_1()
	{
		return _Num_Of_Degree_1(_root);
	}

	//计算度为2的节点个数
	int Num_Of_Degree_2()
	{
		return _Num_Of_Degree_2(_root);
	}

	//判断二叉树是否相似
	int Is_Similar(BNode* t1, BNode* t2)
	{
		if (t1 == NULL && t2 == NULL)
		{
			return 1;
		}
		else if (t1 && t2 && Is_Similar(t1->left, t2->left) && Is_Similar(t1->right, t2->right))
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}

	//判断二叉树是否相等
	int Is_Same(BNode* t1, BNode* t2)
	{
		if (t1 == NULL && t2 == NULL)
		{
			return 1;
		}
		else if (t1 && t2 && (t1->data == t2->data) 
			&& Is_Same(t1->left, t2->left) && Is_Same(t1->right, t2->right))
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}

	//取根节点
	BNode*& GetRoot()
	{
		return _root;
	}

private:
	//递归创建二叉树
	void _BTCreate(BNode*& root)
	{
		char val;
		cin >> val;
		if (val == '.') root = nullptr;
		else
		{
			root = new BNode(val - '0');
			_BTCreate(root->left);
			_BTCreate(root->right);
		}
	}

	//前序遍历
	void _PreOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}
	
		cout << root->data << " ";
		_PreOrder(root->left);
		_PreOrder(root->right);
	}

	//中序遍历
	void _InOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}

		_InOrder(root->left);
		cout << root->data << " ";
		_InOrder(root->right);
	}

	//后序遍历
	void _PostOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}

		_PostOrder(root->left);
		_PostOrder(root->right);
		cout << root->data << " ";
	}

	//计算二叉树深度
	int _BTDepth(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			int left_Height = _BTDepth(root->left) + 1;
			int right_Height = _BTDepth(root->right) + 1;
			if (left_Height >= right_Height) return left_Height;
			else return right_Height;
		}
	}

	//计算二叉树节点数目
	int _Num_Of_TreeNode(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			return 1 + _Num_Of_TreeNode(root->left) + _Num_Of_TreeNode(root->right);
		}
	}

	//计算二叉树叶子节点的数目
	int _Num_Of_LeafNode(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			int left_Num = _Num_Of_LeafNode(root->left);
			int right_Num = _Num_Of_LeafNode(root->right);
			if (left_Num + right_Num == 0)
			{
				return 1;
			}
			else
			{
				return left_Num + right_Num;
			}
		}
	}

	//计算度为1的节点个数
	int _Num_Of_Degree_1(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else if (root->left == NULL && root->right != NULL || root->left != NULL && root->right == NULL)
		{
			return 1 + _Num_Of_Degree_1(root->left) + _Num_Of_Degree_1(root->right);
		}
		return  _Num_Of_Degree_1(root->left) + _Num_Of_Degree_1(root->right);
	}

	//计算度为2的节点个数
	int _Num_Of_Degree_2(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else if(root->left != NULL && root->right != NULL)//均有左右节点
		{
			return 1 + _Num_Of_Degree_2(root->left) + _Num_Of_Degree_2(root->right);
		}
		return  _Num_Of_Degree_2(root->left) + _Num_Of_Degree_2(root->right);
	}

	//销毁二叉树
	void DestroyTree(BNode*& root) 
	{
		if (root == NULL) 
		{
			return;
		}

		BNode* lroot = root->left;
		BNode* rroot = root->right;
		delete root;
		if (lroot != NULL)
		{
			DestroyTree(lroot);
		}
		if (rroot != NULL)
		{
			DestroyTree(rroot);
		}
	}

private:
	BNode* _root;
};

            文章来源地址https://www.toymoban.com/news/detail-736452.html

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;
 
#include"BinaryTree.h" 

void binary_Test()
{
	BTree bt1;
	BTree bt2;
	cout << "输入第一棵树的前序遍历（空树请用 . 代替）:";
	bt1.BTCreate();
	cout << "输入第二棵树的前序遍历（空树请用 . 代替）:";
	bt2.BTCreate(); 
	cout << "第一棵树的前序遍历为:";
	bt1.PreOrder();
	cout << "第一棵树的中序遍历为:"; 
	bt1.InOrder();	
	cout << "第一棵树的后序遍历为:"; 
	bt1.PostOrder();
	cout << "第一棵树的深度为:" << bt1.BTDepth() << endl;
	cout << "第一棵树中的节点数:" << bt1.Num_Of_TreeNode() << endl;
	cout << "第一棵树中的叶子节点数:" << bt1.Num_Of_LeafNode() << endl;
	cout << "第一棵树中度为1的节点数:" << bt1.Num_Of_Degree_1() << endl;
	cout << "第一棵树中度为2的节点数:" << bt1.Num_Of_Degree_2() << endl;
	cout << endl;
	cout << "第二棵树的前序遍历为:";
	bt2.PreOrder();
	cout << "第二棵树的中序遍历为:";
	bt2.InOrder();
	cout << "第二棵树的后序遍历为:";
	bt2.PostOrder();
	cout << "第二棵树的深度为:" << bt2.BTDepth() << endl;
	cout << "第二棵树中的节点数:" << bt2.Num_Of_TreeNode() << endl;
	cout << "第二棵树中的叶子节点数:" << bt2.Num_Of_LeafNode() << endl;
	cout << "第二棵树中度为1的节点数:" << bt2.Num_Of_Degree_1() << endl;
	cout << "第二棵树中度为2的节点数:" << bt2.Num_Of_Degree_2() << endl;
	cout << "两棵树是否相似:" << bt1.Is_Similar(bt1.GetRoot(), bt2.GetRoot());
	cout << "两颗树是否相等:" << bt1.Is_Same(bt1.GetRoot(), bt2.GetRoot());
}

int main()
{
	binary_Test();
	return 0;
}

到了这里，关于数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

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

相关文章

  • 数据结构：二叉树的链式结构

    数据结构：二叉树的链式结构

    朋友们、伙计们，我们又见面了，本期来给大家解读一下链式二叉树的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ 数据结构与算法专栏 ：数据结构与算法 个  人  主  页 ：stackY、 C 语 言 专 栏 ：C语言：从入门到精通 目录 前言

    2024年02月07日
    浏览(56)
  • 数据结构——二叉树的链式结构

    数据结构——二叉树的链式结构

      个人主页 ： 日刷百题 系列专栏 ： 〖C语言小游戏〗〖Linux〗〖数据结构〗  〖C语言〗 🌎 欢迎各位 → 点赞 👍+ 收藏 ⭐️+ 留言 📝  ​ 这里我们使用先序遍历的思想来创建二叉树，这里的内容对于刚接触二叉树的朋友可能有些难理解，不妨先看完下面的二叉树各种遍历

    2024年02月05日
    浏览(43)
  • 【数据结构】二叉树的介绍和二叉树堆

    【数据结构】二叉树的介绍和二叉树堆

    💓作者简介： 加油，旭杏，目前大二，正在学习 C++ ， 数据结构 等👀 💓作者主页：加油，旭杏的主页👀 ⏩本文收录在：再识C进阶的专栏👀 🚚代码仓库：旭日东升 1👀 🌹欢迎大家点赞 👍 收藏 ⭐ 加关注哦！💖        树这一概念，在我们刚开始听说的时候会觉得

    2024年01月20日
    浏览(49)
  • 【数据结构】树，二叉树，满二叉树，完全二叉树的定义和二叉树的基本操作

    【数据结构】树，二叉树，满二叉树，完全二叉树的定义和二叉树的基本操作

    🎊专栏【数据结构】 🍔喜欢的诗句：更喜岷山千里雪 三军过后尽开颜。 🎆音乐分享【勋章】 大一同学小吉，欢迎并且感谢大家指出我的问题🥰 目录 ⭐树 🏳️‍🌈定义  🏳️‍🌈注意 🍔树的基本术语 ⭐二叉树 🏳️‍🌈定义 🎆二叉树和树的区别 🏳️‍🌈二叉树

    2024年02月05日
    浏览(66)
  • 【数据结构】二叉树的链式存储结构

    【数据结构】二叉树的链式存储结构

    前序遍历，又叫先根遍历。 遍历顺序：根 - 左子树 - 右子树 代码： 中序遍历，又叫中根遍历。 遍历顺序：左子树 - 根 - 右子树 代码 ： 后序遍历，又叫后根遍历。 遍历顺序：左子树 - 右子树 - 根 代码 ： 除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍

    2024年02月09日
    浏览(42)
  • 【数据结构】二叉树的概念及结构

    【数据结构】二叉树的概念及结构

    🚀write in front🚀 📜所属专栏： 初阶数据结构 🛰️博客主页：睿睿的博客主页 🛰️代码仓库：🎉VS2022_C语言仓库 🎡您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！ 关注我，关注我，关注我 ， 你们将会看到更多的优质内容！！ 树是一种 非线性的数据结构

    2023年04月23日
    浏览(42)
  • 【数据结构 —— 二叉树的链式结构实现】

    【数据结构 —— 二叉树的链式结构实现】

    树是一种非线性的数据结构，它是由n（n=0）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 1.有一个 特殊的结点，称为根结点 ，根节点没有前驱结点 2.除根节点外， 其余结点被分成M(M0)个互不相交

    2024年02月05日
    浏览(54)
  • 【数据结构】二叉树的顺序结构-堆

    【数据结构】二叉树的顺序结构-堆

    普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而 完全二叉树 更适合使用顺序结构存储。 现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个

    2024年02月09日
    浏览(48)
  • 数据结构：二叉树的顺序结构--堆

    数据结构：二叉树的顺序结构--堆

    朋友们、伙计们，我们又见面了，本期来给大家解读一下二叉树--堆的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ C 语 言 专 栏：C语言：从入门到精通 数据结构专栏：数据结构 个  人  主  页 ：stackY、 目录 前言： 1.堆的概念及

    2024年02月06日
    浏览(44)
  • 【数据结构—二叉树的链式结构实现】

    【数据结构—二叉树的链式结构实现】

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、二叉树的存储结构 二、二叉树链式结构的实现 2.1手动构建一课树 2.2二叉树的遍历 三、二叉树链式结构的实现 3.1前序遍历(递归) 3.2中序遍历(递归) 3.3后序遍历(递归) 3.4层序遍历(非递

    2024年02月03日
    浏览(56)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包