二叉树的顺序结构中堆的实现

前言：

本篇记录二叉树中的堆，堆实现的接口及用堆来进行堆排序

目录

1、二叉树的顺序结构及实现

1.1 二叉树的顺序结构

2、堆

2.1 堆的概念及结构

2.2 堆的实现

2.2.1 向上调整算法

 2.2.2 向下调整算法

2.2.3 堆的插入

2.2.4 堆的删除（删除的是堆顶数据）

2.2.5 完整代码

2.2.6 用堆实现堆排序 

3、总结 

---

1、二叉树的顺序结构及实现

1.1 二叉树的顺序结构

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

 

2、堆

2.1 堆的概念及结构

如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <= 且 <= ( >= 且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆（或大根堆），根节点最小的堆叫做最小堆或小根堆。

堆的性质：
1、堆中某个节点的值总是不大于或不小于其父节点的值；
2、堆总是一棵完全二叉树。

可以解决堆排序和TopK问题

2.2 堆的实现

2.2.1 向上调整算法

 

 本质是在操作数组

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

 2.2.2 向下调整算法

 

void AdjustDown(int* a, size_t n, size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < n)
	{
		//1.找到左右孩子小的那个
		if ((child + 1 < n) && 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;
		}
	}
}

2.2.3 堆的插入

在数组末尾插入数据，空间不够扩容；再将插入的数据向上调整，保证仍是堆

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//空间不够，扩容
	int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
	if (php->capacity == php->size)
	{
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (NULL == tmp)
		{
			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.2.4 堆的删除（删除的是堆顶数据）

思考：能不能利用顺序表思想，删除一个数据，无非就是覆盖，那要删除堆顶的数据，让后面直接覆盖不就可以了吗？

答案：不行！

一：删除如果用覆盖的话，时间复杂度O（N），效率太低；

二：把根删除了，堆结构被破坏，父子关系全部乱了

所以，挪动数据把堆顶元素删除是不可取的

---

更优的方案：

1、第一个数据和最后一个数据交换

2、删除最后一个元素

3、向下调整

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.2.5 完整代码

#pragma once

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

//本质上就是一个顺序表

typedef int HPDataType;

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

}HP;

void HeapInit(HP* php);

void HeapDestroy(HP* php);

void HeapPrint(HP* php);

void HeapPush(HP* php, HPDataType x);

void HeapPop(HP* php);

bool HeapEmpty(HP* php);

size_t HeapSize(HP* php);

HPDataType HeapTop(HP* php);

----------------------------------------------------------------------------------------
#include "Heap.h"

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

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

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

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

void AdjustUp(HPDataType* a, size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		//if (a[child] > a[parent]) //大堆
		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);
	//空间不够，扩容
	int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
	if (php->capacity == php->size)
	{
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (NULL == tmp)
		{
			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);
}

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);//最后向下调整

}

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

	return php->size == 0;
}

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

	return php->size;
}

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

	return php->a[0];
}
-----------------------------------------------------------------------------------------
#include "Heap.h"

//堆排序
void HeapSort(int a[], int sz)
{
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < sz; i++)
	{
		HeapPush(&hp, a[i]);
	}

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

int main()
{
	int a[] = { 1,2,5,6,3,9,0,8, 66 };
	int sz = sizeof(a) / sizeof(int);
	HeapSort(a ,sz);
	for (int i = 0; i < sz; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

2.2.6 用堆实现堆排序 

//堆排序
void HeapSort(int a[], int sz)
{
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < sz; i++)
	{
		HeapPush(&hp, a[i]);
	}

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

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

利用堆来进行堆排序，创建了一个数组，时间复杂度O（N * logN），空间复杂度为O（N）

在写堆排序难道还要写一个堆吗？

显然这种方法实现堆的效率不高，还可以优化

3、总结 

在堆的插入数据和删除数据中，向上调整算法和向下调整算法很重要，配合自己画图和思考，加深对这一块的理解。在堆这块知识上，逻辑上是二叉树，物理上是数组，结合这两个方面去思考，理解。