二叉树的存储结构、堆的实现、堆排序（C语言版）

人们为了获得生活，就得抛弃生活。

🍄1. 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

💒1.1顺序结构

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

🌟1.2链式结构

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，高阶数据结构如红黑树等会用到三叉链。

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
};

🍅2.二叉树的顺序结构及实现

💒2.1二叉树的顺序结构

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

🌟2.2堆的概念及结构

堆是一棵顺序存储的完全二叉树。
其中每个结点的关键字都不大于其孩子结点的关键字，这样的堆称为小根堆。
其中每个结点的关键字都不小于其孩子结点的关键字，这样的堆称为大根堆。
举例来说，对于n个元素的序列{K0, K1, … , Kn}当且仅当满足下列关系之一时，称之为堆：
(1) Ki <= K2i+1 且 Ki <= K2i+2 (小根堆)
(2) Ki >= K2i+1 且 Ki >= K2i+2 (大根堆)
其中i=1,2,…,n/2向下取整;

如上图所示，序列K{3, 8, 15, 31, 25}是一个典型的小根堆。
堆中有两个父结点，元素3和元素8。
元素3在数组中以K[0]表示，它的左孩子结点是K[1]，右孩子结点是K[2]。
元素8在数组中以K[1]表示，它的左孩子结点是K[3]，右孩子结点是K[4]，它的父结点是K[0]。可以看出，它们满足以下规律：
设当前元素在数组中以K[i]表示，那么，
(1) 它的左孩子结点是：K[2*i+1];
(2) 它的右孩子结点是：K[2*i+2];
(3) 它的父结点是：K[(i-1)/2];
(4) K[i] <= K[2*i+1] 且 K[i] <= K[2i+2]。

🌻2.3堆的实现

🍆2.3.1 Heap.h(堆的结构及接口函数声明）

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int HPDataType;

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

void Swap(HPDataType* pa, HPDataType* pb);
void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPrint(HP* php);

// 插入x以后，保持他依旧是(大/小)堆
void HeapPush(HP* php, HPDataType x);

// 删除堆顶的数据。(最小/最大)
void HeapPop(HP* php);
bool HeapEmpty(HP* php);
size_t HeapSize(HP* php);
HPDataType HeapTop(HP* php);

🍇2.3.2 Heap.c（接口函数实现）

🍈2.3.2.1 堆的初始化

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

🍉2.3.2.2 堆的销毁

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

🍊2.3.2.3. 堆的打印

void HeapPrint(HP* php)
{
	assert(php);
	for (rsize_t i = 0; i < php->size; ++i)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

🍌2.3.2.4. 堆的插入

先插入一个数到数组的尾上，有两种情况：

• 如果孩子节点>=父亲节点，此时已经满足小堆就不用做调整。
  
• 如果孩子节点<父亲节点，此时就要进行向上调整，直到满足堆，因为它影响了它的祖先节点。
  
  向上调整算法：
  
  代码演示：

void Swap(HPDataType* pa, HPDataType* pb)
{
	HPDataType tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

void AdjustUp(HPDataType* a,size_t child)
{
	size_t 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;
		}
	}
}

// 插入x以后，保持他依旧是(大/小)堆
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//满了要扩容
	if (php->size == php->capacity)
	{
		size_t newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	php->a[php->size] = x;
	++php->size;
	//向上调整算法,保持小堆
	AdjustUp(php->a, php->size - 1);
}

🍍2.3.2.5 堆的删除

删除堆是删除堆顶的数据，我们第一反应是将数组的数据往前覆盖一位。但这种做法是错误的，因为小堆只能保证孩子大于它们的父亲且时间复杂度是O(N).

正确的做法是将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

向下调整算法：

1. 找出左右孩子中小的那个
2. 跟父亲比较，如果比父亲小，交换
3. 父亲走到孩子位置并继续往小调整

代码演示：

//参数分别是数组，数组大小，根节点位置
void AdjustDown(HPDataType* a, size_t size, size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		// 1、选出左右孩子中小的那个
		if (child + 1 < size && a[child + 1] < a[child])
		{
			++child;
		}

		// 2、如果孩子小于父亲，则交换，并继续往下调整
		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(php->size > 0);

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

	AdjustDown(php->a, php->size, 0);
}

🌺2.3.2.7 判断堆是否为空

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

🍀2.3.2.8 堆的大小

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

	return php->size;
}

💐2.3.2.9 堆顶数据

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

💓2.3.2.6 代码测试

我们发现插入、删除数据后小堆建立成功并正确返回堆顶数据和堆的大小。

🍑2.4 堆的应用

🐾2.4.1 堆排序

🍁2.4.1.1 普通版本

利用我们之前的创建的小堆，我们直接的想法是把数据全部Push到堆里，建立小堆，然后依次取出堆顶的数据，这样便实现了升序的排序。
代码演示：

// 升序 O(N*logN)   1000*10    100w*20
//      O(N*N)      1000*1000  100w*100w

void HeapSort(int* a, int size)
{
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < size; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	size_t j = 0;
	while (!HeapEmpty(&hp))
	{
		a[j] = HeapTop(&hp);
		j++;
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

int main()
{
	//TestHeap();
	int a[] = { 4, 2, 7, 8, 5, 1, 0, 6 };
	HeapSort(a, sizeof(a) / sizeof(int));

	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

运行结果:

如果要排降序，就建立大堆，Push时就把大于父亲的孩子向上调整，Pop时选出左右孩子中较大的那个，如果大于父亲，交换

但是这个版本的堆排序的空间复杂度是O(N)，还需要再优化。

🍄2.4.1.2 优化版本

要求：

1. 时间复杂度为O(N*logN)
2. 空间复杂度为O(1)

实际上我们写堆排序是不会这样写的，没必要写一个堆，直接在数组上进行建堆，对数组建堆有两种方法。
第一种方法：使用向上调整，插入数据的思想建堆。
第二种方法：使用向下调整建堆。

代码演示：

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

那么两种方法那种跟好呢？
我们来算一下两种方法的时间复杂度。

1. 向上调整建堆
   
   第h层的节点要调整h-1次，最坏情况总的调整次数=每层数据个数*向上调整次数
   所以向上调整建堆进行的操作次数为：
   
   我们用错位相减法算得T(h)=2^h*(h-2)+2
   
   又高度N(节点总数)=2^h-1(等比数列求和）。
   得到h=log(N+1),默认以2为底数。
   所以向上调整建堆的时间复杂度为T(h)=2^h*(h-2)+2=(N+1)*(log(N+1)-2)+2即N*logN
2. 向下调整建堆
   最坏情况总的调整次数=每层数据个数*向下调整次数
   
   当N非常大时，log(n+1)的影响忽略不计。
   所以向下调整建堆的时间复杂度为O(N).

在搞清楚向下调整建堆的时间复杂度优于向上调整建堆之后，就可以开始对数据进行排序了。
那么如果要排升序，我们该建小堆还是大堆？
假设排升序我们建小堆

所以排升序要建大堆，具体思路为:

1. 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
2. 重新调整结构（此时最后一个数据不算堆里的），使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
   
   代码演示：

void HeapSort(int* a, int n)
{
	//向下调整建堆，从倒数的第一个非叶子结点（最后一个节点的父亲）开始调整
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	size_t end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

运行结果：

🌴2.4.2 TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

1. 排序的时间复杂度为O(N*logN),空间复杂度为O(1).
2. 建立N个数的大堆，Pop K次，就可以选出前k个最大的数。时间复杂度为O(N+logN*k),空间复杂度为O(1).

但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前K个元素来建堆

• 前k个最大的元素，则建小堆
• 前k个最小的元素，则建大堆

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

代码实现：

void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	int* kminHeap = (int*)malloc(sizeof(int)*k);
	assert(kminHeap);

	for (int i = 0; i < k; ++i)
	{
		kminHeap[i] = a[i];
	}

	// 建小堆
	for (int j = (k - 1 - 1) / 2; j >= 0; --j)
	{
		AdjustDown(kminHeap, k, j);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int i = k; i < n; ++i)
	{
		if (a[i] > kminHeap[0])
		{
			kminHeap[0] = a[i];
			AdjustDown(kminHeap, k, 0);
		}
	}

	for (int j = 0; j < k; ++j)
	{
		printf("%d ", kminHeap[j]);
	}
	printf("\n");
	free(kminHeap);
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int)*n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2305] = 1000000 + 6;
	a[99] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[0] = 1000000 + 1000;
	PrintTopK(a, n, 10);
}

int main()
{
	TestTopk();

	return 0;
}

运行结果：

🌱3.总结

这篇博客其实是博主自己整理的笔记，希望能帮到大家