【数据结构】堆的实现及排序

---

一、树的相关概念及其特殊二叉树

讲堆之前，我们先讲讲树的相关概念及其特殊二叉树，因为堆是一种二叉树，是一棵完全二叉树。

1、数的相关概念

• 节点的度：一个节点含有的子树的个数，如A的度为3
• 叶子节点：度为0的节点，如F、L、H、M等
• 非叶子节点：度不为0的节点，如B、C、D、G等
• 双亲节点或父节点：若一个节点有子节点，则这个节点称为其子节点的父节点，如A是B的父节点
• 孩子节点或子节点：一个节点含有子树的根节点称为该节点的子节点，如B是A的子节点
• 兄弟节点：具有树同父节点的节点互称为兄弟节点，如B、C是兄弟节点
• 树的度：一棵树中，节点最大的度是树的度，如上图树的度为3
• 节点的层次：从根开始定义起，根为第一层，根的子节点为第二层，依次类推
• 树的高度或深度：树中节点的最大层次为树的高度，如上图树的高度为4
• 堂兄弟节点：双亲在同一层的节点互为堂兄弟，如L、M互为堂兄弟节点
• 节点的祖先：从根到该节点所经分支上的所以节点，如A是所以节点的祖先
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙，如所以节点都是A的子孙
• 森林：由m(m>0)棵互不相交的树的集合称为森林

---

2、特殊二叉树

二叉树是由一个根节点加上左子树和右子树组成

2.1、满二叉树

满二叉树每一个层的节点数都达到最大值
若一个满二叉树有K层，则第K层的节点数为2^(K-1)
总节点数为2^K-1
假设一个满二叉树有N个节点，则该树的高度为h=log(N+1)

2.2、完全二叉树

完全二叉树前N-1层是满的，最后一层可以不满，但是必须是从左到右是连续的
假设完全二叉树的高度是h
最多节点数为2^h-1
最少节点数为2^(h-1)

对任何一棵二叉树，如果度为0的叶子节点个数为N0，度为2的分支节点个数为N2，则有N0=N2+1，即度为0的节点总比度为2的节点多一个

---

二、堆

1、堆的实现

堆分为大堆和小堆，实际存储在一个数组当中。
大堆：树中所有父亲都大于等于孩子
小堆：树中所有父亲都小于等于孩子

堆的性质：

• 堆中某个节点的值总是不大于或不小于其父节点的值
• 堆总是一棵完全二叉树

堆孩子和父亲的下标关系

parent = (child - 1) / 2
leftchild = parent * 2 +1
rightchild = parent * 2 +2

1.1、堆向下调整算法和向上调整算法的时间复杂度

堆调整算法有一个要求：左右子树都必须是一个堆，才能调整

1、向下调整

以满二叉树为例：


由此可知，向下调整的时间复杂度为O(N)

代码实现：

void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		// 1、孩子大于父亲，交换，继续向下调整
		// 2、孩子小于父亲，则调整结束
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

以上代码建大堆，若要建小堆，则把a[child + 1] > a[child] 和 if (a[child] > a[parent]) 改为 a[child + 1] < a[child] 和 if (a[child] < a[parent])

---

2、向上调整

由此可知，向下调整的时间复杂度为O(N*logN)

代码实现：

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;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以上代码建大堆，若要建小堆，则把if (a[child] > a[parent]) 改为 if (a[child] < a[parent])

总结：

向下调整：节点多，调整少，节点少，调整多
向上调整：节点少，调整多，节点多，调整多
所以建堆，建议用向下调整

---

1.2、堆的构建

我们给一个数组，但还不是一个堆，我们可以通过建堆算法，把它构成一个堆。但是根节点的子树都不是堆，那我们怎么调整呢？我们可以从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就形成堆了。

此时就构建出一个大堆：

代码实现：

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

extern void AdjustDown(HPDataType* a, int n, int parent);

// 堆的构建
void HeapCreate(HP* 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);
	php->size = php->capacity = n;
	//建堆算法
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a, n, i);
	}
}

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

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

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

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

// 向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		// 1、孩子大于父亲，交换，继续向下调整
		// 2、孩子小于父亲，则调整结束
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

int main()
{
	HP hp;
	int a[] = { 1,5,3,8,7,6 };
	HeapInit(&hp);
	int n=sizeof(a) / sizeof(int);
	HeapCreate(&hp, a, n);
	HeapPrint(&hp);
	HeapDestroy(&hp);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

结果：

---

1.3、堆的插入

先插入一个10到堆尾，再进行向上调整算法，直到形成堆

代码实现：

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, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	php->a[php->size] = x;
	php->size++;
	// 向上调整
	AdjustUp(php->a, php->size - 1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

1.4、堆的删除

删除堆是删除堆顶元素，将堆顶的数据和最后一个数据交换，然后删除最后一个数据，在进行向下调整算法。

代码实现：

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);
}
1
2
3
4
5
6
7
8
9
10

---

1.5、取堆顶的数据、堆的个数及堆的判空

代码如下：

//取堆顶的数据
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}
//堆的个数
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}
// 堆的判空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

---

2、堆的排序

堆的排序分两个步骤：

1、建堆

• 升序：建大堆
• 降序：建小堆

2、利用堆删除思想来进行排序

• 把堆顶数据和最后一个数据进行交换，把最后一个数不看做堆里面的，相当于n-1个数，向下调整，选出次大的数。

代码如下：

#include 
typedef int HPDataType;

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
// 向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		// 1、孩子大于父亲，交换，继续向下调整
		// 2、孩子小于父亲，则调整结束
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
int main()
{
	int a[] = { 1,5,3,8,7,6 };
	int n = sizeof(a) / sizeof(int);
	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;
	}
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

运行结果：

---

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素
如：专业前10、世界500强等

举例：N个数中找最大的前K个数
第一种方法：建立一个N个数的大堆，删除K次，依次取堆顶
但是这个方法数据如果太大，就会放不进内存，直接存放在磁盘文件中，但是磁盘文件不能创建堆，所以次方法不适合。其时间复杂度为：O(N+logN*K)，空间复杂度为：O(1)

第二种方法：建立K个数的小堆，然后依次遍历数据，不堆顶大的数据，就替换堆顶，在向下调整，最后最大的K个数就在这个小堆里面。 时间复杂度：O(N*logK)，空间复杂度：O(K)

假设有一个data.txt文件中有以下数据：

要找出前5个最大的数，代码如下：

#include 
typedef int HPDataType;

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
// 向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}

		// 1、孩子大于父亲，交换，继续向下调整
		// 2、孩子小于父亲，则调整结束
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
int main()
{	
	int minHeap[5];
	int k = 5;
	FILE* fout = fopen("data.txt", "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (int i = 0; i < 5; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);
	}
	// 建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(minHeap, k, i);
	}
	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);
	}
	printf("\n");
	fclose(fout);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

运行结果：