中小企业做网站贷款,seo站群干什么的,网站制作软件免费下载,美容院网站源码目录
1、堆的概念及结构
2、堆的实现(附代码)
2.1、向下调整算法建堆
3、堆的应用(附代码)
3.1、堆排序
3.2、TOP-K问题 1、堆的概念及结构
如果有一个关键码的集合K { k0#xff0c;k1 #xff0c;k2 #xff0c;…#xff0c;k(n-1) }#xff0c;把它的所有元素…目录
1、堆的概念及结构
2、堆的实现(附代码)
2.1、向下调整算法建堆
3、堆的应用(附代码)
3.1、堆排序
3.2、TOP-K问题 1、堆的概念及结构
如果有一个关键码的集合K { k0k1 k2 …k(n-1) }把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中并满足kik(2*i1) 且 kik(2*i2) ( kik(2*i1) 且kik(2*i2) ) (i 012…)则称为小堆(或大堆)。
将根节点作为最大值的堆叫做最大堆或大根堆根节点作为最小值的堆叫做最小堆或小根堆。
通俗一点讲就是
小堆任意一个父结点的值都小于或者等于其子结点。
大堆任意一个父结点的值都大于或者等于其子结点。
至于同一个父结点的两个子结点谁大谁小都无所谓。 堆的性质
(1)堆中某个节点的值总是不大于或不小于其父节点的值。
(2)堆总是一棵完全二叉树。 补充一个问题
堆的意义是什么
答选数选最大值或最小值 -- 时间复杂度为O(logN)。
ex
(1)堆排序时间复杂度为O(N*logN)。 -- 选出每个节点所需时间为O(logN)选出N个节点所需的总时间为O(N*logN)。
(2)top k问题 -- ex从100万个值中找出最大的10个值或者说找出最小的10个值。 2、堆的实现(附代码)
对于堆的创建有两种方法一种是插入法(使用向上调整时间复杂度为N*logN)一种是向下调整法(也叫筛选法)(向下调整建堆时间复杂度为O(N))。
typedef int HPDataType;
typedef struct Heap
{HPDataType *array;int size;int capacity;
} HP;
堆的底层看起来像是顺序表但和顺序表是不一样的从逻辑结构上要把堆看作是一颗完全二叉树。
Heap.h
#include stdio.h
#include assert.h
#include stdlib.h
#include stdbool.h
#include time.htypedef int HPDataType;typedef struct Heap
{HPDataType* array;int size;int capacity;
} HP;
// 堆的底层看起来像是顺序表但和顺序表是不一样的从逻辑结构上要把堆看作是一颗完全二叉树。// 堆的初始化
void HeapInit(HP* php);// 堆的销毁
void HeapDestory(HP* php);// 判断是否需要扩容
void CheckCapacity(HP* php); // 交换
void Swap(HPDataType* p1, HPDataType* p2);// 获取堆顶的元素
HPDataType HeapTop(HP* php);// 获取堆的大小
int HeapSize(HP* php);// 判空
bool HeapEmpty(HP* php);// 小堆的插入
void SmallHeapPush(HP *php, HPDataType x);// 小堆的向下调整
void SmallAdjustDown(HPDataType *a, int size, int parent);// 小堆的删除(规定删除栈顶元素)
void SmallHeapPop(HP *php);// 大堆的插入
void BigHeapPush(HP* php, HPDataType x);// 大堆向下调整
void BigAdjustDown(HPDataType* a, int size, int parent);// 大堆的删除(规定删除栈顶元素)
void BigHeapPop(HP* php);
Heap.c
#include Heap.h// 堆的初始化
void HeapInit(HP* php)
{assert(php);php-array NULL;php-capacity php-size 0;
}// 堆的销毁
void HeapDestory(HP* php)
{assert(php);free(php-array); // 连续的空间直接free即可不用像链表那种还要去一个一个节点的freephp-array NULL;php-capacity php-size 0;
}void CheckCapacity(HP* php) // 判断是否需要扩容
{if (php-size php-capacity){int newcapacity php-capacity ? 2 * php-capacity : 4;HPDataType* tmp (HPDataType*)realloc(php-array, sizeof(HPDataType) * newcapacity);if (tmp NULL){ perror(realloc fail);exit(-1);}php-array tmp;php-capacity newcapacity;}
}// 交换
void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType tmp *p1;*p1 *p2;*p2 tmp;
}// 获取堆顶的元素
HPDataType HeapTop(HP* php)
{assert(php);assert(php-size);return php-array[0];
}// 获取堆的大小
int HeapSize(HP* php)
{assert(php);return php-size;
}// 判空
bool HeapEmpty(HP* php)
{assert(php);return php-size 0;
}void AdjustUp(HPDataType *a, int child) // child至少是0
{int parent (child - 1) / 2;while (a[child] a[parent]) // 把这里改成 就是实现大堆了{Swap(a[child], a[parent]);child parent;parent (parent - 1) / 2; // parent怎么变都不会变成负数}
}// 堆的插入(建堆)--时间复杂度为log(N)--主要的时间消耗在于向上调整的时间消耗--最坏的情况要调整log(N)次
void HeapPush(HP *php, HPDataType x)
{assert(php);CheckCapacity(php);php-array[php-size] x;AdjustUp(php-array, php-size - 1); // 因为size至少是1
}// 向下调整--删除栈顶元素之后进行的调整--也可用于堆的创建时间复杂度为O(N)比向上调整建堆更优
// 思路
// 因为交换完根结点和尾结点并删除栈顶元素之后根结点的左子树和右子树仍旧符合堆的规定
// 所以如下
void AdjustDown(HPDataType *a, int size, int parent) // 将里面的孩子与父亲的大小比较改成就变成是大堆的调整了
{// 分情况讨论法int leftchild parent * 2 1;int rightchild parent * 2 2;while (leftchild size){// 如果左右孩子一样大跟谁换都行(前提是左右孩子都存在)if (rightchild size a[leftchild] a[rightchild] a[parent] a[leftchild]) // 比左孩子大就跟左孩子交换{Swap(a[parent], a[leftchild]);parent leftchild;}else if (rightchild size a[leftchild] a[rightchild] a[parent] a[rightchild]) // 比右孩子大就跟右孩子交换{Swap(a[parent], a[rightchild]);parent rightchild;}else if (a[leftchild] a[parent]) // 一定要注意要讨论只有左孩子没有右孩子的情况不然就出现越界访问了Bug{Swap(a[parent], a[leftchild]);parent leftchild;}else // 如果孩子都比父结点大那就不用再换了{break;}leftchild parent * 2 1;rightchild parent * 2 2;}// 假设法// int child parent * 2 1;//就假设是左孩子更小// while(child size)//{// if(child1 size a[child1] a[child]) //这里可能出现越界需要加一个判断child1size// //因为存在那种只有左孩子但没有右孩子的情况这时child1的值就已经和size相等了// //此时a[child1]就已经是越界访问了// {// child;// }// if(a[child] a[parent])// {// Swap(a[parent],a[child]);// parent child;// child parent * 2 1;// }// else// {// break;// }// }
}// 堆的删除(规定删除栈顶元素)
void HeapPop(HP *php)
{assert(php);assert(php-size);// 第一步先将根结点和尾结点进行交换,然后删除栈顶元素Swap(php-array[0], php-array[php-size - 1]);php-size--;AdjustDown(php-array, php-size, 0);
} 2.1、向下调整算法建堆
因为向下调整需要先保证该节点的左右子树已经是大/小堆了才能向下调整所以先从尾开始调整(思路就是从尾开始调整从最后一个叶结点的父结点开始调整叶结点无需调整因为叶结点可以看作是一种特殊的子树既可以当作大堆也可以当作小堆)。
for (int i (size - 1 - 1) / 2; i 0; i--) // (size-1-1)/2是最后一个叶结点的父结点的下标
{AdjustDown(a, size, i); // a是一个完全二叉树
}
注向下调整算法有一个前提左右子树必须是一个堆才能调整。
注向下调整算法的两大优势
在进行堆排序或者解决TOP-K问题时写一个向下调整就能解决。时间复杂度为O(N)效率更高。
补充为什么用向下调整算法建堆的时间复杂度是O(N)
答经过计算时间复杂度的值是一个等比数列乘于等差数列的求和结果为2^h-1-h(h为树的高度)因为2^h-1N所以时间复杂度为O(N)。 3、堆的应用(附代码)
3.1、堆排序
堆排序即利用堆的思想来进行排序总共分为两个步骤
1.建堆
升序建大堆--注建大堆父节点是跟更大的孩子交换
降序建小堆--注建小堆父节点是跟更小的孩子交换
2.利用堆删除思想来进行排序 -- 交换头尾然后并不是真的删除掉尾只是把除了尾之外的其他数看成新的堆再对新的堆进行调整
总结建堆和堆删除中都可以用向下调整因此掌握了向下调整就可以完成堆排序。 3.2、TOP-K问题
TOP-K问题即求数据结合中前K个最大的元素或者最小的元素一般情况下数据量都比较大。
比如专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题能想到的最简单直接的方式就是排序。--空间复杂度大(可能导致内存不够用)时间复杂度还不好说
但是如果数据量非常大排序就不太可取了(可能数据都不能一下子全部加载到内存中)。
所以最佳的方式就是用堆来解决。--空间复杂度很小时间复杂度仅为O(N(logK))--比较次数为N-K(K可以忽略不计)调整次数最多为logK次
基本思路如下
第一步用数据集合中前K个元素来建堆
要找前k个最大的元素则建小堆
要找前k个最小的元素则建大堆
第二步用剩余的N-K个元素依次与堆顶元素来比较
如果是找前K个最大的元素将剩余N-K个元素依次与堆顶元素比较若比堆顶元素大则替换堆顶元素(替换完后要进行一下向下调整)。
如果是找前K个最小的元素将剩余N-K个元素依次与堆顶元素比较若比堆顶元素小则替换堆顶元素(替换完后要进行一下向下调整)。
最后堆中剩余的K个元素就是所求的前K个最大或者最小的元素。
代码示例
#includestdio.h
#includeassert.h
#includestdlib.h
#includetime.hvoid Print(int* a, int n)
{for (int i 0; i n; i){printf(%d , a[i]);}printf(\n);
}// 堆排序即利用堆的思想来进行排序总共分为两个步骤
// 1. 建堆
// 升序建大堆
// 降序建小堆
// 2. 利用堆删除思想来进行排序 --交换头尾然后并不是真的删除掉尾只是把除了尾之外的其他数看成新的堆再对新的堆进行调整
// 总结建堆和堆删除中都可以用向下调整因此掌握了向下调整就可以完成堆排序。void HeapSort_ascending(int* a, int size) // 这里排升序
{assert(a);// 第一步把数组建成堆 --时间复杂度为N*log(N)// 思路直接把数组的第一个元素看作是一个堆从第二个元素开始看作是要插入(Push)的数据// 这里演示大堆的建成 for (int i 1; i size; i){int child i;int parent (child - 1) / 2;while (a[child] a[parent]){// 交换int tmp a[child];a[child] a[parent];a[parent] tmp;child parent;parent (child - 1) / 2;}}// 第二步,交换并进行向下调整--时间复杂度为N*logNfor (int end size - 1; end 0; --end){// 先交换头尾int tmp a[0];a[0] a[end];a[end] tmp;// 再进行向下调整。这里用的是假设法就假设左孩子更大建大堆就是跟更大的孩子换建小堆则是跟更小的孩子换int j 0;int k j * 2 1;while (k end){if (k 1 end a[k] a[k 1]){k;}if (a[j] a[k]){int tmp a[j];a[j] a[k];a[k] tmp;}else{break;}j k;k j * 2 1;}}
}void HeapSort_descending(int* a, int size) // 这里排降序
{assert(a);// 假设第一个元素自身是一个小堆将从第二个元素开始之后的元素都视为新插入的元素for (int i 1; i size; i){int child i;int parent (child - 1) / 2;while (a[child] a[parent]){// 交换int tmp a[child];a[child] a[parent];a[parent] tmp;child parent;parent (child - 1) / 2;}}// 开始排序就是先交换头尾再进行向下调整for (int i size - 1; i 0; --i){int tmp a[i];a[i] a[0];a[0] tmp;int parent 0;int leftchild parent * 2 1;int rightchild parent * 2 2;while (rightchild i || leftchild i){if (rightchild i a[rightchild] a[leftchild] a[rightchild] a[parent]){int tmp a[rightchild];a[rightchild] a[parent];a[parent] tmp;parent rightchild;}else if (a[leftchild] a[parent]){int tmp a[leftchild];a[leftchild] a[parent];a[parent] tmp;parent leftchild;}elsebreak;leftchild parent * 2 1;rightchild parent * 2 2;}}
}// TOP-K问题
// 基本思路如下
// 第一步用数据集合中前K个元素来建堆
// 要找前k个最大的元素则建小堆
// 要找前k个最小的元素则建大堆
// 第二步用剩余的N-K个元素依次与堆顶元素来比较
// 如果是找前K个最大的元素将剩余N-K个元素依次与堆顶元素比较若比堆顶元素大则替换堆顶元素(替换完后要进行一下向下调整)。
// 如果是找前K个最小的元素将剩余N-K个元素依次与堆顶元素比较若比堆顶元素小则替换堆顶元素(替换完后要进行一下向下调整)。
// 最后堆中剩余的K个元素就是所求的前K个最大或者最小的元素。
// 补充
// 当N不大时(N太大会有内存不够的问题)可以选择建个大小为N的堆然后 pop K次即可。 // 但不管怎样这个思路都不如上面的好。// 造数据
void CreateData()
{int n 1000000;FILE* pf fopen(data.txt, w);if (!pf){perror(fopen fail);exit(-1);}for (int i 0; i n; i){int x (rand() i) % 100000; // 注意rand()产生的随机数是有范围的范围为0到RAND MAX(32767)之间fprintf(pf, %d , x);}fclose(pf);pf NULL; // 好习惯置不置空都行因为出了函数就自动销毁了
}void PrintfTopK(int k)
{FILE* pf fopen(data.txt, r);if (!pf){perror(fopen fail);return;}// 第一步建堆(这里建小堆找大数)int* minheap (int*)malloc(sizeof(int) * k);if (!minheap){perror(malloc fail);return;}for (int i 0; i k; i){// 边读边建堆int x 0;if (fscanf(pf, %d, x) ! EOF) // fscanf的用法笔记那里没写例子{minheap[i] x; int j i;while (minheap[j] minheap[(j - 1) / 2]) // 向上调整{int tmp minheap[j];minheap[j] minheap[(j - 1) / 2];minheap[(j - 1) / 2] tmp;j (j - 1) / 2;}}}int x 0;while (fscanf(pf, %d, x) ! EOF){if (x minheap[0]){// 手动打个条件断点 --因为该例子中数据太多了一个一个调试那得调试一辈子// if (x 100000)// {// int condition 0; // 因为断点不能打在空语句上这里只是随便写一句代码让断点打一下// }minheap[0] x;// 开始向下调整int L 0;int y L * 2 1;while (L * 2 1 k){if (y 1 k minheap[y 1] minheap[y]){y;}if (minheap[L] minheap[y]){int tmp minheap[L];minheap[L] minheap[y];minheap[y] tmp;}else{break;}L y;y L * 2 1;}}}for (int i 0; i k; i){printf(%d , minheap[i]);}printf(\n);free(minheap);fclose(pf);
}int main()
{srand((unsigned int)time(NULL));// CreateData();int k 0;printf(请输入你想获取的最大数的个数\n);scanf(%d, k);PrintfTopK(k);//int n 10;//int a[10] { 0 };//for (int i 0; i n; i)//{// a[i] rand() % 100 1;//}//HeapSort_ascending(a, sizeof(a) / sizeof(int)); // 堆排序//Print(a, sizeof(a) / sizeof(int));//HeapSort_descending(a, sizeof(a) / sizeof(int));//Print(a, sizeof(a) / sizeof(int));return 0;
}
