网站营销信息申请企业邮箱步骤是什么

简介

堆是一种重要的数据结构，是一种完全二叉树，（二叉树的内容后面会出），
堆分为大小堆，大堆，左右结点都小于根节点，（又称子节点和父节点），
小堆则反过来，可以用静态数组/顺序表实现

公式

已知某节点下标 i ，（根节点下标为0），

• 左孩子节点为 2*i+1
• 右孩子节点为 2*i+2
• 父节点 （ i - 1 ）/ 2

建立堆

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int HPTypeDate;
typedef struct {HPTypeDate* a;HPTypeDate size;HPTypeDate capacity;
}HP;

将元素插入a里面，size表示堆里面的元素个数，避免浪费内存，满了就开辟

void HeapInit(HP* php);
void HeapPush(HP* php, HPTypeDate x);
void Adjustup(HPTypeDate* a, int child);
void swap(HPTypeDate* a, HPTypeDate* b);
void HeapPrint(HP* php, HPTypeDate n);
HPTypeDate HPTop(HP* php);
void HPPop(HP* php);
bool HPEmpty(HP* php);
void Adjustdown(HPTypeDate* a, HPTypeDate n,HPTypeDate parent);

堆常用的函数，初始化，插入，上下调整，取堆顶元素，消堆顶元素

函数解释

void HeapInit(HP* php)
{assert(php);php->a = (HPTypeDate*)malloc(sizeof(HPTypeDate) * 4);if (php->a == NULL){perror("malloc fail");return;}php->size = 0;php->capacity = 4;
}

初始化，为数组a开辟空间，size赋值，capacity先赋值4，

void HeapPrint(HP* php, HPTypeDate n)
{assert(php);for (int i = 0;i < n;i++){printf("%d ", php->a[i]);}printf("\n");
}
void swap(HPTypeDate* a, HPTypeDate* b)
{int p = *b;*b = *a;*a = p;
}

打印和交换函数

void Adjustup(HPTypeDate* 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;}elsebreak;}
}

向上调整函数，非常重要，传入child，是某个节点的下标。再找出父亲节点，判断孩子和父亲节点的大小，根据建大小堆的不同 if中判断符号作改变，我这里是小堆，再递归，父亲的位置给孩子，父亲根据公式 再重新向上找点，一直往复，直到不满足堆的规定时间复杂度为O(log n）；

void Adjustdown(HPTypeDate* a,HPTypeDate n, HPTypeDate parent)
{HPTypeDate child = parent * 2+1;while (child < n){if (child+1<n&&a[child] < a[child + 1]){child = child + 1;}if (a[parent] > a[child]){swap(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else break;}
}

向下调整，传入父节点下标，求出孩子结点，找出那个大孩子，再根据大小堆是否与孩子交换，递归，与向上类似时间复杂度与向上一致

void HeapPush(HP* php, HPTypeDate x)
{assert(php);if (php->capacity == php->size){HPTypeDate* tmp = (HPTypeDate*)realloc(php->a, sizeof(HPTypeDate) * (php->capacity) * 2);if (tmp == NULL){perror("realloc");return;}php->a = tmp;php->capacity *= 2;}php->a[php->size++] = x;Adjustup(php->a, php->size - 1);
}

插入函数，判断空间够不够，不够realloc再开辟capacity2的，把开辟的空间给a，capacity=2；
将新来的数插入数组末尾，再向上调整一遍。时间复杂度最坏O(n),均摊O(1)

bool HPEmpty(HP* php)
{return php->size == 0;
}
HPTypeDate HPTop(HP* php)
{assert(php);return php->a[0];
}
void HPPop(HP* php)
{assert(php);if (HPEmpty(php)) return;swap(&php->a[0], &php->a[php->size - 1]);php->size--;Adjustdown(php->a, php->size,0);
}

消去堆顶函数，将堆顶和堆尾交换，size-- 就行，再将堆顶向下调整

堆排序O(n logn)

#include <stdio.h>void swap(int* a, int* b)
{int p = *a;*a = *b;*b = p;
}
void Adjustdown(int* a, int parent, int n)
{int child = parent * 2 + 1;while (child < n){if (child + 1 < n && a[child] < a[child + 1])child = child + 1;if (a[child] > a[parent]){swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else break;}}
void heap_sort(int* a, int n)
{for (int i = (n - 2) / 2;i >= 0;i--){Adjustdown(a, i, n);}int end = n - 1;while (end > 0){swap(&a[0], &a[end]);Adjustdown(a, 0, end);end--;}
}
int main()
{int a[] = { 1,9,8,5,6,4,7,4 };heap_sort(a, 8);for (int i = 0;i < 8;i++){printf("%d ", a[i]);}return 0;
}

先前向上调整函数参数为指针，可以直接用来排序，
先将数组建成一个大堆，从中间开始往下调整O(n)，但从下向上调整O(nlogn)
默认升序，若想降序

• 方法 1：改用 小根堆（最小堆），这样堆顶是最小值，交换到末尾后自然形成降序。

• 方法 2：仍然用 大根堆，但 不交换堆顶到末尾，而是 直接输出堆顶（每次取最大值），但这样会破坏原数组

topk问题

给出一堆数让求最大的前k个，若给几十亿个数，开辟不了这么大的内存，所以要取巧，
建k个大小的小堆，遍历一遍数，若比堆顶大就代替堆顶，进堆，最后几个就是最大的

#include <stdio.h>void swap(int* a, int* b)
{int p = *a;*a = *b;*b = p;
}
void Adjustdown(int* a, int parent, int n)
{int child = parent * 2 + 1;while (child < n){if (child + 1 < n && a[child] < a[child + 1])child = child + 1;if (a[child] < a[parent]){swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else break;}}
void heap_sort(int* a, int k)
{//建堆for (int i = (k - 2) / 2;i >= 0;i--){Adjustdown(a, i, k);}//n-k比较for(int i=k;i<8;i++){int val = a[i];if (val > a[0]){swap(&val, &a[0]);Adjustdown(a, 0, k);}}
}
int main()
{int a[] = { 1,9,8,5,6,4,7,4 };int k = 2;heap_sort(a, k);for (int i = 0;i < k;i++){printf("%d ", a[i]);}return 0;
}

代码稍微一改就行，要求前k小的就建大堆，若比堆顶小，代替进堆