数据结构——堆的结构及实现详解_数据结构用什么存放堆

堆

如题，这里说的堆并不是计算机进程地址空间中的堆，而是数据结构中的堆

堆的作用： 选最大数或最小数，不断选数，时间复杂度是O（LogN）

注意： 在数据结构中，堆是一种完全二叉树，适合用数组存储。只有非完全二叉树不适合用线性表来存储，因为空白部分会浪费空间。

堆的实现

头文件

#pragma once
#include<stdio.h>
typedef int HpDateType;
typedef struct Heap
{
	HpDateType* _a;
	size_t _size;
	size_t _capacity;
}Heap;
void AdjustDown(HpDateType* a, size_t n, int root);
Heap* HeapCreat(HpDateType* a, size_t n);
void HeapPush(Heap* hp, HpDateType x);
void HeapPop(Heap* hp);
HpDateType HeapTop(Heap* hp);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

建堆： 堆的初始化

Heap* HeapCreat(Heap* hp, HpDateType* a, size_t n)
{
	hp->_a = (HpDateType*)malloc(sizeof(HpDateType)*n);
	memcpy(hp->_a, a, sizeof(HpDateType)*n);
	hp->_size = n;
	hp->_capacity = n;
	//建小堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(hp->_a, hp->_size, i);
	}
	return hp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

注意： 为什么n-1-1呢 因为假如数组10个元素 -1才到最后一个元素的下标 即9。调堆要从最后一个下表的父开始调 按照公式就是 - 1除以2

向下调整算法： 一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

void AdjustDown(HpDateType* a, size_t n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)//即child存在时
	{
		//找出更小的那个孩子
		if (a[child + 1] < a[child])
		{
			++child;
		}
		//如果孩子比父亲小就交换，继续向下调
		//如果孩子比父亲大就终止调整
		if (a[parent]>a[child])
		{
			HpDateType tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;
			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
26
27

堆的插入：先插入数据到数组的尾上，再进行向上调整算法，知道满足堆。

void HeapPush(Heap* hp, HpDateType x)
{
	//空间不够则增容
	if (hp->_size == hp->_capacity)
	{
		size_t newcapacity = hp->_capacity * 2;
		hp->_a = (HpDateType*)realloc(sizeof(HpDateType)*newcapacity);
		hp->_a[hp->_size] = x;
		hp->_size++;
		//向上调整，调成堆
		AdjustUp(hp->_a, hp->_size - 1);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

向上调整算法

void AdjustUp(HpDateType*a, HpDateType child)
{
	int parent=(child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			int tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;
			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
18
19
20

堆的删除：删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调
整算法。（如果直接删除堆顶的数据，整个堆就都乱了，再调堆代价太大）

void HeapPop(Heap* hp)
{
	int tmp = hp->_a[0];
	hp->_a[0] = hp->_a[hp->_size - 1];
	hp->_a[hp->_size - 1] = tmp;
	hp->_size--;
	AdjustDown(hp->_a, hp->_size, 0);
}
1
2
3
4
5
6
7
8

直接size–，简单粗暴XD

取堆里面的数据

HpDateType HeapTop(Heap* hp)
{
	return hp->_a[0];
}
1
2
3
4