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

有一个特殊的结点，称为根结点，根节点没有前驱结点。
除根节点外，其余结点被分成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，则一棵非空二叉树的**第i层上最多有**个结点。
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是。
对任何一棵二叉树, 如果度为0其叶结点个数为 n0 , 度为2的分支结点个数为 n2 ,则有 n0 ＝n2 ＋1。
若规定根节点的层数为1，具有n个结点的满二叉树的深度 ，h=log以2为底，n+1的对数。
对于具有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);
}

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

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

排降序建小堆

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

向上调整

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;
//}