二叉树顺序和链式结构及实现（图文版）

其他 2020-10-14 18:38:50 阅读次数: 0

1.树的概念及结构

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的
在这里插入图片描述
在这里插入图片描述
节点的度：一个节点含有的子树的个数称为该节点的度，如上图：A的度为6，B的度为0
叶节点或终端节点：度为0的节点称为叶节点，如上图：B、C、H…
分支节点或非终端节点：度不为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的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒，所以二叉树是有序数。

特殊的二叉树：
3. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
4. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二树
在这里插入图片描述
注意：
满二叉树是一种特殊的完全二叉树，但完全二叉树不一定是满二叉树。
满二叉树每一层节点都存满了，也就是说每一层的节点个数都是2^(i-1)—i表示层数
完全二叉树前n-1层节点存满了，但第n层节点不一定存满，但第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=Log2(n+1). (ps：Log2(n+1)是log以2为底，n+1为对数)
  5. 对于具有n个结点的完全二叉树，如果按照从上至下，从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
    在这里插入图片描述
  6. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
  7. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
  8. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子
    说明：
  9. 完全二叉树中最多只能有1个度为1的节点
  10. 完全二叉树不可能存在某个节点只有右孩子没有左孩子的情况
  11. 完全二叉树节点个数为奇数：没有度为1的孩子（通过完全二叉树观察得到）
  12. 完全二叉树节点个数为偶数：有一个度为1的孩子（通过完全二叉树观察得到）
    在这里插入图片描述
    二叉树的存储结构：二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构
    顺序结构：连续空间 只适合完全二叉树以及满二叉树在这里插入图片描述普通二叉数
    链式结构：普通二叉树
    在这里插入图片描述

3.二叉树顺序结构及实现

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

堆的概念及结构
将元素集合按照完全二叉树顺序存储方式存储到数组中,将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质

  1. 堆中某个节点的值总是不大于或不小于其父节点的值；
  2. 堆总是一棵完全二叉树。
  3. 堆顶元素一定是最小的或者最大的值
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    将完全二叉树转换为小堆
    在这里插入图片描述
    思路：因为9下面的左右子树不是小堆，先将8和7分别对应的堆调整为小堆，而调整8对应的小堆，又得先调整6和5所对应的小堆，其中5对应的小堆是最先调的，也就是说，调整堆的顺序为5->6->7->8->9,最后这种情况就和上面的情况一样，再将100向下调整
    用堆来解决的问题
    若要创建前k个最大的元素，则需要创建一个小堆；若若要创建前k个最小的元素，则需要创建一个大堆
    假设需要一个大堆：
    1 用数据中的前k个元素创建一个小堆
    2 用剩余的元素（N-K）个元素依次与堆顶元素 进行比较，如果比堆顶元素大，将堆顶元素删除掉，将新元素插入到堆中
    将任意一个数组转化为小堆-----代码如下：
void HeapInit(Heap* hp, int initCap)
{
    
    
	assert(hp);
	initCap = initCap < 10 ? 10 : initCap;
	hp->array = (HDataType*)malloc(sizeof(HDataType)*initCap);
	if (NULL == hp->array)
	{
    
    
		assert(0);
		return;
	}

	hp->capacity = initCap;
	hp->size = 0;
}

void Swap(HDataType* left, HDataType* right)
{
    
    
	HDataType temp = *left;
	*left = *right;
	*right = temp;
}

void AdjustDown(HDataType* array, int size, int parent)
{
    
    
	//用child标记parent中较小的孩子----默认先标记parent的左孩子
	int child = parent * 2 + 1;

	while (child < size)
	{
    
    
		//找到parent中两个孩子中较小的孩子
		if (child + 1 < size && array[child + 1] < array[child])
			               child += 1;

		//parent较小的孩子已经找到
		//检测parent是否满足堆的性质
		if (array[child] < array[parent])
		{
    
    
			Swap(&array[child], &array[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}

//用数组中元素创建堆
void HeapCreate(Heap* hp, int* array, int size)
{
    
    
	//1 先将数组中的元素放在堆结构中
	HeapInit(hp, size);
	memcpy(hp->array, array, sizeof(HDataType)*size);
	hp->size = size;

	//2 进行调整
	for (int root = (size - 2) / 2; root >= 0; root--)
		AdjustDown(hp->array, hp->size, root);
}

void AdjustUP(HDataType* array, int size, int child)
{
    
    
	int parent = ((child-1)>>1);

	//调整到根节点结束
	while (child)
	{
    
    
		if (array[child] < array[parent])
		{
    
    
			Swap(&array[child], &array[parent]);
			child = parent;
			parent = ((child - 1) >> 1);
		}
		else
			return;
	}
}

void CheckCapacity(Heap* hp)
{
    
    
	assert(hp);
	if (hp->size == hp->capacity)
	{
    
    
		//1.开辟新空间
		int newCapacity = hp->capacity * 2;
		HDataType* temp = (HDataType*)malloc(sizeof(HDataType)*newCapacity);
		if(NULL == temp)
		{
    
    
			assert(0);
			return; 
		}
		//2.拷贝元素
		//memcpy(temp, hp->array, hp->size*sizeof(HDataType));
		for (int i = 0; i < hp->size; ++i)
			temp[i] = hp->array[i];

		//3.释放旧空间
		free(hp->array);
		//4.使用新空间
		hp->array = temp;
		hp->capacity = newCapacity; 
	}
}

void HeapPush(Heap* hp, HDataType data)
{
    
    
	//0. 检测是否需要扩容
	CheckCapacity(hp);

	//1.将新元素插入到数组的末尾，即：将新元素插入到完全二叉树的最后
	hp->array[hp->size++] = data;

	//2. 新元素插入后，可能会破会堆的性质
	AdjustUP(hp->array, hp->size, hp->size-1);
}

//删除堆顶元素
void HeadPop(Heap* hp)
{
    
    
	if (HeapEmpty(hp))
		return;

	Swap(&hp->array[0], &hp->array[hp->size-1]);
	hp->size--;
	AdjustDown(hp->array, hp->size, 0);
}

//返回堆顶元素，也就是0号位置的元素
HDataType HeapTop(Heap* hp)
{
    
    
	//获取之前堆中先判断是否为空
	assert(!HeapEmpty(hp));
	return hp->array[0];
}

//判断是否为空
int HeapEmpty(Heap* hp)
{
    
    
	assert(hp);
	return hp->size == 0;
}

//获取堆中有效元素的个数
int HeapSize(Heap* hp)
{
    
    
	assert(hp);
	return hp->size;
}

void HeapDestroy(Heap* hp)
{
    
    
	assert(hp);
	free(hp->array);
	hp->array = NULL;
	hp->capacity = 0;
	hp->size = 0;
}


void TestHeap()
{
    
    
	int array[] = {
    
    3,6,9,1,5,2,0,7,8,4};
	Heap hp;

	HeapCreate(&hp, array, sizeof(array)/sizeof(array[0]));
	printf("heap size = %d\n", HeapSize(&hp));
	printf("heap top = %d\n", HeapTop(&hp));

	HeadPop(&hp);
	printf("heap size = %d\n", HeapSize(&hp));
	printf("heap top = %d\n", HeapTop(&hp));

	HeapPush(&hp, 0);
	HeapDestroy(&hp);
}

运行结果：在这里插入图片描述

4.二叉树链式结构及实现

在这里插入图片描述
二叉树的遍历
前序遍历：根节点–>根节点的左子树–>根节点的右子树（根-左-右）
中序遍历：根节点的左子树–>根节点–>根节点的右子树（左-根-右）
后序遍历：根节点的左子树–>根节点的右子树–>根节点（左-右-根）
以上述图片为例：
前序遍历：1 2 3 4 5 6
中序遍历: 3 2 1 5 4 6
后续遍历：3 2 5 6 4 1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
解决方法是：1按照层序遍历的方式找第一个不饱和节点 2 从该节点之后，所有的节点不能有孩子，如果有则不是完全二叉树
在这里插入图片描述

BTNode* BuyBinTreeNode(BTNDataType data)
{
    
    
	BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
	if (NULL == newNode)
	{
    
    
		assert(0);
		return NULL;
	}

	newNode->data = data;
	newNode->left = NULL;
	newNode->right = NULL;
	return newNode;
}

//array数组中，保存的是二叉树中所有节点的值域
BTNode* CreateBinTree(int array[], int size, int* index, int invalid)
{
    
    
	BTNode* root = NULL;
	if (*index < size && array[*index] != invalid)
	{
    
    
		//创建根节点
		root = BuyBinTreeNode(array[*index]);
		//创建根节点的左子树
		++(*index);
		root->left = CreateBinTree(array, size, index, invalid);
		//创建根节点的右子树
		++(*index);
		root->right = CreateBinTree(array, size, index, invalid);
	}
	return root;
}

//根-左-右
void PreOrder(BTNode* root)
{
    
    
	if (root)
	{
    
    
		printf("%d ", root->data);
		PreOrder(root->left);
		PreOrder(root->right);
	}
}

//左-根- 右
void InOrder(BTNode* root)
{
    
    
	if (root)
	{
    
    
		PreOrder(root->left);
		printf("%d ", root->data);
		PreOrder(root->right);
	}
}

//左-右-根
void PostOrder(BTNode* root)
{
    
    
	PreOrder(root->left);
	PreOrder(root->right);
	printf("%d ", root->data);
}

void DestroyTree(BTNode** root)
{
    
    
	assert(root);//root中的地址，也就是外部实参的地址,*root才是外部的实参

	if (*root)
	{
    
    
		DestroyTree(&(*root)->left);
		DestroyTree(&(*root)->right);
		free(*root);
 		*root = NULL;
	}
}

//二叉树节点的个数
int GetNodeCount(BTNode* root)
{
    
    
	if (root == NULL)
		return 0;

	return GetNodeCount(root->left) + GetNodeCount(root->right) + 1;
}

//二叉树叶子节点的个数,也就是度为0的节点
int GetLeafNodeCount(BTNode* root)
{
    
    
	if (root == NULL)
		return 0;

	//遇到左右孩子的都为空，即为叶子节点
	if (NULL == root->left && NULL == root->right )
		return 1;

	return GetLeafNodeCount(root->left) + GetLeafNodeCount(root->right);
}

//二叉树第K层节点的个数
int GetKLevelNodeCount(BTNode* root, unsigned int k)
{
    
    
	if (NULL == root || k == 0)
		return 0;

	//第一层只有根节点
	if (1 == k)
		return 1;

	//将问题转为到子树中求k-1层节点的个数
	return GetKLevelNodeCount(root->left, k - 1) + GetKLevelNodeCount(root->right, k - 1);
}

//查找值为data的节点
BTNode* Find(BTNode* root, BTNDataType data)
{
    
    
	BTNode* ret = NULL;
	if (root == NULL)
		return NULL;

	if (root->data = data)
		return root;

	//先在左子树找，找到了返回，找不到继续在右子树找
	(ret = Find(root->left, data)) || (ret = Find(root->right, data));
	return ret;
}

int GetHeight(BTNode* root)
{
    
    
	int leftHeight = 0, rightHeight = 0;
	if (root == NULL)
		return 0;

	leftHeight = GetHeight(root->left);
	rightHeight = GetHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

/*int BinaryTreeComplete(BTNode* root)
{
	int flag = 0;
	int ret = 0;
	//空树也是完全二叉树 
	if (NULL == root)
		return 1;

	//非空
	//1 按层序遍历的规则找不饱和节点
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* cur = QueueFront(&q);
		if (flag)
		{
			//后序节点不能有孩子
			if (cur->left || cur->right)
				break;
		}
		else
		{
			//找第一个不饱和的节点
			if (cur->left && cur->right)
			{ 
				QueuePush(&q, cur->left);
				QueuePush(&q, cur->right);
			}
			else if (cur->left)
			{
				//只有左孩子
				QueuePush(&q, cur->left);
				flag = 1;
			}
			else if (cur->right)
			{
				//只有右孩子
				break;
			}
			else
			{
				//没有左右孩子
				flag = 1;
			}
		}
		QueuePop(&q);
	}

	if (QueueEmpty(&q))
		ret = 1;

	DestroyQueue(&q);
	return ret;
	return 1;
}*/

BTNode* CopyBinTree(BTNode* root)
{
    
    
	BTNode* newroot = NULL;
	if (root)
	{
    
    
		//拷贝根节点
		newroot = BuyBinTreeNode(root->data);

		//拷贝根节点的左子树
		newroot->left = CopyBinTree(root->left);

		//拷贝根节点的右子树
		newroot->right = CopyBinTree(root->right);
	}
	return newroot;
}

void TestBinTree()
{
    
    
	//将二叉树的元素放在数组中
	int array[] = {
    
     1,2,3,-1,-1,-1,4,5,-1,-1, 6 };
	int index = 0;
	BTNode* root = CreateBinTree(array, sizeof(array)/sizeof(array[0]), &index, -1);


	BTNode* newroot = NULL;

	printf("前序遍历:");
	PreOrder(root);
	printf("\n");

	printf("中序遍历:");
	InOrder(root);
	printf("\n");

	printf("后序遍历:");  
	PostOrder(root);
	printf("\n");

	//printf("%d\n", GetNodeCount(root));
	//printf("%d\n", GetLeafNodeCount(root));
	//printf("%d\n", GetKLevelNodeCount(root, 2));
	//printf("%d\n", GetKLevelNodeCount(root, 3));

	//BTNode* cur = Find(root, 5);
	//if (cur)
	//	printf("5 是二叉树\n");
	//else
	//	printf("5不是二叉树\n");

	newroot = CopyBinTree(root);
	printf("前序遍历:");
	PreOrder(root);
	printf("\n");

	printf("中序遍历:");
	InOrder(root);
	printf("\n");

	printf("后序遍历:");
	PostOrder(root);
	printf("\n");

	printf("%d\n", GetHeight(root));
	DestroyTree(&newroot);
	DestroyTree(&root);
}
}

结果：在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/aaaaauaan/article/details/106727740
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022