《堆的概念和结构以及堆排序》

---

前言

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

---

堆的概念及结构

堆(数据结构) 在逻辑上是一个完全二叉树而在物理上是一个数组。

堆是一种顺序存储结构（采用数组方式存储），仅仅是利用完全二叉树的顺序结构的特点进行分析。
已知二叉树根结点的下标是root,那么它左孩子的下标left=2*root+1，右孩子的下标right=2*root+2。
已知孩子结点的下标（不区分左右)为child，那么双亲的下标为（child-1)/2。

将满足根的值小于等于所有子树结点的值，称为小堆；根的值大于等于所有子树结点的值称为大堆。

---

堆的实现

我们实现堆还是要用三个文件，来让堆的代码看起来更加的简单易懂，
test.c，用来让测试堆的代码
Heap.c，我们些堆的函数
Heap.h，包括堆函数的头文件

(1)创建一个堆

typedef int HPDataType;

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

(2)堆的初始化

//初始化堆
void HeapInit(Heap* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}

(3)堆的销毁

//销毁堆
void HeapDestory(Heap* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size;
}

(4)打印堆

//打印堆
void HeapPrint(Heap* php)
{
	assert(php);
	for (int i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

(5)堆的添加元素

因为堆本质上是一个数组，我们堆添加元素的思路，就是在数组的最后一位添加元素，然后看他的父节点是不是比他大或者小(创建大堆和创建小堆)，如果是大堆，父节点比他小，就交换，然后知道最后交换到头结点。

这时我们就用到一种算法，叫做向上调整算法。

向上调整算法

//向上调整
//大堆：将孩子和父节点比较，比父节点大，则交换，比父节点小，就break。循环下去，直到把这个新插入的数字送到头
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			child = parent; //往上推
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

交换函数

//交换函数
void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

堆插入元素的代码

//在堆尾面插入数据
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* temp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc fail");
			exit(-1);
		}

		php->a = temp;
		php->capacity = newcapacity;
	}
	php->a[php->size++] = x; //插入元素

	AdjustUp(php->a, php->size - 1);  //将刚插入的元素进行向上调整
}

(6)删除堆顶的元素

我们堆删除元素，都是删除堆顶的元素，那么怎么删除元素了，
我们数组，最好删除的元素就是尾删，所以我们将第一个 元素和最后一个元素交换，然后我们size–.

然后我们在删除完后，还要保持他是一个堆，用到一个向下调整算法。

这个算法就是将父节点（最根节点开始），和他的最大的子节点进行交换，然后在进行到最后。

向下调整算法

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = 2 * parent + 1;
	while (child < n)
	{
		//找大孩子,要防止child+1越界
		if (child + +1 < n && a[child] > a[child + 1])
		{
			child++;
		}

		//比较父亲和大孩子
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child; //往下压
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

物理和逻辑图的详细对比

删除元素的框架

//删除堆顶元素
//将堆顶元素和最后一个元素交换，然后删除堆尾元素，再对剩余的size-1个元素进行向下调整
void HeapPop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->a[0], &php->a[php->size - 1]); //交换堆顶和堆尾元素
	php->size--;//删除堆尾元素
	AdjustDown(php->a, php->size - 1, 0); //对剩余的size-1个元素进行调整
}

(7)找堆顶的元素

//找堆顶元素
HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	return php->a[0];
}

(8)查看堆的大小

//查看堆的大小
HPDataType HeapSize(Heap* php)
{
	assert(php);
	return php->size;
}

(9)判断堆是否为空

//判断堆是否为空
bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

---

堆的构建

我们堆的构建用的算法是我们在删除元素的时候向下调整算法。至于为什么不用向上调整，我们后面分析

void HeapCreat(Heap* php, HPDataType* a, int n)
{
	assert(php);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	memcpy(php->a, a, sizeof(HPDataType) * n); //将a拷贝到堆里拷贝过来
	php->capacity = php->size = n; //n是元素个数

	//向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a, n, i);//传父节点
	}
}

堆排序

我们想要堆排序，首先我们就要建堆，有了堆我们才可以排序，所以我们怎么将一个数组变成一个堆呢？
首先有两种方法，
1.第一种就是用插入的思想，将每一个数一个一个插进去，这时就要用我们的向上调整算法。
2.第二种方法就是用我们的上面用向下调整算法的思想建堆

向上调整算法建堆

其实这个思想就是将我们的每一个数插入堆的方法，肯定大家又点不理解，下来画个图，大家就理解了

<1>向上调整算法建堆代码

直接从头遍历一遍，一个一个调整就行了

	//向上调整
	for (int i = 1 ; i < n; i++)
	{
		AdjustUp(php->a,i);//传父节点
	}

<2>向上调整建堆的时间复杂度

我们向上调整算法将每个数遍历一遍，然后将每个数的都要进行向上调整算法，我们就可以通过计算算,高度为h，
第一层不需要调整，
第二层开始调整，第二层有$2^1$ 个元素，每个再向上调整中进行了一次调整。
第三层有$2^2$个元素,每个数最多调整2次
依次类推，在第n层，有$2^{h-1}$个元素，每个元素换h-1次。

向下调整算法建堆

思路就是：我们想将最后一个叶子结点和他的父节点，先构成一个堆，然后我们再将父节点的上一个结点的子节点，将这个构建一个堆，知道最后到根结点。看下面我画的解释图。

<1>向下调整算法建堆代码：

	//向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a, n, i);//传父节点
	}

<2>向下调整算法的时间复杂度

有的同学，看都不看，看到了两个循环，直接就说他的时间复杂度是O($N^2$),这样就错了

首先分析一下，因为我们是从我们的最后一个数的父节点才开始算，我们的最后的叶子结点就不进行计算，而且我们想一下，我们的最多的结点不算，这种算法，一看这个时间复杂度就可以。
所以我们的最后一层没有进行堆排，
在我们的倒数第二层就进行一次调整
在倒数第三层进行2次调整
所以依次类推，第一层就进行h-1次调整

比较两种算法

我们比较算法就是通过时间复杂度和空间复杂度进行比较，我们很容易就比较出来了，明显是向下调整算法好。他的时间复杂度底。
其实这个我们也可以通过画思路图就可以看明白了，

在向上调整算法中，我们的最后一层的结点最多，并且向上进行最多次，
而在向下调整算法中，我们最后一层的结点都不进行排序，并且在倒数第二层最多的结点才进行一次，而到了最高层最少的结点进行最多次。

如果我们要升序，建大堆还是建小堆

首先先说答案：建大堆。
思路：为什们建大堆，我们大堆的头就是最大的数，这是无容置疑的，然后我们将最大的数和堆最后一个数进行交换，我们的再用向下调整算法调整堆不包括最后一个最大的数，(利用我们堆的删除的思路)知道我们的堆就剩下一个。

//堆排序
void HeapSort(HPDataType* 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);//对剩余的n-1个数据调整
		end--;
	}
}

堆排序的时间复杂度

Top-K问题

TopK问题实战

我们建立一个文件，向文件内随机写入n个1000以内的数字，求前K个最大的数字

//TopK问题
//自己创立一个文件，往里面随机写入1000个数字，再找前10大的数字
void test6()
{
	int n, k;
	printf("请输入n和k:>");
	scanf("%d%d", &n, &k);


	srand((size_t)time(NULL)); //播种
	FILE* pin = fopen("data.txt", "w");
	if (pin == NULL)
	{
		perror("fopen fail");
		return;
	}

	//向文件中写入n个随机10000以内数字
	while (n--)
	{
		int val = rand() % 10000; //限定10000以内的数字
		fprintf(pin, "%d\n", val);
	}
	fclose(pin);

	/****************************************************/
	//找topK
	//int minHeap[k];  //不能有变长数组

	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}


	FILE* pout = fopen("data.txt", "r");
	if (pout == NULL)
	{
		perror("fopen fail");
		return;
	}

	//建立小堆
	int i = 0;
	//取数字
	for (i = 0; i < k; i++)
	{
		fscanf(pout, "%d", &minHeap[i]);
	}
	//建堆
	for (i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(minHeap, k, i);
	}

	//比较
	int val = 0;
	while (fscanf(pout, "%d", &val) != EOF)
	{
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}


	//打印堆
	for (i = 0; i < k; i++)
	{
		printf("%d ", minHeap[i]);
	}

	free(minHeap);
	minHeap = NULL;

	fclose(pout);
	pout = NULL;
}