数据结构-二叉树、堆的概念及结构

halooy

已于 2024-03-12 15:17:41 修改

阅读量74

点赞数

分类专栏： C/C++ 文章标签：数据结构

于 2023-09-01 17:50:59 首次发布

本文链接：https://blog.csdn.net/m0_49619206/article/details/132609301

版权

C/C++ 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

树的概念

树是一种非线性的数据结构，由n(n>=0)个有限结点组成一个具有层次关系的集合，把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是跟朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根结点没有前驱结点
除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、…、Tm，其中每一个集合Ti（1<= i <= m）又是一颗结构与树类似的子树。每颗子树的根结点有且只有一个前驱，可以有0个或多个后继。
因此，树是递归定义的。

结点的度：一个结点含有的子树的个数称为该节点的度；如：R的为3
叶节点或终端结点：度为0的节点称为叶节点；如：j、k、e、f、g、m、n、i为叶节点
非终端节点或分支节点：度不为0的节点；如：a、b、c…等为分支节点
双亲结点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如：R是a的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如：a是R的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如：a、b为兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如：树的度为3
节点的层次，从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次，如：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如：e、f互为堂兄弟节点
节点的祖先：从根到该节点所经分支上的所有结点；如：R是所有节点的祖先
子孙：以某节点为根的子树中任一结点都称为该节点的子孙。如：所有的节点都是R的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；

树的表示

介绍孩子兄弟表示法
在这里插入图片描述

typedef int DataType;
struct Node
{
	struct Node* _firstChild1;	//第一个孩子节点
	struct Node* _pNextBrother;	//指向其下一个兄弟节点
	DataType _data;				//节点中的数据域
};

二叉树概念及结构

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：

每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
二叉树的子树有左右之分，其子树的次序不能颠倒。

特殊二叉树：
满二叉树：一个二叉树，如果每一个层的节点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且节点总数是(2^k)-1，则它就是满二叉树。
完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而印出来的。对于深度为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 = Log2（n+1）.（log以2为底，n+1为对数）
5.对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0开始编号，则对于序号为 i 的结点有：
①若 i > 0, i 位置结点的双亲序号：（i-1）/ 2；i = 0，i为根结点编号，无双亲结点
②若2i+1<n，左孩子序号：2i+1，2i+1>=n 否则无左孩子
③若2i+2<n，右孩子序号：2i+2，2i+2>=n 否则无右孩子

顺序存储：

顺序存储就是使用数组来存储，非完全二叉树会有空间浪费，二叉树顺序存储在物理上是一个数组，在逻辑上是一棵二叉树。
在这里插入图片描述

链式存储：

用链表来表示一颗二叉树，通常方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该节点左孩子和右孩子所在的链结点的存储地址。
链式结构又分为二叉链和三叉链，高阶数据结构如红黑树等会用到三叉链。
在这里插入图片描述

堆的概念及结构

把所有元素按照完全二叉树的顺序存储在一个一维数组中，并满足每个结点小于（或大于）其左右孩子结点，则称为小堆（或大堆）。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：

堆中某个结点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

假设小堆：进行调整实现：

//向下调整
void shiftDown(int* arr, int n, int cur)
{
	//找到孩子的位置
	//左孩子
	int child = 2 * cur + 1;

	while (child < n)
	{
		//从左右孩子中找一个最小的
		if (child + 1 < n && arr[child + 1] < arr[child])
			++child;

		//和当前数据比较
		//1.调整： 孩子 < 当前
		if (arr[child] < arr[cur])
		{
			int tmp = arr[child];
			arr[child] = arr[cur];
			arr[cur] = tmp;

			//更新位置，继续调整
			cur = child;
			child = 2 * cur + 1;
		}
		else
			//2.不调整： 孩子 >= 当前
			break;
	}
}

void test()
{
	int arr[] = { 10, 9, 8,7,6,5,4,3,2,1 };
	int n = sizeof(arr) / sizeof(arr[0]);
	//建堆：从最后一个非叶子节点开始：向下调整
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		shiftDown(arr, n, i);
	}
}

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

void heapPush(heap* hp, HDataType val)
{
	if (hp == NULL)
		return;
	checkCapacity(hp);
	//尾插
	hp->_data[hp->_size++] = val;
	//向上调整
	shiftUp(hp->_data, hp->_size, hp->_size - 1);
}

void heapPop(heap* hp)
{
	if (hp->_size > 0)
	{
		//交换
		Swap(&hp->_data[0], &hp->_data[hp->_size - 1]);
		//尾删
		hp->_size--;
		//从堆顶位置向下调整
		shiftDown(hp->_data, hp->_size, 0);
	}
}

void checkCapacity(heap* hp)
{
	if (hp->_size == hp->_capacity)
	{
		int newC = hp->_capacity == 0 ? 1 : 2 * hp->_capacity;
		hp->_data = (HDataType*)realloc(hp->_data, sizeof(HDataType) * newC);
		hp->_capacity = newC;
	}
}

void heapInit(heap* hp)
{
	if (hp == NULL)
		return;
	//空堆
	hp->_data = NULL;
	hp->_size = hp->_capacity = 0;
}

//向下调整
void shiftDown(int* arr, int n, int cur)
{
	//找到孩子的位置
	//左孩子
	int child = 2 * cur + 1;

	while (child < n)
	{
		//从左右孩子中找一个最小的
		if (child + 1 < n && arr[child + 1] < arr[child])
			++child;

		//和当前数据比较
		//1.调整： 孩子 < 当前
		if (arr[child] < arr[cur])
		{
			int tmp = arr[child];
			arr[child] = arr[cur];
			arr[cur] = tmp;

			//更新位置，继续调整
			cur = child;
			child = 2 * cur + 1;
		}
		else
			//2.不调整： 孩子 >= 当前
			break;
	}
}

void shiftUp(int* arr, int n, int cur)
{
	while (cur > 0)
	{
		//和父节点进行比较
		int parent = (cur - 1) / 2;

		if (arr[cur] < arr[parent])
		{
			int tmp = arr[cur];
			arr[cur] = arr[parent];
			arr[parent] = tmp;

			//更新位置
			cur = parent;
			parent = (cur - 1) / 2;
		}
		else
			break;
	}
}

HDataType heapTop(heap* hp)
{
	return hp->_data[0];
}

int heapEmpty(heap* hp)
{
	if (hp == NULL || hp->_capacity == 0)
		return 1;
	else
		return 0;
}

void test2()
{
	int arr[] = { 10, 9, 8,7,6,5,4,3,2,1 };
	int n = sizeof(arr) / sizeof(arr[0]);
	heap hp;
	heapInit(&hp);
	for (int i = 0; i < n; ++i)
	{
		heapPush(&hp, arr[i]);
	}
}

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