网站导航
> 文章列表 > 数据结构_第十关：二叉树的顺序结构——堆

数据结构_第十关：二叉树的顺序结构——堆

网友: 文章列表 2024-03-21 23:45:06

数据结构_第十关：二叉树的顺序结构——堆

目录

1. 二叉树的顺序结构

2.堆的概念及结构

3.堆的实现

3.1堆向下调整算法

 3.2堆的创建

3.3堆的插入

3.4建堆的复杂度

3.5堆的删除

4.堆的代码实现

4.1堆的定义

4.2堆的函数实现

1）堆的初始化

2）堆的销毁

3）堆的插入

4）堆的删除

5）取堆顶的数据

6）堆的数据个数

7）堆的判空

8）堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）

4.3堆的源代码和测试（vs2022下编译）

5.堆排序

6.TOP-K问题

1. 二叉树的顺序结构

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

2.堆的概念及结构

如果有一个关键码的集合K = { k0，k1 ，k2 ，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：i=0，1，2...

则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

人话说就是：
大堆：树中所有 父节点  都  大于或等于  子节点
小堆：树中所有 父节点  都  小于或等于  子节点

孩子和小标之前有一个关系：

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

 选择题

1.下列关键字序列为堆的是：（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100
C 65,100,70,32,50,60
D 70,65,100,32,50,60
E 32,50,100,70,65,60
F 50,100,70,65,60,32

2.已知小根堆为8,15,10,21,34,16,12，删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次
数是（）。
A 1
B 2
C 3
D 4

3.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为
A(11 5 7 2 3 17)
B(11 5 7 2 17 3)
C(17 11 7 2 3 5)
D(17 11 7 5 3 2)
E(17 7 11 3 5 2)
F(17 7 11 3 2 5)

4.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后，其结果是（）
A[3，2，5，7，4，6，8]
B[2，3，5，7，4，6，8]
C[2，3，4，5，7，8，6]
D[2，3，4，5，6，7，8]

答案：

A

C

C

C

3.堆的实现

3.1堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。

我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。

向下调整算法：

  • 小堆：父节点 比 孩子节点 小，往下换，换孩子中大的那个
  • 大堆：父节点 比 孩子结点 大，往下换，换孩子中小的那个

int array[] = {27,15,19,18,28,34,65,49,25,37};

 3.2堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。

这里我们插入每插入一个数，就和父节点进行比较，建立一个大堆如下：

3.3堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

3.4建堆的复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明
(时间复杂度本来看的 就是近似值，多几个节点不影响最终结果)

向上调整建堆的时间复杂度为O(N*logN)。

向下调整建堆的时间复杂度为O(N)。

所以堆的创建一般选取像下调整建堆

最少为0，
最多为：二叉树的层数H

3.5堆的删除

删除堆是删除堆顶的数据，

堆的删除不能往前挪动覆盖，因为首先数组的挪动覆盖 比较慢，而后，堆的关系会乱。

删最后一个就不会改变堆的关系所以，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

4.堆的代码实现

4.1堆的定义

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//打印
void HeapPrint(HP* hp);// 堆的初始化
void HeapInit(HP* hp);// 堆的销毁
void HeapDestory(HP* hp);// 堆的插入
void HeapPush(HP* hp, HPDataType x);// 堆的删除
void HeapPop(HP* hp);// 取堆顶的数据
HPDataType HeapTop(HP* hp);// 堆的数据个数
int HeapSize(HP* hp);// 堆的判空
bool HeapEmpty(HP* hp);//堆的构建（给你一个数组，用给定的数组建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n);

4.2堆的函数实现

1）堆的初始化

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

2）堆的销毁

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

3）堆的插入

void AdjustUp(HPDataType* a, int child)
{int parent = (child - 1) / 2;while (child > 0){//这里换为 < 是小堆的创建if (a[child] > a[parent]){//交换HPDataType temp = a[child];a[child] = a[parent];a[parent] = temp;child = parent;parent = (child - 1) / 2;}else{break;}}
}
// 堆的插入
void HeapPush(HP* hp, HPDataType x)
{assert(hp);//扩容if (hp->size == hp->capacity){int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);if (tmp == NULL){perror("realloc fail");exit(-1);}hp->a = tmp;hp->capacity = newcapacity;}hp->a[hp->size] = x;hp->size++;// 向上调整AdjustUp(hp->a, hp->size - 1);
}

原理可参考 3.3

先循环判断子节点和父节点的大小，然后做向上调整操作，

4）堆的删除

//交换
void swap(HPDataType* p1, HPDataType* p2)
{HPDataType temp = *p1;*p1 = *p2;*p2 = temp;
}
//像下调整
void AdjustDown(HPDataType* a, int n, int parent)
{//默认认为左孩子大int child = parent * 2 + 1;//超过数组大小while (child < n){//确认child指向大的孩子if (child < n && a[child + 1] > a[child]){++child;}//孩子大于父亲，交换,继续调整if (a[child] > a[parent]){swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}
}
// 堆的删除
void HeapPop(HP* hp)
{assert(hp);assert(hp->size > 0);//交换swap(&hp->a[0], &hp->a[hp->size - 1]);hp->size--;AdjustDown(hp->a, hp->size, 0);
}

5）取堆顶的数据

HPDataType HeapTop(HP* hp)
{assert(hp);assert(hp->size > 0);return hp->a[0];
}

6）堆的数据个数

int HeapSize(HP* hp)
{assert(hp);return hp->size;
}

7）堆的判空

bool HeapEmpty(HP* hp)
{assert(hp);return hp->size == 0;
}

8）堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）

// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{assert(hp);hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (hp->a == NULL){perror("malloc fail");exit(-1);}//把传过来的数组a，拷贝给hp->a,memcpy(hp->a, a, sizeof(HPDataType) * n);hp->size = hp->capacity = n;//建堆算法（向下调整）for (int i = (n - 1 - 1) / 2;i >= 0;--i){AdjustDown(hp->a, n, i);}
}

4.3堆的源代码和测试（vs2022下编译）

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>//堆的声明typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//打印
void HeapPrint(HP* hp);// 堆的初始化
void HeapInit(HP* hp);// 堆的销毁
void HeapDestory(HP* hp);// 堆的插入
void HeapPush(HP* hp, HPDataType x);// 堆的删除(删除堆顶元素)
void HeapPop(HP* hp);// 取堆顶的数据
HPDataType HeapTop(HP* hp);// 堆的数据个数
int HeapSize(HP* hp);// 堆的判空
bool HeapEmpty(HP* hp);// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）,n是数组大小
void HeapCreate(Heap * hp, HPDataType * a, int n);//堆的定义
#include"heap.h"//交换
void swap(HPDataType* p1, HPDataType* p2)
{HPDataType temp = *p1;*p1 = *p2;*p2 = temp;
}// 打印
void HeapPrint(HP* hp)
{assert(hp);for (int i = 0;i < hp->size;i++){printf("%d ", hp->a[i]);}printf("\\n");
}// 堆的初始化
void HeapInit(HP* hp)
{assert(hp);hp->a = NULL;hp->size = hp->capacity = 0;
}// 堆的销毁
void HeapDestory(HP* hp)
{assert(hp);free(hp->a);hp->a = NULL;hp->size = hp->capacity = 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 HeapPush(HP* hp, HPDataType x)
{assert(hp);//扩容if (hp->size == hp->capacity){int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);if (tmp == NULL){perror("realloc fail");exit(-1);}hp->a = tmp;hp->capacity = newcapacity;}hp->a[hp->size] = x;hp->size++;// 向上调整AdjustUp(hp->a, hp->size - 1);
}//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{//默认认为左孩子大int child = parent * 2 + 1;//超过数组大小while (child < n){//确认child指向大的孩子if (child < n && a[child + 1] > a[child])    //第一处：a[child + 1] > a[child]{++child;}//孩子大于父亲，交换,继续调整if (a[child] > a[parent])    //第二处：a[child] > a[parent]{swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}//将第一处和第二处的>换位<则是建小堆
}// 堆的删除
void HeapPop(HP* hp)
{assert(hp);assert(hp->size > 0);//交换swap(&hp->a[0], &hp->a[hp->size - 1]);hp->size--;AdjustDown(hp->a, hp->size, 0);
}// 取堆顶的数据
HPDataType HeapTop(HP* hp)
{assert(hp);assert(hp->size > 0);return hp->a[0];
}// 堆的数据个数
int HeapSize(HP* hp)
{assert(hp);return hp->size;
}// 堆的判空
bool HeapEmpty(HP* hp)
{assert(hp);return hp->size == 0;
}// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{assert(hp);hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (hp->a == NULL){perror("malloc fail");exit(-1);}//把传过来的数组a，拷贝给hp->a,memcpy(hp->a, a, sizeof(HPDataType) * n);hp->size = hp->capacity = n;//建堆算法（向下调整）for (int i = (n - 1 - 1) / 2;i >= 0;--i){//这里的AdjustDown是建立的大堆，若要减小堆，调整该函数里面的符号（函数里面有提示）AdjustDown(hp->a, n, i);}
}//测试void text1()
{HP hp;HeapInit(&hp);HPDataType array[] = { 27,15,19,18,28,34,65,49,25,37 };//用Push的方法建堆，是向上建堆，时间复杂度是O(n*logn);for (int i = 0;i < sizeof(array) / sizeof(HPDataType);i++){HeapPush(&hp, array[i]);}HeapPrint(&hp);HeapPop(&hp);HeapPrint(&hp);//取堆里面最大的五个数int k = 5;while (k--){printf("%d ", HeapTop(&hp));HeapPop(&hp);}HeapDestory(&hp);
}void text2()
{HP hp;HPDataType array[] = { 27,15,19,18,28,34,65,49,25,37 };HeapCreate(&hp, array, sizeof(array) / sizeof(int));HeapPrint(&hp);}int main()
{text2();return 0;
}

5.堆排序

  • 排升序，建大堆
  • 排降序，建小堆

算法思想：堆排序和堆删除的算法思想一样，都用到了堆的向下调整算法

算法核心：用数组的最后一个元素（size位置）与数组首元素进行交换，并将数组的size--；
                  使得下次交换时，最后一个位置的元素不受影响

具体步骤如下：以数组array={17，20，8，16，5，3}为例：（字有点丑，大家看懂就行）

 

代码如下： 

//交换
void swap(HPDataType* p1, HPDataType* p2)
{HPDataType temp = *p1;*p1 = *p2;*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(HPDataType* a, int n, int parent)
{//默认认为左孩子大int child = parent * 2 + 1;//超过数组大小while (child < n){//确认child指向大的孩子if (child < n && a[child + 1] > a[child])    //第一处：a[child + 1] > a[child]{++child;}//孩子大于父亲，交换,继续调整if (a[child] > a[parent])    //第二处：a[child] > a[parent]{swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}//将第一处和第二处的>换位<则是建小堆
}
//堆排序
void HeapSort(int* a, int size)
{// 向下调整建堆 -- O(N)// 升序：建大堆for (int i = (size - 1 - 1) / 2; i >= 0; --i){AdjustDown(a, size, i);}int end = size - 1;//(end表示数组需要与array[0]交换的下标位置)while (end > 0){swap(&a[0], &a[end]);//交换array[0]和array[end]的位置AdjustDown(a, end, 0);//向下调整end--;}
}int main()
{int array[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };HeapSort(array, sizeof(array) / sizeof(int));//打印for (int i = 0; i < sizeof(array) / sizeof(int); ++i){printf("%d ", array[i]);}printf("\\n");return 0;
}

6.TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大

 比如：专业前10名、世界500强、富豪榜、游戏中前100玩家等

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    • 前k个最大的元素，则建小堆
    • 前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

比如：N个数找最大的前K个：

  • 方法一（传统方法）：建立一个N个数的大堆，Pop   K次，依次取堆顶
    • 时间复杂度：N+logN*K
    • 空间复杂度：O(1)
  • 方法二：建立K个数的小堆，依次遍历数据，比堆顶数据大，就替换堆顶，再向下调整，
    最后最大的前K个数，就在小堆里面。
    • 时间复杂度：N+（N-K)*logK  ->  O(N*logK)
    • 空间复杂度：O(K)

这里给定n个数，求n个数里面最大的k个数（方法二的代码实现）

#include<stdio.h>
#include<stdlib.h>
#include<time.h>void swap(int* p1, int* p2)
{int temp = *p1;*p1 = *p2;*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(int* a, int n, int parent)
{//默认认为左孩子大int child = parent * 2 + 1;//超过数组大小while (child < n){//确认child指向大的孩子if (child + 1 < n && a[child + 1] < a[child]){++child;}//孩子大于父亲，交换,继续调整if (a[child] < a[parent]){swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}
}void TestHeap5()
{// 造数据int n, k;	//n为造数据的多少，k为选前几个最大的printf("请输入n和k:>");scanf("%d%d", &n, &k);//打开文件FILE* fin = fopen("data.txt", "w");if (fin == NULL){perror("fopen fail");return;}//写文件srand(time(0));		//为了让rand()实现真随机，用时间戳给他一个种子//int randK = k;//写n个数据到文件data.txt中for (size_t i = 0; i < n; ++i){int val = rand() % 100;fprintf(fin, "%d\\n", val);}fclose(fin);//-------------------------------------------------------------------------//// 找topk//打开文件FILE* fout = fopen("data.txt", "r");if (fout == NULL){perror("fopen fail");return;}//对数组扩容int* minHeap = (int*)malloc(sizeof(int) * k);if (minHeap == NULL){perror("malloc fail");return;}//先读文件里面前k个数据并放入数组中for (int i = 0; i < k; ++i){fscanf(fout, "%d", &minHeap[i]);}// 堆前k个数据建小堆for (int i = k - 1 - 1; i >= 0; --i){AdjustDown(minHeap, k, i);}//文件的数据读取出来，保存到val值中，并与小堆堆顶的数据作比较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);
}int main()
{TestHeap5();return 0;
}
网络标签：

相关问题