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

已于 2023-11-01 08:58:57 修改
阅读量1.8k 收藏 24
点赞数 19
分类专栏： 数据结构 文章标签： 数据结构
于 2023-10-29 17:06:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crocodile1006/article/details/134102973
版权

文章目录

数据结构上机实验

1.要求

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

            

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对这棵二叉树进行遍历

在这里插入图片描述

前序遍历：

  我们创建_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.全部源码

测试：

在这里插入图片描述
在这里插入图片描述
  

在这里插入图片描述
在这里插入图片描述

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;
};

            

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;
}
鳄鱼麻薯球
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 30
    评论
专栏目录
6-129 统计二叉树叶子结点的个数（Python语言描述）
燕朝铭的博客
04-17 128
本题要求计算二叉树中有多少片树叶，输出格式见样例。
数据结构实验6：C++实现二叉树类
u25th_engineer的博客
11-19 2881
                                             实验6                                                                  学号：      姓名：      专业：   6.1 实验目的 掌握二叉树的动态链表存储结构及表示。 掌握二叉树的三种遍历算法（递归和非递归两类）。 运用二叉...
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
二叉树 — 层次/先序遍历/广义表创建、递归/非递归遍历输出，求深度、求结点/叶子结点数
Cap07博客
03-01 8465
#include<iostream> #include<queue> #include<stack> #include<string.h> #include<malloc.h> using namespace std; typedef char DataType; typedef struct BiTNode { DataType data; struct BiTNode* lchild, * rchild; }BiTNode, * B.
二叉树的前中后序遍历以及求深度、叶子节点和二叉树的重建
周小末天天开心的博客
04-03 922
二叉树的前中后序遍历以及求深度、叶子节点和二叉树的重建。理论+代码演示
数据结构实验8-二叉树遍历及应用
weixin_65113709的博客
04-19 1107
二叉树题解
详解二叉树四种遍历方式以及求节点数、叶子节点数、二叉树的深度，代码有详细注释【C++】
qq_45767189的博客
06-18 6684
详解二叉树四种遍历方式以及求节点数、叶子节点数、二叉树的深度，代码有详细注释【C++】
二叉树实验 （数据结构）
Popcorn_zyh的博客
11-03 1532
二叉树的遍历 数据结构 实验报告
Day16 算法学习|二叉树03 最大与最小深度/节点个数
m0_55811518的博客
06-07 539
给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例： 给定二叉树 [3,9,20,null,null,15,7]，
数据结构实验 二叉树的基本操作
热门推荐
weixin_45111284的博客
05-06 3万+
数据结构实验 二叉树的基本操作 实验环境： Visual C++ 实验目的： 1．掌握二叉树的定义； 2．掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深 度计算等。 实验内容： 用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度...
数据结构实验——树
qq_47703599的博客
04-21 868
数据结构实验——树 实验要求 1.查找并绘制自己家族的族谱二叉树； 2.族谱二叉树的建立（树的深度要>=4）； 3.三种不同遍历算法遍历此二叉树； 4.统计二叉树的深度，输出叶子结点的信息。 ...
数据结构实验——二叉树的建立和遍历.zip
12-13
5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1的；度为2的；总结点数。 6.用递归公式计算二叉树的高度（BiTreeDepth(BT)=0; 当二叉树空时（BT==NULL）。 BiTreeDepth(BT)=max{ ...
山东建筑大学计算机学院数据结构实验二：二叉树的遍历
03-31
3、实现统计二叉树叶子结点个数和计算二叉树深度的操作； 要求： 1、二叉链表结点类的定义； 2、二叉树类的定义； 3、创建一棵二叉树： 4、实现输出以上二叉树先序、中序和后序遍历序列中第k个数据元素的操作； 5、...
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
数据结构从入门到精通-二叉树的实现和遍历
最新发布
03-18
二叉树是数据结构中的重要概念，它是每个节点最多有两个子节点的树形结构，通常分为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求值等场景。本教程将带你从基础到深入地了解二叉树的...
数据结构与算法 实验二 二叉树的建立与遍历算法（C语言版）
weixin_64234293的博客
04-24 5221
实验目的： 1、掌握二叉树的定义。 2、二叉树的链式存储结构及在链式存储结构中三种遍历（前序，中序，后序）操作的实现及应用。 实验内容： 编写程序，实现以下功能： (1)建立一棵二叉树（以链表存储），对该二叉树进行遍历并输出该二叉树的前序，中序，后序遍历序列。要求前序、中序遍历用非递归方法，后序遍历用递归方法完成。 (2)实现二叉树左右子树的交换。 (3)统计二叉树中叶子结点个数。(要求用非递归算法完成) 基本要求： 1、写出完成实验内容的实验方法和源代码。 2、写出实验数据及运行结果。
[数据结构(C语言版本)上机实验]二叉树实验
weixin_49691084的博客
04-23 3385
二叉树的创建(先序遍历,中序遍历,后序遍历)+二叉树的高度+叶子节点的个数+找某节点的孩子,双亲,兄弟
关于树和二叉树的基本概念总结
jingsuxuyilq的专栏
03-09 5608
1.什么是（自由）树？ 树首先是无向图的一种，并且此无向图要满足下面两个特性： 1）连通，即任何两对顶点之间都有路径相连。 2）无回路，简单地说就是没有成环。 2.什么是森林？ 当满足树特性2）而不满足1）时称为森林。可以简单地理解为，什么不满足连通性，所以森林中可含有多个（自由）树。 3.树的特性 假设G = (V, E)是一个无向图，则下面的定义中等价的： 1）G是（自由）
《数据结构》上机实验(第七章) —树与二叉树Ⅰ
Miss Z的博客
08-29 2930
1. 已知一棵二叉树按顺序结构进行存储，求编号分别为i和j的两个结点最近的公共祖先节点的值。 算法思想：1)若i>j，则结点i所在层次大于等于结点j所在层次。结点i的双亲结点为结点i/2，若i/2=j，则结点i/2是原结点i和j结点的最近公共祖先结点，若i/2≠j。则令i=i/2，即以该结点的双亲结点为起点，采用递归的方法继续查找。 1)若j>i，则结点j所在层次大于等于结点i所在层次。结点j的双亲结点为结点j/2，若j/2=i，则结点j/2是原结点i和j结点的最近公共祖先结点，若j/2≠i

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鳄鱼麻薯球

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值