数据结构与算法：二叉树之“堆排序”

Han同学2023-11-01 8:42

目录

一、树概念及结构

二、二叉树树概念及结构

特殊的二叉树

三、堆的概念及结构

四、堆的创建

1、声明结构体

2、初始化

3、销毁

4、添加新元素

5、交换元素

6、向上调整

7、判断堆是否为空

8、移除堆顶元素

9、向下调整

10、获取堆元素个数

五、使用堆排序

排降序建小堆

向上调整

向下建堆

建堆方式对比

完整版：

Heap.h声明部分

Heap.c函数部分

text.c使用及测试部分

一、树概念及结构

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

  • 有一个特殊的结点，称为根结点，根节点没有前驱结点。
  • 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti(1 <= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
  • 因此，树是递归定义的
  • 注意：树形结构中，子树之间不能有交集，否则就不是树形结构
  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林；

二、二叉树树概念及结构

二叉树是一个由n(n>=0)个结点构成的有限集合，其中该集合可以为空，这时称其为空二叉树；或者由一个根结点以及两个互不相交的左子树和右子树组成，且左右子树均为二叉树。在二叉树中，子树被明确区分为左子树和右子树，且它们的顺序不可颠倒。

  • 值得注意的是，二叉树的定义具有递归性质，因为二叉树本身可以为空，根结点可以有空的左子树或空的右子树。
  • 这使得二叉树与普通树有明显的区别，即使只有一棵子树存在，也需要明确指定它是左子树还是右子树。这是二叉树与树最主要的区别之一。
  • 请注意，二叉树不同于一般的树，因为它的子树具有左右之分，并且顺序不能颠倒。因此，"二叉树是结点度为2的树"的说法是不正确的。

二叉树的基本形态包括以下五种：

特殊的二叉树

当涉及到二叉树的特殊类型时，有两个主要概念需要了解：满二叉树和完全二叉树。

  • 满二叉树：满二叉树是一种特殊的二叉树，其特点是每个层级的结点数都达到最大值。具体来说，如果一个二叉树的深度为K，且结点总数为2^K - 1，那么它就是一个满二叉树。满二叉树的每一层都包含最大数量的结点，使得它具有很特殊的结构。
  • 完全二叉树：完全二叉树是一种高效的数据结构，与满二叉树相关。一个二叉树如果在深度为K的情况下，其结点都与深度为K的满二叉树中的编号从1到n的结点一一对应，那么它就被称为完全二叉树。需要注意的是，满二叉树是完全二叉树的一个特殊情况。
    性质
  1. 若规定根节点的层数为1，则一棵非空二叉树的**第i层上最多有**个结点。
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是。
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0 , 度为2的分支结点个数为 n2 ,则有 n0 ＝n2 ＋1。
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度 ，h=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否则无右孩子

三、堆的概念及结构

堆（Heap）是一种特殊的树状数据结构，通常用于实现优先队列和对数据进行排序。堆的主要特点是它是一棵树，其中每个节点的值满足特定的堆属性。在堆中，通常有两种主要类型：最大堆和最小堆。

  • 最大堆（Max Heap）：在最大堆中，每个节点的值都不小于其子节点的值，即根节点的值最大。这意味着最大堆的最大元素总是位于根节点，而子树中的值递减。

  • 最小堆（Min Heap）：在最小堆中，每个节点的值都不大于其子节点的值，即根节点的值最小。这意味着最小堆的最小元素总是位于根节点，而子树中的值递增。

堆的常见用途包括：

  • 优先队列：堆可以用来实现高效的优先队列，使得可以快速访问和删除具有最高或最低优先级的元素。

  • 堆排序：堆排序是一种高效的排序算法，它利用堆的性质来进行排序。它的时间复杂度为O(n log n)。

堆通常是以数组的形式来表示，其中父节点和子节点之间的关系通过数组索引来建立。具体来说，对于一个具有n个元素的堆，节点的索引从1到n编号，其中：

  • 父节点的索引为i，则它的左子节点的索引为2i，右子节点的索引为2i + 1。
  • 子节点的索引为i，则其父节点的索引为i/2。

这种数组表示方法使得堆的操作更加高效，因为它不需要使用额外的指针来表示树的结构。

四、堆的创建

本次以小堆举例进行讲解

1、声明结构体

cpp 复制代码 
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
  • HPDataType 被定义为 int 类型，表示堆中存储的数据类型。
  • 创建堆的结构体Heap，定义别名为HP。
  • 指针a指向堆的数组
  • size为堆的当前大小
  • capacity为堆的容量

2、初始化

cpp 复制代码 
void HeapInit(HP* php)
{
    assert(php);
    php->a = NULL;
    php->size = 0;
    php->capacity = 0;
}
  • assert 判断指针是否合法。
  • 指向数组的指针 a 初始化为 NULL。
  • size 和 capacity 初始化为0。

3、销毁

cpp 复制代码 
void HeapDestroy(HP* php)
{
    assert(php);
    free(php->a);
    php->a = NULL;
    php->capacity = php->size = 0;
}
  • assert 判断指针是否合法。
  • 释放数组空间，将 a 指针置空，同时将 capacity 和 size 设置为0。

4、添加新元素

cpp 复制代码 
void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	if (php->size == php->capacity) {
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));
		if (tmp==NULL) {
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}

	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);
}
  • assert 判断指针是否合法。
  • 判断当前是否需要扩容，初始堆的容量为0，则为堆开辟四个HPDataType类型大小的空间，如果当前堆的大小size等于容量capacity，则将堆扩容为两倍原来大小的空间。
  • 扩容失败，打印错误信息，结束函数
  • 将扩容的空间赋值给指针a，更新容量capacity的大小。
  • 将要增加的元素插入数组a中，更新size大小。
  • 每次在堆中添加新元素时，小堆可能会被破坏，所以我们再添加新元素后，要在AdjustUp 函数中判断是否需要进行向上调整。

5、交换元素

后续函数会经常用到，同一串代码放到函数里供其使用者调用比较好。

cpp 复制代码 
void Swap(HPDataType* p1, HPDataType* p2)
{
    HPDataType tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

6、向上调整

cpp 复制代码 
void AdjustUp(HPDataType* a, int child)
{
    int parent = (child - 1) / 2;

    while (child > 0) {
        if (a[child] < a[parent]) {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else {
            break;
        }
    }
}
  • 首先通过当前的孩子节点child找到父节点parent。
  • 当child大于0时，进行判断当前chilid是否需要调整
  • 如果child位置元素小于parent位置元素，则通过Swap进行交换，然后新的孩子节点更新为parent位置，通过孩子节点更新新的父节点位置，然后继续比较和交换，直到不再需要交换为止。
  • 如果当前孩子节点不小于当前的父节点，则结束循环，当前节点不需要向上调整。

7、判断堆是否为空

cpp 复制代码 
bool HeapEmpty(HP* php)
{
    assert(php);
    return php->size == 0;
}

8、移除堆顶元素

一般来说，堆的移除操作通常是移除堆顶元素，这样大堆小堆的性质保持不变，如果移除堆底会破坏堆的性质。

cpp 复制代码 
void HeapPop(HP* php)
{
    assert(php);
    assert(!HeapEmpty(php));

    Swap(&php->a[0], &php->a[php->size - 1]);
    php->size--;
    AdjustDown(php->a, php->size, 0);
}
  • assert 判断指针是否合法。
  • 检查堆是否为空，为空则报错。
  • 移除堆顶元素有两种方法，首选第二种方法，不需要重新建堆，节约时间。
  • 首先交换堆顶堆尾，然后size减一完成删除，后续不会访问删除位置的元素，所以不释放内存空间也可以。
  • 然后进行向下调整。

9、向下调整

向下调整是从第一个节点（父节点）开始向下调整，传入参数命名为parent

cpp 复制代码 
void AdjustDown(HPDataType* a, int size, int parent)
{
    int child = parent * 2 + 1;
    while (child < size) {
        if (child + 1 < size && a[child + 1] < a[child]) {
            child++;
        }
        if (a[child] < a[parent]) {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 - 1;
        }
        else {
            break;
        }
    }
}
  • 通过传入参数获取到当前的左子节点的位置。
  • 当child位置小于数组元素个数时进行判断。
  • 进入循环，首先判断检查右子节点是否存在并且比左子节点的值小，如果是，将 child 更新为右子节点的索引，以确保选择更小的子节点进行比较。
  • 比较选定的子节点的值与父节点的值，如果子节点的值小于父节点的值，就交换它们。
  • 更新parent为新的子节点位置，更新child为新的左子节点位置，然后继续比较和交换，直到不再需要交换为止。
  • 如果当前子节点不小于当前父节点则停止循环。

10、获取堆元素个数

cpp 复制代码 
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

五、使用堆排序

我们先来看看这种方式：

cpp 复制代码 
void HeapSort(int* a, int n)
{
	HP hp;
	HeapInit(&hp);
    // 时间复杂度：N*logN
	for (int i = 0; i < n; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	// 时间复杂度：N*logN
	int i = 0;
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		a[i++] = top;
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

可以使用这种方式，但有诸多弊端：

  1. 要先有一个堆,太麻烦。
  2. 空间复杂度+拷贝数据

排降序建小堆

我们要在传入的原数组上排降序，需要使用建小堆的方式向上或向下调整，使用这种方式是最优选择！！！

向上调整

cpp 复制代码 
void HeapSort(int* a, int n)
{
	// 建堆--向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);

		// 再调整，选出次小的数
		AdjustDown(a, end, 0);

		--end;
	}
}
  • 从根节点的子节点开始从上往下向上建堆，除了根节点以外，每个节点都进行向上调整。
  • 定义堆的最后一个节点end为n-1
  • 我们将堆的根节点（也就是最小值）与堆的最后一个元素交换，即将最小值放到排序尾部即为好的部分。接下来，通过调用AdjustDown函数，将堆的大小减一，再次将堆调整为最小堆。
  • 重复while循环内部操作，直到整个数组排序完成。每次交换和堆的调整都会将最小的元素添加到已排序的部分，直到整个数组都有序。

向下调整的时间复杂度为log(n)（下面有讲解），所以 HeapSort 的时间复杂度为O(n log(n)) ，它不需要额外的空间来存储数据，所以是一种原地排序算法。它在最坏情况下的性能仍然是O(n** log(n))，因此相对稳定，适用于大规模数据的排序。

向下建堆

我们也可以向下建堆：

倒着调整叶子节点不需要处理（因为叶子节点没有子节点无法向下比较），从倒数第一个非叶子节点开始，即最后一个节点的父节点开始调整，从下往上向下建堆。

cpp 复制代码 
void HeapSort(int* a, int n)
{

	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
    {	
        AdjustDown(a, n, i);
    }

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);

		AdjustDown(a, end, 0);

		--end;
	}
}

建堆方式对比

向上调整和向下调整哪种方式更好呢？

结论：向下建堆的时间复杂度比向上建堆小。

  • 接下来我们来看看二者的时间复杂度如何计算
    向下调整建堆计算过程如下：

向上调整建堆计算过程如下：

完整版：

Heap.h声明部分

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

void HeapInit(HP* php);
void HeapDestroy(HP* php);

void AdjustUp(HPDataType* a, int child);
void HeapPush(HP* php, HPDataType x);
bool HeapEmpty(HP* php);
void AdjustDown(int* a, int n, int parent);
void HeapPop(HP* php);

HPDataType HeapTop(HP* php);
int HeapSize(HP* php);

Heap.c函数部分

cpp 复制代码 
#include "Heap.h"

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

void HeapDestroy(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	while (child>0) {
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	if (php->size == php->capacity) {
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));
		if (tmp==NULL) {
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}

	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);
}

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size==0;
}
void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size) {
		if (child + 1 < size && a[child + 1] < a[child]) {
			child++;
		}
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 - 1;
		}
		else {
			break;
		}
	}
}

void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	return php->a[0];
}

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

text.c使用及测试部分

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

void HeapSort(int* a, int n)
{
	// 建堆--向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}

    // 建堆--向下调整建堆
	//for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	//{
	//	AdjustDown(a, n, i);
	//}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);

		// 再调整，选出次小的数
		AdjustDown(a, end, 0);

		--end;
	}		
}

int main()
{
	int a[] = { 7,8,3,5,1,9,5,4 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < 8; i++) {
		printf("%d  ", a[i]);
	}
	return 0;
}

//---测试堆函数功能---
//int main()
//{
//	HP hp;
//	HeapInit(&hp);
//	int a[] = { 65,100,70,32,50,60 };
//	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
//	{
//		HeapPush(&hp, a[i]);
//	}
//	
//	while (!HeapEmpty(&hp))
//	{
//		int top = HeapTop(&hp);
//		printf("%d\n", top);
//		HeapPop(&hp);
//	}
//
//	return 0;
//}
相关推荐
大锦终15 分钟前
【C++】unordered_map与set的模拟实现
开发语言·数据结构·c++·哈希算法
wniuniu_26 分钟前
socc19 echash部分代码讲解 二 hashtable
算法·哈希算法
ai.Neo1 小时前
牛客网NC276055:三根木棒能否组成三角形问题详解(ACM中的A题)
数据结构·c++·算法
_安晓1 小时前
数据结构 -- 树形查找（三）红黑树
数据结构
じ☆ve 清风°1 小时前
滑动窗口算法详解与C++实现
开发语言·c++·算法
tmacfrank1 小时前
Android 性能优化入门（一）—— 数据结构优化
android·数据结构·性能优化
东莞呵呵2 小时前
吴恩达机器学习（1）——机器学习算法分类
算法·机器学习·分类
JeffersonZU5 小时前
【数据结构】2-3-2 单链表的插入删除
数据结构
m0_738206545 小时前
嵌入式学习的第二十二天-数据结构-栈+队列
数据结构·学习
远瞻。6 小时前
【论文阅读】人脸修复(face restoration ) 不同先验代表算法整理2
论文阅读·算法
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU06Coze扣子平台完整体验和实践（附国内和国际版对比）07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08DeepSeek各版本说明与优缺点分析09苍穹外卖面试总结10Ubuntu24.04安装中文输入法