🌺🌻🌼🌷 纵横数据结构与算法🌺🌻🌼🌷
目录
欢迎订阅本专栏,说在前面💖
今天给大家带来数据结构与算法堆的相关知识的讲解!
博主为了本系列专栏,做了很多准备,争取图文并茂,让大家看明白!希望大家不要吝啬订阅,与关注,多多评论哦!!💖💖💖💖💖💖💖
一、前言
💪💪💪💪那么这里博主先安利一下其他一些干货满满的专栏啦!💪💪💪💪
玩转Linux操作系统+系统编程+网络编程,快速掌握数据结构宝藏文章,点击下方蓝字即可跳转:
🔝🔝🔝🔝🔝玩转Linux操作系统+系统编程+网络编程🔝🔝🔝🔝🔝
CCF相关真题,点击下方蓝字即可跳转:
🔝🔝🔝🔝🔝 CCF真题🔝🔝🔝🔝🔝
刷题专栏,点击下方蓝字跳转:
🔝🔝🔝🔝🔝刷题专栏🔝🔝🔝🔝🔝
二 、正文
1.堆
关于堆的提出,其实是我们从二叉树的实现问题衍生出来的。我们知道我们要实现一颗二叉树,有两种方式。第一种是顺序实现,也就是借用我们顺序表实现的方式。第二种是链式结构实现,也就是借用链表那一套逻辑。
顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储,需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。
1.1堆的定义及其性质
1.2 小根堆的实现
头文件
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef int HpDatatype;
typedef struct Heap
{
HpDatatype* a;
int size;
int capacity;
}HP;
void swap(HpDatatype* x, HpDatatype* y);
void Adjustup(HpDatatype * a,int child);
void Adjustdown(HpDatatype * a,int size ,int parent);
void HpInit(HP* p);
void HpPrint(HP* p);
void HpPush(HP* p, HpDatatype x);
void HpPop(HP* p);
HpDatatype HpTop(HP* p);
bool HpEmpty(HP* p);
int HpSize(HP* p);
源文件
#include "Heap.h"
void HpInit(HP* p)
{
assert(p);
p->a = NULL;
p->capacity = p->size = 0;
}
void HpPrint(HP* p)
{
assert(p);
for (int i = 0; i < p->size; i++)
{
printf("%d ", p->a[i]);
}
printf("\n");
}
void swap(HpDatatype* x, HpDatatype* y)
{
HpDatatype tmp = 0;
tmp = *x;
*x = *y;
*y = tmp;
}
bool HpEmpty(HP* p)
{
assert(p);
return p->size == 0;
}
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;
}
}
}
void HpPush(HP* p, HpDatatype x) // 时间复杂度 O(log N)
{
assert(p);
if (p->capacity == p->size)
{
int newcapacity = (p->capacity == 0 ? 4 : p->capacity * 2);
HpDatatype* tmp = (HpDatatype*)realloc(p->a, sizeof(HpDatatype) * newcapacity);
assert(tmp);
p->a = tmp;
p->capacity = newcapacity;
}
p->a[p->size] = x;
p->size++;
Adjustup(p->a, p->size - 1);
}
void Adjustdown(HpDatatype* a, int size, int parent)//选出小的孩子然后交换!
{
int child = parent * 2 + 1; // 左孩子
while ( child < size )
{
if (child + 1 < size && a[child + 1] < a[child]) // chose smaller
{
child++;
}
if (a[child] < a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void HpPop(HP* p) //时间复杂度O(log N)
{
assert(p);
assert(!HpEmpty(p));
swap(&(p->a[0]),&( p->a[p->size - 1])) ;
p->size--;
Adjustdown(p->a, p->size, 0);
}
HpDatatype HpTop(HP* p)
{
assert(p);
return p->a[0];
}
int HpSize(HP* p)
{
assert(p);
return p->size;
}
其实在整个实现过程中最重要的其实就是两个函数,一个是adjustup 另有一个是 adjustdown。
我们先来看看,实现小根堆的逻辑
void Adjustup(HpDatatype* a, int child)
{
int parent = (child - 1) / 2;//关于孩子与父亲的下标问题,可以看二叉树章节
while (child > 0 )//写小堆即孩子要比父亲大 ,不佳可以写成child >=0,child=0的时候已经到根了
{
if (a[child] < a[parent])
{
swap(&a[child],&a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
向上调整我们可以用来进行插入数据时的成堆操作,一个数据被插入他只会影响他的祖先!
void Adjustdown(HpDatatype* a, int size, int parent)//因为是小根堆,选出小的孩子然后交换!
{
int child = parent * 2 + 1; // 左孩子
while ( child < size )// 等于size都没有孩子了
{
if (child + 1 < size && a[child + 1] < a[child]) // chose smaller 1如果右孩子大,那就选右孩子
{
child++;
}
if (a[child] < a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
1.3 大根堆的实现
所以,当我们要实现大根堆的时候只要修改两个调整算法就可以了。
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;
}
}
}
void Adjustdown(HpDatatype* a, int size, int parent)//选出大的孩子然后交换!
{
int 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;
}
}
}
2.堆排序
对于堆排序,我们要知道我们目前有两种建堆方式:
-
向上调整建堆:
向上调整对于条件没有任何要求,当你出传入一个数组时,直接从第二个元素开始依次向上插入即可成堆。但是我们可以想象到,这样的建堆时间复杂度是O(N*log N). -
向下调整建堆:
向下调整有一个前提要求就是 目前要调整节点的左右子树必须成堆。因为我们向下调整那一刻取决于两个孩子的大小,假如说我们要建一个大根堆,此时左孩子比有孩子大,我们将向左孩子方向调整。但如果此时最大的数在右孩子方向那么我们此次就永远地错过了最大的值。 但是我们的向下调整时间复杂度是O(N),所以我们采用向下调整的建堆方法,我们传入数组后,倒着从第一个非叶子节点开始向下调整即可。
3.排序方式:
(一)我们可以选择向下建堆,每次选出最大最小之后,再次向下建堆。但是这样的话我们的时间复杂度就是O(N*N)。
(二)我们也可以选择每次向下建堆完成后,将最大的数与最后的数交换,然后从根部向下调整一次,这样我们的时间复杂度便达到了O(N*log N).
void Heapsort(HpDatatype* a,int n)
{
for (int i = (n - 1 - 1) / 2; i >= 0; i--) //这里的 (n-1-1)/2 其实就是用最后一个元素的下标计算父节点的下标!!
{
Adjustdown(a, n, i);
}
int end = n - 1;
while (end > 0) //排序
{
swap(&a[0],&a[end]);
Adjustdown(a, end, 0); //从根出发
end--;
}
}
我们可以清晰地知道,当我们需要升序排序时,我们建立大堆,将顶部数据与末尾交换然后再次从根部向下调整 ,降序相反。
3.TOPK问题
TOP-K问题:即求数据结合中前K个最大的元素或者最小的元素,一般情况下数据量都比较大。
比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能数据都不能一下子全部加载到内存中)。
最佳的方式就是用堆来解决,基本思路如下:
1. 用数据集合中前K个元素来建堆
前k个最大的元素,则建小堆 (比堆顶大,则替换。后续比较N-K次后,堆中剩下的元素肯定比之前的都大,于是选出了TOPK)
前k个最小的元素,则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素
void TOPK(HP* p, int n,int k)//选出最大的k为例
{
int* karr = (int * )malloc(sizeof(int)*k);
for (int i = 0; i < k; i++)
{
karr[i] = p->a[i];
}
for (int i = (n - 1 - 1) / 2; i >= 0; ik--)
{
Adjustdown(karr, k, i);
}
for (int i = k; i < n; i++)
{
if (p->a[i] > karr[0])
{
karr[0] = p->a[i];
Adjustdown(karr, k, 0);
}
}
}
三、 结尾💖
🌹🌹🌹🌹🌹🌹🌹 感谢大家的点赞关注,希望大家多多评论!!!🌹🌹🌹🌹🌹🌹🌹