二叉树与堆的概念以及实现

最新推荐文章于 2024-07-31 23:15:29 发布
最新推荐文章于 2024-07-31 23:15:29 发布
阅读量253 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 C语言 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43105323/article/details/105805234

二叉树与堆

树的概念

  1. 根没有父节点
  2. 子树互不相交
  3. 节点数 = 边数 + 1
  4. 节点的度 = 子树的个数
  5. 树的度：最大节点个数
  6. 树的高度：最大层次

树的表示：双亲表示法，孩子表示法，孩子兄弟表示法

  • 满二叉树：除过叶子，其他节点度都为二，并且每层都是满的
  • 完全二叉树：除过最后一层，剩余结构是一个满二叉树，并且最后一层的节点从左向右中间无间隔

满二叉树一定是完全二叉树

完全二叉树不一定是满二叉树

二叉树

二叉树的节点总数

n0 + n1 + n2 = 二叉树的节点总数

n1 + 2 * n2 = 二叉树边的总数

节点总数 - 1 = 边的个数

n0 + n1 + n2 - 1 = n1 + 2 * n2

n0 = n2 + 1

满二叉树高度：
log ⁡ 2 ( N + 1 ) \log_2(N+1) log2​(N+1)

∵ 2 h − 1 = N ∴ h = l o g 2 ( N + 1 ) \because2^h - 1 =N \quad \therefore h = log_2(N+1) ∵2h−1=N∴h=log2​(N+1)

满二叉树的节点一定为奇数

二叉树的存储形式
  1. 顺序结构：适合存放完全二叉树，没有空间浪费

规则：从第一层开始存放，直到最后一层，每层从左向右依次存放，如果中间有空节点，保留空节点的位置

完全二叉树

父子节点的位置：

parent： left_child = 2 x parent + 1

​ right_child = 2 x parent +2

child : parent = (child - 1) / 2

  1. 链式结构：适合存放一般二叉树

二叉链：数据，指向左右孩子的指针

三叉链：数据，指向左右孩子的指针 + 指向父亲的指针

完全二叉树：总数 2n

度为1的节点出现在倒数第二层

度为一的节点个数：

​ 节点个数为偶数：n1 = 1

​ 节点个数为奇数：n1 = 0

堆

大小堆：

大堆：每个父节点都比子节点大

小堆：每个父节点都比子节点小

堆的向下调整：

隐含的前提：当前需要调整的位置以下的子结构已经是一个堆。

1. 小堆

从当前需要调整的位置开始，（parent）

a. 从左右孩子中选一个最小的（child）

b. 如果最小的child仍然小于parent：

​ 交换child和parent

​ 更新：parent = child，child = 2 * parent + 1

​ 如果child没有越界，跳到a，继续执行

​ 如果最小的child仍然大于parent：结束调整

void shiftDown(HPDataType* a, int size, int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] < a[child])
			child++;
		if (a[child] < a[parent])
		{
			Swap(a, child, parent);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

2. 大堆

从当前需要调整的位置开始，（parent）

a. 从左右孩子中选一个最大的（child）

b. 如果最大的child仍然大于parent：

​ 交换child和parent

​ 更新：parent = child，child = 2 * parent + 1

​ 如果child没有越界，跳到a，继续执行

​ 如果最大的child仍然小于parent：结束调整

void shiftDown(HPDataType* a, int size, int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])
			child++;
		if (a[child] > a[parent])
		{
			Swap(a, child, parent);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
堆的向上调整

从当前位置开始（child），与父节点进行比较，如果是大堆，则若孩子大于父亲，交换二者，如果是小堆，则若孩子小于父亲，交换二者，直到不能交换为止。

void shiftUp(HPDataType* a, int child)
{
	//小堆
	/*int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(a, child, parent);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}*/
	//大堆
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(a, child, parent);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆的实现

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity;
}Heap;

堆的实现使用了线性表来存储数据

void Swap(HPDataType* a, int left, int right)
{
	int tmp = a[left];
	a[left] = a[right];
	a[right] = tmp;
}

// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int size)
{
	hp->_a = (HPDataType*)malloc(sizeof(HPDataType)* size);
	memcpy(hp->_a, a, sizeof(HPDataType)* size);
	hp->_size = size;
	hp->_capacity = size;

	for (int parent = (size - 2) / 2; parent >= 0; parent--)
	{
		shiftDown(hp->_a, size, parent);
	}
}

堆得插入与删除，堆得插入则直接在线性表末尾插入，然后进行向上调整，堆得删除则需先交换堆顶与最后一个叶子结点，接着线性表进行尾删，然后进行向下调整

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	if (hp->_size >= hp->_capacity)
	{
		hp->_capacity *= 2;
		hp->_a = (HPDataType*)realloc(hp->_a, sizeof(HPDataType)* hp->_capacity);
	}
	hp->_a[hp->_size++] = x;
	shiftUp(hp->_a, hp->_size - 1);

}
// 堆的删除
void HeapPop(Heap* hp)
{
	if (hp->_size > 0)
	{
		Swap(hp->_a, 0, hp->_size - 1);
		hp->_size--;
		shiftDown(hp->_a, hp->_size, 0);
	}
}

二叉树的实现

二叉树的遍历
  1. 前序（先序）遍历，先访问父节点，在访问左孩子，最后访问右孩子。
void BinaryTreePrevOrder(BTNode* root)
{
	if (root)
	{
		printf("%c ", root->_data);
		BinaryTreePrevOrder(root->_left);
		BinaryTreePrevOrder(root->_right);
	}
}

递归方式

void BinaryTreePrevOrderNoR(BTNode* root)
{
	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	BTNode* top = NULL;
	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			printf("%c ", cur->_data);
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		StackPop(&st);
		cur = top->_right;

	}
	printf("\n");
}

非递归方式，使用到了栈

  1. 中序遍历，先访问左孩子，在访问父节点，最后访问右孩子。
void BinaryTreeInOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreeInOrder(root->_left);
		printf("%c ", root->_data);
		BinaryTreeInOrder(root->_right);
	}
}

递归方式

void BinaryTreeInOrderNoR(BTNode* root)
{
	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	BTNode* top = NULL;
	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		StackPop(&st);
		printf("%c ", top->_data);
		cur = top->_right;
	}
	printf("\n");
}

非递归，使用到了栈

  1. 后序遍历，先访问左孩子，后访问右孩子，最后访问父节点。
void BinaryTreePostOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreePostOrder(root->_left);
		BinaryTreePostOrder(root->_right);
		printf("%c ", root->_data);
	}
}

递归方式

void BinaryTreePostOrderNoR(BTNode* root)
{
	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	BTNode* top = NULL;
	BTNode* prev = NULL;
	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		if (!top->_right || top->_right == prev)
		{
			printf("%c ", top->_data);
			StackPop(&st);
			prev = top;
		}
		else
			cur = top->_right;
	}
	printf("\n");
}

非递归方式，使用到了栈

  1. 层序遍历，从第一层开始，每层向后遍历。

使用队列实现

void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%c ", front->_data);
		if (front->_left)
			QueuePush(&q, front->_left);
		if (front->_right)
			QueuePush(&q, front->_right);
	}
	printf("\n");
}
二叉树的构建

此处使用先序遍历的方式建树，‘ # ’代表数中的空节点NULL

BTNode* BinaryTreeCreate(BTDataType* a,int n, int* pi)
{
	if (a[*pi] != '#' && *pi < n)
	{
		BTNode* root = (BTNode*)malloc(sizeof(BTNode));
		root->_data = a[*pi];
		(*pi)++;
		root->_left = BinaryTreeCreate(a, n, pi);
		(*pi)++;
		root->_right = BinaryTreeCreate(a, n, pi);
		return root;
	}
	return NULL;
}
二叉树的节点个数问题

拆分成左右子数的问题，用递归实现

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (!root)
		return 0;
	return BinaryTreeSize(root->_left)
		+ BinaryTreeSize(root->_right)
		+ 1;
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (!root)
		return 0;
	if (!root->_left && !root->_right)
		return 1;
	return BinaryTreeLeafSize(root->_left)
		+ BinaryTreeLeafSize(root->_right);
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (!root)
		return 0;
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->_left, k - 1)
		+ BinaryTreeLevelKSize(root->_right, k - 1);
}
二叉树和堆
annuoa的专栏
07-24 463
突击算法面试题 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 二叉树和堆 目录 突击算法面试题 二叉树和堆 前言 一、二叉树 二叉树的查找： 二叉树的插入 二叉树的删除 二叉树的遍历二叉树的广度优先遍历 二叉树的深度优先遍历 翻转二叉树 判断二叉树是否对称 求二叉树的深度（最大深度、最小深度...
二叉树—堆（C语言实现）
2401_83431652的博客
05-29 1178
树是一种非线性的数据结构，它是有n（n > 0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下。树结构相对线性表就比较复杂，要存储表示起来就比较麻烦，既然保存值域，也要保存结点和结点之间的关系，实际上数有很多表示方式比如：双亲表示法，孩子表示法，孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的理解其中最常用的孩子兄弟表示法。 二、二叉树的概念及结构 1.概念 由上图可知： 注意：对于任意的二叉树都是有以下几种情况符合而成的：(1)满
关于二叉树二叉堆的一些基本概念
月夜行的专栏
08-29 2548
在看到算法导论的堆排序的时候，对于二叉树，二叉堆概念不是很清楚，所以查阅了一些资料和博客。将相关的基本概念总结在博客里面。 二叉树：是树的一种，主要的特点是二叉树的所有节点最多只有两个叶节点。除此之外没有别的要求 完全二叉树：就是在二叉树当中，除了最后一层之外，所有层的节点都有满的，且最后一层的节点也是从左到右的。优先填满左边的节点。 满二叉树：又是一种特殊的完全二叉
二叉树与堆
weixin_57822074的博客
07-29 634
二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。...
【数据结构】二叉树和堆
2401_83948390的博客
07-31 1822
在C语言中，二叉树是一种基础的数据结构，它由节点组成，每个节点包含数据元素以及指向其他节点的指针。高度（Height）：节点的高度是从该节点到最远叶节点的最长路径上的边的数量。子节点（Children）：如果节点A的左指针或右指针指向节点B，则节点B是节点A的子节点。层（Level）：节点的层是从根节点开始计数，根节点在第1层，它的子节点在第2层，以此类推。父节点（Parent）：如果一个节点有子节点，那么这个节点就是其子节点的父节点。根节点（Root）：位于树顶部的节点，它是树中唯一没有父节点的节点。
golang实现的基础排序算法以及二叉树、堆、图等数据结构_basicAlgorithm.zip
最新发布
09-23
在计算机科学与工程领域中，算法是解决问题和执行计算的基本步骤，而数据结构则是组织和存储数据的一种方式...通过使用Go语言实现这些基础算法和数据结构，不仅可以加深对这些概念的理解，还能提高解决实际问题的能力。
二叉树与堆结构在类模板中的验证与实现
在本文件中，我们深入探讨了数据结构二叉树的三个关键知识点：二叉链表的验证、线索二叉树的实现以及堆的实现与改造。每一个部分都是数据结构学习中不可或缺的基础，下面将详细阐述这些知识内容。 首先，我们来了解...
数据结构_二叉树(Binary tree)与堆排序(Heap sorting)
QinMou
05-20 1186
本文的重点是二叉树实现堆、堆排序和topK问题
二叉树、堆和堆排序（优先队列）
weixin_64132124的博客
02-11 1301
本章会讲解二叉树及其一些相关练习题，和堆是什么。
二叉树—堆
qq_62236390的博客
07-17 592
在插入数据到堆中时要注意插入元素是否会使得堆不再为堆（因为堆的性质是父节点要大于或小于子节点），所以在插入数据之后需要向上检索其父节点是否不满足当前堆的性质，如果是则交换父子数据，接着循环，直至满足为止。二叉树也可以选择链表和数组表示，当二叉树是完全二叉树或者满二叉树时，用数组表示更优，因为用数组找寻子节点不需要指针，仅需要数组下标即可，详情请查看上篇文章，附上传送门。堆顶元素的删除并不是简单将数组元素整体往前挪动一位那么简单，如果仅仅是挪动，那么会破坏堆结构，父子间的关系可能会改变。......
二叉树和堆详解
V_zjs的博客
06-01 872
二叉树的第i层上至多有2i-1（i≥1）个节点 [6]。深度为h的二叉树中至多含有2h-1个节点 [6]。若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1 [6]。具有n个节点的满二叉树深为log2n+1。若对一棵有n个节点的完全二叉树进行顺序编号(从0开始),对于编号为ii（1）i的左孩子结点的编号是2*i+1（2）i的右孩子的编号是2*i+1（2）i的父节点的编号是(i-1)/2。
二叉树和堆的概念和特点
欧尼酱的技术园
05-29 1704
文章目录前言一、树1.1 树的概念1.2 树的特点1.3 孩子兄弟表示法二，二叉树2.1 二叉树的特点2.2 二叉树的性质2.3 二叉树存储结构2.3.1 顺序存储结构2.3.2 链式存储结构：2.4二叉树（堆）的顺序存储结构及实现2.4.1堆的概念和结构总结 前言 本篇文章将带大家了解二叉树和堆。二叉树和堆的外形非常相似，都是一个下宽上窄的金字塔结构，常常让人傻傻分不清楚。这篇文章将介绍二叉树和堆的概念，区别，以及他们的特点。 一、树 1.1 树的概念 树是一种非线性的数据结构，它是由若干个有限节点组
数据结构6：二叉树与堆
m0_53607711的博客
11-11 816
树的基本概念和堆结构的实现以及堆排序实现方法都在这里了
堆与二叉树的关系
曲终人散
08-02 550
1 堆数组下边与二叉树节点关系 节点编号 与数组的关系 i号节点的左节点 为2i+1 i号节点的右节点 为2i+2 i号节点的符节点为i-1/2
【数据结构】二叉树之堆
阿琪
02-27 3525
本篇章主要对堆的创建、插入、删除、排序进行详细图解，以例题方式进行绘制。
【数据结构】满二叉树、完全二叉树、堆的概念回顾，堆和堆排序的算法实现
Bobby's Blog
08-28 478
本来只想整理两个内容： 无映射关系的堆排序（eg.堆排序） 有映射关系的堆排序（eg.模拟堆） 但是在实现过程中，因为堆的本质是完全二叉树，所以有些地方需要结合完全二叉树的性质来理解。而完全二叉树又是根据满二叉树定义的，所以先回顾一下满二叉树和完全二叉树的基本概念及性质。 1 基本概念及相关性质 1.1 满二叉树 定义：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为k，且结点总数是2k - 1 ，则它就是满二叉树。 注：满二叉树的概念国内外定义是
树与二叉树，堆
Advsance的博客
08-01 483
数概念及结构 数是一个非线性的数据结构，它是由n（n>0）个有限节点组成一个具有层次关系的集合，只不过在计算机中的树看起来向倒挂的树； 树中的各个部分因为比较简单，所以在此不做说明可以查看下图： 节点的度：一个节点含有的子树的个数称为该节点的度； 叶节点或终端节点：度为0的节点称为叶节点； 树的度：一棵树中，最大的节点的度称为树的度；（例如上图最大度为3） 森林：由m（m>=0）棵互不...
堆（二叉树，带图详解）
qq_74732628的博客
10-25 685
向下调整建堆，向上调整建堆，大堆小堆带图详解
二叉树与堆的概念解析
本文将深入探讨堆的定义以及与之相关的数据结构概念，特别是与C++中的树和森林的实现有关的知识。堆是一种特殊类型的树，它在计算机科学中有着广泛的应用，例如在优先队列、排序算法（如堆排序）以及内存管理等方面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值