【数据结构】实现堆结构 ---超细致解析

luck++

已于 2022-04-29 21:57:09 修改

阅读量1.6k

点赞数 12

文章标签：数据结构排序算法

于 2022-04-28 15:03:38 首次发布

本文链接：https://blog.csdn.net/qq_61344207/article/details/124120002

版权

二叉树的性质：

在我们实现堆之前我们要知道堆的实现是依靠的是二叉树所以我们在实现对之前要了解一下二叉树的基本性质：>

如果根节点的层数为1，则一个非空二叉树的第 i 层上最多有2^(i-1)个节点
若规定根节点的层数为1，则深度为h的二叉树的最大节点数是2^h - 1
对于任何一棵二叉树，如果度为0的节点个数是n0，度为2的分支节点个数为n2，则有n0=n2+1
如果说根节点的层数为1，那么具有那个节点的满二叉树的深度 h=log2(n+1);

这些就是我们二叉树的一些基本性质

二叉树的存储结构：

二叉树一般有两种存储结构一个顺序结构一个链式结构

顺序存储：

顺序存储顾名思义就是存储的数据是有一定顺序的所以顺序存储就是用数组来进行存储但是使用顺序存储一般用来存储完全二叉树因为不是完全二叉树会有空间的浪费（就是有些地方应该为NULL 那么在数组里面这些地方也应该空着它们只能属于自己的位置）

像这样大家应该就知道如果说不是完全二叉树使用顺序结构的话会有空间的浪费数据越多浪费的空间也可能更多

链式存储：

链式存储意思就是用链表来表示一个链表的节点就包括这个节点的数据和左右节点的指针

typedef struct BinaryTreeNode
{
	int data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

堆的概念和性质：

堆其实就是一个完全二叉树其中堆又分为小堆和大堆

小堆就是根节点是所有数据中最小的

大堆就是根节点是所有数据中最大的

堆的实现：

首先这里我们就用数组的方式来存储数据

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

另外有个点大家要注意我们的堆是不支持什么在中间插入删除数据的这种操作是顺序表中使用的但我们的堆虽然是使用的数组的结构但那只是物理上面的逻辑上面可不是那样的哦

这里我们为什么还有一个size capacity呢这两个参数是用来判断是否扩容的我们这里设置的是一个动态增长的数组

堆的初始化：

void HeapInit(Heap* hp)
{
	assert(hp);

	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

void HeapDestory(Heap* hp)
{
	assert(hp);

	free(hp->a);
	hp->a = NULL;
	hp->capacity = hp->size = 0;
}

堆的插入：

我们先了解一下堆的插入是如何实现首先我们的堆的结构是一个动态的数组我们在他的尾部插入数据但大家想想仅仅只是把数据放进去就完了嘛我们上面说过我们堆里面的数据位置是有讲究的如果说随便改变是有可能会把我们之前建立的结构破坏的

所以如果我们建立的是一个小堆的话现在放进去一个较小的数据那么这个数据肯定是要往前面进行调整的不然我们的堆就不是小堆 :>

看过上图大家应该知道我们因给如何调整我们的堆结构了把：

就是向上调整

这个就是我们的向上调整的整体操作

void HeapPush(Heap* hp, HPDataType x)
{
	if (hp->_size == hp->_capacity)
	{
		int newcapcity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
		HPDataType* tmp=(HPDataType *)malloc(newcapcity * sizeof( HPDataType));
		assert(tmp);
		hp->_a = tmp;
	}

	hp->_a[hp->_size++] = x;
	AdjustUp(hp->_a, hp->_size - 1);//因为我们我们调整是从最后一个数据开始调 所以要传他的下标
}

因为我们堆的实现物理上还是依靠的顺序表虽说结构上是树但我们在插入数据的时候难免会遇到要扩容的情况所以我们使用了 size 和 capacity 来实时监控我们的空间

然后就来看我们的向上调整函数：

向上调整函数：

在实现我们的向上调整函数之前我们首先要了解树中父亲和孩子的关系

左孩子=父亲×2+1

右孩子=父亲×2+2

然后大家想想其实无论奇数还是偶数 -1÷2 的结果都是一样的我的编译器 ÷ 是默认的向下取整带入几个数算了就知道他们的结果都是一样的但你要-2÷2就不太好了

void AdjustUp(HPDataType* a,int child)
{
	assert(a);
	size_t parent = (child - 1) >> 1;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(a+child, a+parent);
			child = parent;
			parent= (child - 1) >> 1;
		}
		else
		{
			break;
		}
	}
}

看到这个图大家应该明白我们的child 排到0时就不用再继续往上调整了

所以我们设置的外部循环是 child>0 至于为什么不用parent判断因为parent不会小于0

我们的child等于0的时候 (0-1)/2 parent还是等于0的

里面设置一个if 小于就交换大于就不用再换了大于一个数那它都大于它上面的了

然后重新给我们的 child parent 赋值

堆的删除：

堆的删除操作就是删除根节点也就是最大或者最小的数那大家觉得怎样删除既能删掉数据还不会破坏我们的堆结构呢？

可能我们会觉得删除数据嘛就把它删了不就行了把它后面的数据往前面覆盖把它覆盖掉不就行了嘛真的是这样嘛我们来看一下：

其次还有一个问题就是如果这样删除数据每次移动数据都是O(N)

现在我们再来看正确的做法：

先将最后一个数据和根节点交换然后把size--删掉最后一个数据

这样现在我们的根节点就是一个较大的数然后使用 向下调整 函数

向下调整函数：

因为我们向下调整最多调整高度次所以我们这个删除函数的时间复杂度是O(N)

大家看这张图明白是怎么做的了嘛

找出左右孩子中最小的那一个
与父亲比较
如果交换继续向下调整

两个孩子节点为什么要选最小的？

因为我们的父亲节点有两个孩子节点要从中选出较小的那一个该怎么选呢？

因为我们选择最小的换上去后也是比它的兄弟节点小的

void Adjustdown(HPDataType* a, size_t size, int root)//向下调整
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] < a[child])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child= parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

这里我们的循环条件是 while(child<n) 因为当我们排到叶子节点的时候这个时候已经是最后一次了之所以不用 while(parent<n) 是因为有可能这样我们的child会越界当我们已经计算出child>n了可是parent<n 这个时候在进去比较就会越界了除非在第二个 if 判断语句那里在加一个限制条件

至于选左右孩子最小就像上面那样就好了但是要注意有时我们的左孩子可能不存在所以我们还要保证 child+1<n

我们的child赋值一开始也是右孩子的下标

了解了这些我们就可以实现一下我们的堆排序了

    Heap hp;

	HeapInit(&hp);
	
    int a[11]={1,0,2,8,5,6,9,3,8,4};
    for(int i=0;i<sizeof(a)/sizeof(int);i++)
    {   
        HeapPush(&hp,a[i]); 
    }    

    size_t j=0;
    while(!HeapEmpty(&hp))
    {
        a[j++]=HeapTop(&hp);//0 1 2 3 4 5 6 8 8 9
        HeapPop(&hp);
    }
    
    HeapDestory(&hp);

大家注意我们这里的时间复杂度是 N*logN 哦入数据是N*logN 排序也是N*logN 所以总的时间复杂度就是N*logN 因为我们有N个数每个数无论是入数据还是删除数据每次都是logN

logN其实就是我们的层数(可以说是接近吧毕竟2^h-1=N h=log(N+1)) 大家可以这样理解

接下来给大家说一下另一种更好的排序在此之前呢我们先来了解一下两种思想：向上建堆和向下建堆

向上建堆：

首先向上建堆的思想是我们把一个数组的首元素看作是一个堆其后的数据作为要插入的数据就好像是上面堆的插入的思想

    int a[10]={0};
    for(int i=0;i<10;i++)
    {
        a[i]=i;    
    }
    
    for(int i=1;i<size;i++)
    {
        AdjustUp(a,i);
    }

我们依次对数组中的元素进行向上调整那么最后调整完就是一个调整好的堆了

向下建堆：

向下建堆其实也是和向上建堆的思想其实是一样的所以向下建堆就是使用向下调整函数来调整我们的原数组

那我们向下调整是从那里开始呢

大家看这张图觉得我们向下调整应该从那里开始呢？

如果我们从第一个数开始调这样大家调完就会发现是不可行的回顾我们上面的向下调整会发现我们从第一个数看它的左右子树都是小堆所以呢其实我们使用向下调整算法要知道开始位置往下的左右子树要么全是大堆要么全是小堆

看了上面这段话大家有思路了嘛我们知道我们在对一个节点开始向下调整那么它的左右子树必须是堆所以我们从下往上依次进行向下调整那这样是不是就保证了刚刚的条件了呢

大家看这张图明白怎么做了嘛？

for(int i=(size-1-1)/2;i>=0;i--)//size-1是最后一个节点的下标
{
    AdjustDown(a,size，i);
}

其实就是从倒数的第一个非叶子节点(最后一个节点的父亲节点)开始往上递归做向下调整

我们找到后在从该节点-- 就可以把所有的数都调整一遍了

并且建堆的方式不同建出来的堆也是不一样的虽然建的都是小堆

既然有这两种方法那哪一种方法更好呢？看这文章就知道了：【数据结构】堆的建立 (时间复杂度计算-堆排序)---超细致_luck++的博客-CSDN博客

这里面还包括了堆排序的实现以及整体的思路打击有兴趣可以看看哦

TopK问题：

TopK问题字如其名其实就是我们在N个数里面找出最大的（最小）前K个数

大家有什么思路嘛？

其实有这样的几个思路：

① 我们直接进行排序选数

② 我们建立以个N个数的大堆 Pop k 次就选出前K个最大的数

这两种方法可行但是万一我们的N很大呢是不是我们的排序效率就很低了呢是不是我们的建N个数的大堆也就空间不支持了呢？

对于这种问题我们可以这样解决：

假设我们要选前K个最大的数我们首先排出K个数的小堆然后我们再遍历N-K个数如果遇到比小堆的根节点的数更大的数就交换并且交换完对堆进行向下调整这样就能保证下一次入数据不会因为根节点的数据更大而进不去了

void PrintTopK(int* a, int n, int k)
{
	int* kminHeap = (int*)malloc(4 * k);
	assert(kminHeap);
	for (int i = 0; i < k; i++)//将数据放入我们建堆的数组中
	{
		kminHeap[i] = a[i];
	}

	for (int i = (k - 1 - 1) / 2; i >= 0; i--)//向下调整建堆（小堆）
	{
		Adjustdown(kminHeap, k, i);
	}

	for (int i = 0; i < n; i++)//N-K个数依次与堆顶的数比较
	{
		if (kminHeap[0] < a[i])
		{
			kminHeap[0] = a[i];
			Adjustdown(kminHeap, k, 0);
		}
	}

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

void TestTopk()
{
	int* p = (int*)malloc(10000 * sizeof(int));
	assert(p);
	srand((unsigned int)time(0));

	for (int i = 0; i < 10000; i++)
	{
		p[i] = rand() % 10000;
	}
	p[1221] = 10000 + 3;
	p[223] = 10000 + 5;
	p[678] = 10000 + 9;
	p[345] = 10000 + 2;
	p[897] = 10000;
	p[4567] = 10000 + 10;
	p[2345] = 10000 + 6;

	PrintTopK(p, 10000, 7);
}