【坐在马桶上看算法】算法11:堆——神奇的优先队列(上)
2017-07-17 13:38
393 查看
这位朋友写的特别好,忍不住转发 :-)
http://ahalei.blog.51cto.com/4767671/1425314
所有的代码都是我自己写的,并没有沿用这篇文章原有的代码。
堆是什么?是一种特殊的完全二叉树,就像下面这棵树一样。
![](https://img-blog.csdn.net/20170717133810562?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
有没有发现这棵二叉树有一个特点,就是所有父结点都比子结点要小(注意:圆圈里面的数是值,圆圈上面的数是这个结点的编号,此规定仅适用于本节)。符合这样特点的完全二叉树我们称为最小堆。反之,如果所有父结点都比子结点要大,这样的完全二叉树称为最大堆。那这一特性究竟有什么用呢?
假如有14个数分别是99、5、36、7、22、17、46、12、2、19、25、28、1和92。请找出这14个数中最小的数,请问怎么办呢?最简单的方法就是将这14个数从头到尾依次扫一遍,用一个循环就可以解决。这种方法的时间复杂度是O(14)也就是O(N)。
现在我们需要删除其中最小的数,并增加一个新数23,再次求这14个数中最小的一个数。请问该怎么办呢?只能重新扫描所有的数,才能找到新的最小的数,这个时间复杂度也是O(N)。假如现在有14次这样的操作(删除最小的数后并添加一个新数)。那么整个时间复杂度就是O(142)即O(N2)。那有没有更好的方法呢?
堆这个特殊的结构恰好能够很好地解决这个问题。
首先我们先把这个14个数按照最小堆的要求(就是所有父结点都比子结点要小)放入一棵完全二叉树,就像下面这棵树一样。
![](https://img-blog.csdn.net/20170717145136475?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
很显然最小的数就在堆顶,假设存储这个堆的数组叫做h的话,最小数就是h[1]。接下来,我们将堆顶的数删除,并将新增加的数23放到堆顶。显然加了新数后已经不符合最小堆的特性,我们需要将新增加的数调整到合适的位置。
那如何调整呢?
![](https://img-blog.csdn.net/20170717145248276?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
向下调整!我们需要将这个数与它的两个儿子2和5比较,并选择较小一个与它交换,交换之后如下。
![](https://img-blog.csdn.net/20170717145427129?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
我们发现此时还是不符合最小堆的特性,因此还需要继续向下调整。于是继续将23与它的两个儿子12和7比较,并选择较小一个交换,交换之后如下。
![](https://img-blog.csdn.net/20170717145455715?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
到此,还是不符合最小堆的特性,仍需要继续向下调整直到符合最小堆的特性为止。
![](https://img-blog.csdn.net/20170717145524237?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
我们发现现在已经符合最小堆的特性了。综上所述,当新增加一个数被放置到堆顶时,如果此时不符合最小堆的特性,则将需要将这个数向下调整,直到找到合适的位置为止,使其重新符合最小堆的特性。
![](https://img-blog.csdn.net/20170717145550938?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
向下调整的代码如下
输出结果:
[23, 2, 5, 12, 7, 17, 25, 19, 36, 99, 22, 28, 46, 92]
在循环里
在循环里
在循环里
[2, 7, 5, 12, 22, 17, 25, 19, 36, 99, 23, 28, 46, 92]
我们刚才在对23进行调整的时候,竟然只进行了3次比较,就重新恢复了最小堆的特性。现在最小的数依然在堆顶为2。之前那种从头到尾扫描的方法需要14次比较,现在只需要3次就够了。现在每次删除最小的数并新增一个数,并求当前最小数的时间复杂度是O(3),这恰好是O(log14)即O(logN)。
假如现在有1亿个数(即N=1亿),进行1亿次删除最小数并新增一个数的操作,使用原来扫描的方法计算机需要运行大约1亿的平方次,而现在只需要log1亿次,即27亿次。假设计算机每秒钟可以运行10亿次,那原来则需要一千万秒大约115天!而现在只要2.7秒(2的27次方大概是1亿)。
是不是很神奇,再次感受到算法的伟大了吧。
说到这里,如果只是想新增一个值,而不是删除最小值又该如何操作呢?即如何在原有的堆上直接插入一个新元素呢?只需要直接将新元素插入到末尾,再根据情况判断新元素是否需要上移,直到满足堆的特性为止。如果堆的大小为N(即有N个元素),那么插入一个新元素所需要的时间也是O(logN)。例如我们现在要新增一个数3。
![](https://img-blog.csdn.net/20170717150623008?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
先将3与它的父结点25比较,发现比父结点小,为了维护最小堆的特性,需要与父结点的值进行交换。交换之后发现还是要比它此时的父结点5小,因此需要再次与父结点交换。至此又重新满足了最小堆的特性。向上调整完毕后如下。
![](https://img-blog.csdn.net/20170717150708554?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvT3JiaXRh/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
向上调整的代码如下
输入结果:
[2, 7, 5, 12, 22, 17, 25, 19, 36, 99, 23, 28, 46, 92, 3]
在循环里
在循环里
[2, 7, 3, 12, 22, 17, 5, 19, 36, 99, 23, 28, 46, 92, 25]
说了半天,我们忽略一个很重要的问题!就是如何建立这个堆,下节接着说。
原贴的广告咱不能选择性地忽略。
《啊哈!算法》系列,坐在马桶上都能读懂的算法入门书,已经整理出版,下周一将是最后一次在线更新啦(把堆说完)。各位喜欢《啊哈!算法》的朋友要去买一本搜藏哦 这年头写个东西不容易,多谢大家支持啦,当当网购买链接 http://product.dangdang.com/23490849.html
http://ahalei.blog.51cto.com/4767671/1425314
所有的代码都是我自己写的,并没有沿用这篇文章原有的代码。
堆是什么?是一种特殊的完全二叉树,就像下面这棵树一样。
有没有发现这棵二叉树有一个特点,就是所有父结点都比子结点要小(注意:圆圈里面的数是值,圆圈上面的数是这个结点的编号,此规定仅适用于本节)。符合这样特点的完全二叉树我们称为最小堆。反之,如果所有父结点都比子结点要大,这样的完全二叉树称为最大堆。那这一特性究竟有什么用呢?
假如有14个数分别是99、5、36、7、22、17、46、12、2、19、25、28、1和92。请找出这14个数中最小的数,请问怎么办呢?最简单的方法就是将这14个数从头到尾依次扫一遍,用一个循环就可以解决。这种方法的时间复杂度是O(14)也就是O(N)。
public void minNumber(){ int[] a = {99,5,36,7,22,17,46,12,2,19,25,28,1,92}; int min = a[0]; for(int i=0; i<a.length; i++){ if(a[i]<min) { min=a[i]; } } System.out.println(min); }
现在我们需要删除其中最小的数,并增加一个新数23,再次求这14个数中最小的一个数。请问该怎么办呢?只能重新扫描所有的数,才能找到新的最小的数,这个时间复杂度也是O(N)。假如现在有14次这样的操作(删除最小的数后并添加一个新数)。那么整个时间复杂度就是O(142)即O(N2)。那有没有更好的方法呢?
堆这个特殊的结构恰好能够很好地解决这个问题。
首先我们先把这个14个数按照最小堆的要求(就是所有父结点都比子结点要小)放入一棵完全二叉树,就像下面这棵树一样。
很显然最小的数就在堆顶,假设存储这个堆的数组叫做h的话,最小数就是h[1]。接下来,我们将堆顶的数删除,并将新增加的数23放到堆顶。显然加了新数后已经不符合最小堆的特性,我们需要将新增加的数调整到合适的位置。
那如何调整呢?
向下调整!我们需要将这个数与它的两个儿子2和5比较,并选择较小一个与它交换,交换之后如下。
我们发现此时还是不符合最小堆的特性,因此还需要继续向下调整。于是继续将23与它的两个儿子12和7比较,并选择较小一个交换,交换之后如下。
到此,还是不符合最小堆的特性,仍需要继续向下调整直到符合最小堆的特性为止。
我们发现现在已经符合最小堆的特性了。综上所述,当新增加一个数被放置到堆顶时,如果此时不符合最小堆的特性,则将需要将这个数向下调整,直到找到合适的位置为止,使其重新符合最小堆的特性。
向下调整的代码如下
public void siftdown(){ int[] a = {1,2,5,12,7,17,25,19,36,99,22,28,46,92}; a[0] = 23; System.out.println(Arrays.toString(a)); int i = 0, t, newValue; while (i*2+1 < a.length){ newValue = a[i]; if(a[i*2+1] > a[i*2+2]){ t = i*2+2; }else{ t = i*2+1; } a[i] = a[t]; a[t] = newValue; i = t; System.out.println("在循环里"); } System.out.println(Arrays.toString(a)); }
输出结果:
[23, 2, 5, 12, 7, 17, 25, 19, 36, 99, 22, 28, 46, 92]
在循环里
在循环里
在循环里
[2, 7, 5, 12, 22, 17, 25, 19, 36, 99, 23, 28, 46, 92]
我们刚才在对23进行调整的时候,竟然只进行了3次比较,就重新恢复了最小堆的特性。现在最小的数依然在堆顶为2。之前那种从头到尾扫描的方法需要14次比较,现在只需要3次就够了。现在每次删除最小的数并新增一个数,并求当前最小数的时间复杂度是O(3),这恰好是O(log14)即O(logN)。
假如现在有1亿个数(即N=1亿),进行1亿次删除最小数并新增一个数的操作,使用原来扫描的方法计算机需要运行大约1亿的平方次,而现在只需要log1亿次,即27亿次。假设计算机每秒钟可以运行10亿次,那原来则需要一千万秒大约115天!而现在只要2.7秒(2的27次方大概是1亿)。
是不是很神奇,再次感受到算法的伟大了吧。
说到这里,如果只是想新增一个值,而不是删除最小值又该如何操作呢?即如何在原有的堆上直接插入一个新元素呢?只需要直接将新元素插入到末尾,再根据情况判断新元素是否需要上移,直到满足堆的特性为止。如果堆的大小为N(即有N个元素),那么插入一个新元素所需要的时间也是O(logN)。例如我们现在要新增一个数3。
先将3与它的父结点25比较,发现比父结点小,为了维护最小堆的特性,需要与父结点的值进行交换。交换之后发现还是要比它此时的父结点5小,因此需要再次与父结点交换。至此又重新满足了最小堆的特性。向上调整完毕后如下。
向上调整的代码如下
public void siftup(){ int[] a = {2,7,5,12,22,17,25,19,36,99,23,28,46,92,3}; int newValue, i = a.length - 1; System.out.println(Arrays.toString(a)); while(i>0){ newValue = a[i]; if(a[i] < a[i/2-1]){ a[i] = a[i/2-1]; a[i/2-1] = newValue; i = i/2-1; }else{ break; } System.out.println("在循环里"); } System.out.println(Arrays.toString(a)); }
输入结果:
[2, 7, 5, 12, 22, 17, 25, 19, 36, 99, 23, 28, 46, 92, 3]
在循环里
在循环里
[2, 7, 3, 12, 22, 17, 5, 19, 36, 99, 23, 28, 46, 92, 25]
说了半天,我们忽略一个很重要的问题!就是如何建立这个堆,下节接着说。
原贴的广告咱不能选择性地忽略。
《啊哈!算法》系列,坐在马桶上都能读懂的算法入门书,已经整理出版,下周一将是最后一次在线更新啦(把堆说完)。各位喜欢《啊哈!算法》的朋友要去买一本搜藏哦 这年头写个东西不容易,多谢大家支持啦,当当网购买链接 http://product.dangdang.com/23490849.html
相关文章推荐
- 【坐在马桶上看算法】算法11:堆——神奇的优先队列(上)
- 【坐在马桶上看算法】算法12:堆——神奇的优先队列(下)
- 【坐在马桶上看算法】算法12:堆——神奇的优先队列(下)
- 【啊哈!算法】算法11:堆——神奇的优先队列(上)
- 【啊哈!算法】算法11:堆——神奇的优先队列(上)
- 【坐在马桶上看算法】算法12:堆——神奇的优先队列(下)
- 【啊哈!算法】算法11:堆——神奇的优先队列(上) 推荐
- 【坐在马桶上看算法】算法12:堆——神奇的优先队列(下) 推荐
- 轻松学算法11:堆——神奇的优先队列
- 【啊哈!算法】算法11:堆——神奇的优先队列(上)
- [转]【啊哈!算法】算法11:堆——神奇的优先队列(上)--作者:ahalei
- 【啊哈!算法】算法11:堆——神奇的优先队列(上)
- 【啊哈!算法】算法12:堆——神奇的优先队列(下)
- 数据结构1:栈、队列、优先队列相关的算法题
- 算法设计---优先队列与索引优先队列
- 算法总结——spfa(使用优先队列的Bellman_Ford算法)
- 广度优先搜索以及队列优化的 Bellman-Ford 短路算法
- 7.1堆——神奇的优先队列
- 数据结构与算法--优先队列和堆排序
- Dijkstra算法之优先队列优化版本 By ACReaper Dijkstra