数据结构——二叉树的相关概念及其实现

最新推荐文章于 2024-08-27 17:42:05 发布

‘’return 0

最新推荐文章于 2024-08-27 17:42:05 发布

阅读量73

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/weixin_62590142/article/details/132020606

版权

1.树的基本概念

如下图是一个树

节点的度 ：一个节点含有的子树的个数称为该节点的度；如上图： A 的为 6

叶节点或终端节点 ：度为 0 的节点称为叶节点；如上图： B 、 C 、 H 、 I... 等节点为叶节点

非终端节点或分支节点 ：度不为 0 的节点；如上图： D 、 E 、 F 、 G... 等节点为分支节点

双亲节点或父节点 ：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图： A 是 B 的父节点

孩子节点或子节点 ：一个节点含有的子树的根节点称为该节点的子节点；如上图： B 是 A 的孩子节点

兄弟节点 ：具有相同父节点的节点互称为兄弟节点；如上图： B 、 C 是兄弟节点

树的度 ：一棵树中，最大的节点的度称为树的度；如上图：树的度为 6

节点的层次 ：从根开始定义起，根为第 1 层，根的子节点为第 2 层，以此类推；

树的高度或深度 ：树中节点的最大层次；如上图：树的高度为 4

堂兄弟节点 ：双亲在同一层的节点互为堂兄弟；如上图： H 、 I 互为兄弟节点

节点的祖先 ：从根到该节点所经分支上的所有节点；如上图： A 是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是 A 的子孙

森林：由 m （ m>0 ）棵互不相交的树的集合称为森林

2.二叉树的概念及结构：

一棵二叉树是结点的一个有限集合，该集合 :

1. 或者为空

2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

1. 二叉树不存在度大于 2 的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意的二叉树都是由以下几种情况复合而成的：

特殊的二叉树：

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1,则它就是满二叉树。

2. 完全二叉树 ：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 1 至 n 的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质:

1. 若规定根节点的层数为 1 ，则一棵非空二叉树的第 i 层上最多有2^(i-1)个结点.

2. 若规定根节点的层数为 1 ，则 深度为 h 的二叉树的最大结点数2^h-1.

3. 对任何一棵二叉树 , 如果度为 0 其叶结点个数为N0 , 度为 2 的分支结点个数为N2 , 则有N0 ＝N2＋ 1

4. 若规定根节点的层数为 1 ，具有 n 个结点的满二叉树的深度 ， h= $\log_{2}(n+1)$

5. 对于具有 n 个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从 0 开始编号，则对于序号为i 的结点有：

(1). 若 i>0 ， i 位置节点的双亲序号： (i-1)/2 ； i=0 ， i 为根节点编号，无双亲节点

(2). 若 2i+1<n ，左孩子序号： 2i+1 ， 2i+1>=n 否则无左孩子

(3). 若 2i+2<n ，右孩子序号： 2i+2 ， 2i+2>=n 否则无右孩子

3.二叉树的实现：

头文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>
typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

源文件：

int TreeSize;

BTNode* BTBuyNode(BTDataType x)
{
	BTNode* Newnode = (BTNode*)malloc(sizeof(BTNode));
	if (Newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	Newnode->_data = x;
	Newnode->_left = NULL;
	Newnode->_right = NULL;
	return Newnode;
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	assert(n > 0);
	if (a[*pi] == '0' || a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* nownode = BTBuyNode(a[*pi]);
	(*pi)++;
	nownode->_left = BinaryTreeCreate(a, n, pi);
	nownode->_right = BinaryTreeCreate(a, n, pi);
	return nownode;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	if ((*root)==NULL)
	{
		return;
	}
	BinaryTreeDestory(&(*root)->_left);
	BinaryTreeDestory(&(*root)->_right);
	free(*root);
	*root = NULL;
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	TreeSize++;
	BinaryTreeSize(root->_left);
	BinaryTreeSize(root->_right);
	return TreeSize;
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->_left==NULL&&root->_right==NULL)
	{
		return 1;
	}
	return BinaryTreeLeafSize(root->_left) 
		 + BinaryTreeLeafSize(root->_right);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}

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

	return BinaryTreeLevelKSize(root->_left,k-1) 
		+ BinaryTreeLevelKSize(root->_right,k-1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	static BTNode* node = NULL;
	if (root == NULL)
		return NULL;
	if(root->_data==x)
	{
		node = root;
		return root;
	}
	if (node != NULL)
		return node;
	BinaryTreeFind(root->_left,x);
	if(node!=NULL)
	return node;
	BinaryTreeFind(root->_right,x);
	if (node != NULL)
	return node;

	return NULL;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("#");
		return;
	}
	printf("%c", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("#");
		return;
	}
	
	BinaryTreeInOrder(root->_left);
	printf("%c", root->_data);
	BinaryTreeInOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("#");
		return;
	}
	
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c", root->_data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);

	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		printf("%c", front->_data);
		QueuePop(&q);
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);

	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
			break;

			QueuePush(&q, front->_left);
			QueuePush(&q, front->_right);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

主函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include"BTNode.h"

int main()
{
	BTDataType a[] = "ABD##E#H##CF##G##";
	//BTDataType a[] = "ABD##E##CF##G##";
	int pi = 0;
	BTNode* root= BinaryTreeCreate(a, strlen(a), &pi);
	printf("TreeSize:%d\n", BinaryTreeSize(root));
	printf("TreeLeafSize:%d\n", BinaryTreeLeafSize(root));
	int k = 3;
	printf("TreeLevelKSizeof %d:%d\n",k, BinaryTreeLevelKSize(root, k));
	k = 4;
	printf("TreeLevelKSizeof %d:%d\n", k, BinaryTreeLevelKSize(root, k));
	k = 5;
	printf("TreeLevelKSizeof %d:%d\n", k, BinaryTreeLevelKSize(root, k));
	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreeInOrder(root);
	printf("\n");
	BinaryTreePostOrder(root);
	printf("\n");
	
	BTNode* findnode= BinaryTreeFind(root,'D');
	if (findnode == NULL)
		printf("没找到\n");
	else
	{
		printf("找到了%c\n", findnode->_data);
	}
	
	if (BinaryTreeComplete(root))
	{
		printf("是完全二叉树\n");
	}
	else
	{
		printf("不是完全二叉树\n");
	}

	BinaryTreeLevelOrder(root);

	BinaryTreeDestory(&root);
	return 0;
}

运行结果：

‘’return 0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
数据结构——二叉树的相关概念及其实现

如下图是一个树：一个节点含有的子树的个数称为该节点的度；如上图：A的为6：度为0的节点称为叶节点；如上图：BCHI...等节点为叶节点：度不为0的节点；如上图：DEFG...等节点为分支节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点：具有相同父节点的节点互称为兄弟节点；如上图：BC是兄弟节点：一棵树中，最大的节点的度称为树的度；
复制链接

扫一扫