一、基本概念
//最大节点的度称为树的度
//非常棒的设计结构
//二叉树的高度计算公式
//数组存储仅适用于满二叉树或完全二叉树
//注意下标的规律！！！
//插入一个数据时可能的调整过程
二、
//插入数据往数组尾插然后用向上调整算法，删除数据先交换再用向下调整算法
//因为向上调整的过程中，child的下标最终在parent的下标之上，所以，判断条件应该改成child>0（正确思路，最后一次循环child=0）,而不是parent>=0(巧合情况可以运行）。
//删除堆顶数据：
//向下调整算法的前提是左右子树都是小/大堆才能这样弄
//找左右孩子中更小的节点进行数值交换，知道符合小/大堆，或者走到了叶子节点（该位置处坐标*2+1是否超出数组范围）
//首尾交换之后从下标为0的位置开始继续往后比较
//这样不断找堆顶元素的过程就是不断从小的数开始往外pop，时间复杂度好，但是空间复杂度为O（N），这样不好
//建堆算法
//降序排列要建小堆
//升序要建大堆
//但是向上调整和向下调整算法都可以实现小堆和大堆
//假如降序建大堆直接取堆顶元素的话，那么堆的结构就被破坏了，就不再是小堆的结构了
//更好的建堆方法
//建堆及其各种功能代码
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
void Swap(HPDataType* p1, HPDataType* p2);
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int n, int parent);
void HPInit(HP* php);
void HPDestroy(HP* php);
void HPPush(HP* php, HPDataType x);
void HPPop(HP* php);
HPDataType HPTop(HP* php);
bool HPEmpty(HP* php);
//初始化
void HPInit(HP* php)
{
assert(php);
php->a = NULL;
php->size = php->capacity = 0;
}
//销毁
void HPDestroy(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 AdjustUp(HPDataType* a, int child)
{
// 初始条件
// 中间过程
// 结束条件
int parent = (child - 1) / 2;
//while (parent >= 0)
while (child > 0)
{
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//插入一个数据
void HPPush(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, newcapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->a = tmp;
php->capacity = newcapacity;
}
php->a[php->size] = x;
php->size++;
//因为在末尾插入的，所以要向上调整
AdjustUp(php->a, php->size - 1);
}
//向下调整算法
void AdjustDown(HPDataType* a, int n, int parent)
{
// 先假设左孩子小
int child = parent * 2 + 1;
while (child < n) // child >= n说明孩子不存在，调整到叶子了
{
// 找出小的那个孩子
// 右孩子要存在且有孩子更小一点
if (child + 1 < n && a[child + 1] < a[child])
{
++child;
}
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//删除一个元素（把最小/大的删除）
// logN
void HPPop(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);
}
//取堆顶元素（最小/大的元素）
HPDataType HPTop(HP* php)
{
assert(php);
assert(php->size > 0);
return php->a[0];
}
//判空
bool HPEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
//一系列测试函数
void TestHeap1()
{
int a[] = { 4,2,8,1,5,6,9,7,3,2,23,55,232,66,222,33,7,1,66,3333,999 };
HP hp;
HPInit(&hp);
//建堆
for (size_t i = 0; i < sizeof(a)/sizeof(int); i++)
{
HPPush(&hp, a[i]);
}
int i = 0;
while (!HPEmpty(&hp))
{
printf("%d ", HPTop(&hp));
//a[i++] = HPTop(&hp);
HPPop(&hp);
}
printf("\n");
// 找出最大的前k个
/*int k = 0;
scanf("%d", &k);
while (k--)
{
printf("%d ", HPTop(&hp));
HPPop(&hp);
}
printf("\n");*/
HPDestroy(&hp);
}
//时间复杂度
// 堆排序 O(N*logN)
// 冒泡排序 O(N^2)
void HeapSort(int* a, int n)
{
// 降序，建小堆
// 升序，建大堆
/*for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}*/
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;
}
}
void TestHeap2()
{
int a[] = { 4,2,8,1,5,6,9,7,2,7,9};
HeapSort(a, sizeof(a) / sizeof(int));
}
int main()
{
TestHeap2();
return 0;
}三、堆的时间复杂度分析
//向上调整和向下调整算法都是走了堆的高度，时间复杂度都为logN
//推导过程
由：
T(h)=2^h-1-h;
2^h-1=N;
h=log(N+1);
得：
T(N)=N-log(N+1）；
因为N>>logN
所以向下调整算法的时间复杂度为O（N）
//向上调整算法的时间复杂度推导：
四、TopK问题
N个数找....的前K个，假设N远大于K
//法一：建四次堆，分别取出最大的前k个数，最后比较取出来的这些数
//法二：建k个数的小堆，然后往后取数据，该数据大于堆顶数据就将堆顶数据替换为该数 // 据，然后进堆进行向下调整
//TopK代码
//只看TestHeap3（）就行
#include<stdio.h> #include<assert.h> #include<stdlib.h> #include<stdbool.h> typedef int HPDataType; typedef struct Heap { HPDataType* a; int size; int capacity; }HP; void Swap(HPDataType* p1, HPDataType* p2); void AdjustUp(HPDataType* a, int child); void AdjustDown(HPDataType* a, int n, int parent); void HPInit(HP* php); void HPDestroy(HP* php); void HPPush(HP* php, HPDataType x); void HPPop(HP* php); HPDataType HPTop(HP* php); bool HPEmpty(HP* php); void HPInit(HP* php) { assert(php); php->a = NULL; php->size = php->capacity = 0; } void HPDestroy(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 AdjustUp(HPDataType* a, int child) { // 初始条件 // 中间过程 // 结束条件 int parent = (child - 1) / 2; //while (parent >= 0) while (child > 0) { if (a[child] < a[parent]) { Swap(&a[child], &a[parent]); child = parent; parent = (child - 1) / 2; } else { break; } } } void HPPush(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, newcapacity * sizeof(HPDataType)); if (tmp == NULL) { perror("realloc fail"); return; } php->a = tmp; php->capacity = newcapacity; } php->a[php->size] = x; php->size++; AdjustUp(php->a, php->size - 1); } void AdjustDown(HPDataType* a, int n, int parent) { // 先假设左孩子小 int child = parent * 2 + 1; while (child < n) // child >= n说明孩子不存在，调整到叶子了 { // 找出小的那个孩子 if (child + 1 < n && a[child + 1] < a[child]) { ++child; } if (a[child] < a[parent]) { Swap(&a[child], &a[parent]); parent = child; child = parent * 2 + 1; } else { break; } } } // logN void HPPop(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); } HPDataType HPTop(HP* php) { assert(php); assert(php->size > 0); return php->a[0]; } bool HPEmpty(HP* php) { assert(php); return php->size == 0; } #include"Heap.h" #include<time.h> void TestHeap1() { int a[] = { 4,2,8,1,5,6,9,7,3,2,23,55,232,66,222,33,7,1,66,3333,999 }; HP hp; HPInit(&hp); for (size_t i = 0; i < sizeof(a)/sizeof(int); i++) { HPPush(&hp, a[i]); } int i = 0; while (!HPEmpty(&hp)) { printf("%d ", HPTop(&hp)); //a[i++] = HPTop(&hp); HPPop(&hp); } printf("\n"); // 找出最大的前k个 /*int k = 0; scanf("%d", &k); while (k--) { printf("%d ", HPTop(&hp)); HPPop(&hp); } printf("\n");*/ HPDestroy(&hp); } // 堆排序 O(N*logN) // 冒泡排序 O(N^2) void HeapSort(int* a, int n) { // 降序，建小堆 // 升序，建大堆 // 向上调整建堆 O(N*logN) /*for (int i = 1; i < n; i++) { AdjustUp(a, i); }*/ // 向下调整建堆 O(N) for (int i = (n-1-1)/2; i >= 0; i--) { AdjustDown(a, n, i); } // O(N*logN) int end = n - 1; while (end > 0) { Swap(&a[0], &a[end]); AdjustDown(a, end, 0); --end; } } void TestHeap2() { int a[] = { 4,2,8,1,5,6,9,7,2,7,9}; HeapSort(a, sizeof(a) / sizeof(int)); } void CreateNDate() { // 造数据 int n = 100000; srand(time(0)); const char* file = "data.txt"; FILE* fin = fopen(file, "w"); if (fin == NULL) { perror("fopen error"); return; } for (int i = 0; i < n; ++i) { int x = (rand()+i) % 10000000; fprintf(fin, "%d\n", x); } fclose(fin); } void TestHeap3() { int k; printf("请输入k>:"); scanf("%d", &k); int* kminheap = (int*)malloc(sizeof(int) * k); if (kminheap == NULL) { perror("malloc fail"); return; } const char* file = "data.txt"; FILE* fout = fopen(file, "r"); if (fout == NULL) { perror("fopen error"); return; } // 读取文件中前k个数 for (int i = 0; i < k; i++) { fscanf(fout, "%d", &kminheap[i]); } // 11:51继续 // 建K个数的小堆 for (int i = (k-1-1)/2; i>=0 ; i--) { AdjustDown(kminheap, k, i); } // 读取剩下的N-K个数 int x = 0; while (fscanf(fout, "%d", &x) > 0) { if (x > kminheap[0]) { kminheap[0] = x; AdjustDown(kminheap, k, 0); } } printf("最大前%d个数：", k); for (int i = 0; i < k; i++) { printf("%d ", kminheap[i]); } printf("\n"); } int main() { //CreateNDate(); TestHeap3(); return 0; }
扫一扫
36万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
