基本数据结构——堆(Heap)的基本概念及其操做

时间 2019-12-04

标签基本数据结构 heap 基本概念及其栏目 Java 繁體版

原文原文链接

　　　　　　　　　　基本数据结构――堆的基本概念及其操做

　　　　　　　　　　　　　小广告：福建安溪一中在线评测系统 Online Judge

　　　　　　在我刚听到堆这个名词的时候，我认为它是一堆东西的集合．．．html

　　　　　　但其实吧它是利用彻底二叉树的结构来维护一组数据，而后进行相关操做，通常的操做进行一次的时间复杂度在ios

　　O(1)~O(logn)之间。算法

　　　　　　可谓是至关的引领时尚潮流啊(我不信学信息学的你看到log和1的时间复杂度不会激动一下下)！。数组

　　　　　　什么是彻底二叉树呢？别急着去百度啊，要百度我帮你百度：数据结构

　　　　　　若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层全部的结点都连续集中ide

　　　　在最左边，这就是彻底二叉树。咱们知道二叉树能够用数组模拟，堆天然也能够。学习

　　　　　　如今让咱们来画一棵彻底二叉树：测试

　　　　　　从图中能够看出，元素的父亲节点数组下标是自己的1/2(只取整数部分)，因此咱们很容易去模拟，也很优化

　　　　容易证实其全部操做都为log级别~~spa

　　　　　　堆还分为两种类型：大根堆、小根堆

　　　　　　顾名思义，就是保证根节点是全部数据中最大/小，而且尽力让小的节点在上方

　　　　　　不过有一点须要注意：堆内的元素并不必定数组下标顺序来排序的！！不少的初学者会错误的认为大/小根堆中

　　　　下标为1就是第一大/小，2是第二大/小……

　　　　　　缘由会在后面解释，如今你只须要深深地记住这一点！

　　　　　　咱们刚刚画的彻底二叉树中并无任何元素，如今让咱们加入一组数据吧！

　　　　　　下标从1到9分别加入：{8，5，2，10，3，7，1，4，6}。

　　　　　　以下图所示

　　　　　　（不要问我怎么加，想一想你是怎么读入数组的。）

　　　　　　咱们能够发现这组数据是杂乱无章的，咱们该如何去维护呢？

　　　　　　如今我就来介绍一下堆的几个基本操做：

上浮 shift_up；
下沉 shift_down
插入 push
弹出 pop
取顶 top
堆排序 heap_sort

　　　　　　学习C/C++的同窗有福利了，堆的代码通常十分之长，而咱们伟大的STL模板库给咱们提供了两种简单方便堆操做的方式，

　　　　想学习的能够看看这个：http://www.cnblogs.com/helloworld-c/p/4854463.html 密码: abcd111

　　　　　　我我的建议吧，起码知道一下实现的过程，STL只能是锦上添花，毫不能够雪中送炭!!

　　　　　　万一哪天要你模拟堆的某一操做过程，而你只知道STL殊不知道原理，看不出这个题目是堆，过后和其余OIer

　　　　讨论出题解，那岂不是砍舌头吃苦瓜，哭得笑哈哈。

　　　　　　那么咱们开始讲解操做过程吧，咱们以小根堆为例

　　　　　　刚刚那组未处理过的数据中咱们很容易就能看出，根节点1元素8绝对不是最小的

　　　　　　咱们很容易发现它的一个儿子节点3(元素2)比它来的小，咱们怎么将它放到最高点呢？很简单，直接交换嘛~~

　　　　　　可是，咱们又发现了，3的一个儿子节点7(元素1)彷佛更适合在根节点。

　　　　　　这时候咱们是没法直接和根节点交换的，那咱们就须要一个操做来实现这个交换过程，那就是上浮 shift_up。

　　　　　　操做过程以下：

　　　　　　从当前结点开始，和它的父亲节点比较，如果比父亲节点来的小，就交换，

　　　　而后将当前询问的节点下标更新为原父亲节点下标；不然退出。　

　　　　　　模拟操做图示:

　　　　　　伪代码以下：

Shift_up( i )
{
    while( i / 2 >= 1)
    {
        if( 堆数组名[ i ] < 堆数组名[ i/2 ] )
        {
            swap( 堆数组名[ i ] , 堆数组名[ i/2 ]) ;
            i = i / 2;
        }
        else break;
｝

　　　　　　这一次上浮完毕以后呢，咱们又发现了一个问题，貌似节点3(元素8)不太合适放在那，而它的子节点7(元素2)

　　　　好像才应该在那个位置。

　　　　　　此时的你应该会说:“赐予我力量，让节点7上浮吧，我是OIer！”

　　　　　　然而，上帝(我很不要脸的说是我)赐予你另一种力量，让节点3下沉！

　　　　　　那么问题来了：节点3应该往哪下沉呢？

　　　　　　咱们知道，小根堆是尽力要让小的元素在较上方的节点，而下沉与上浮同样要以交换来不断操做，因此咱们应该

　　　　让节点7与其交换。　　　　　

　　　　　　由此咱们能够得出下沉的算法了：　　　

　　　　　　让当前结点的左右儿子(若是有的话)做比较，哪一个比较小就和它交换，

　　　　并更新询问节点的下标为被交换的儿子节点下标，不然退出。

　　　　　　模拟操做图示：

　　　　　　伪代码以下：

Shift_down( i , n )    //n表示当前有n个节点
{
    while( i * 2 <= n)
    {
        T = i * 2 ;
        if( T + 1 <= n && 堆数组名[ T + 1 ] < 堆数组名[ T ])
            T++;
        if( 堆数组名[ i ] < 堆数组名[ T ] )
        {
           swap( 堆数组名[ i ] , 堆数组名[ T ] );
            i = T;
        }
        else break;
}

　　　　　　讲完了上浮和下沉，接下来就是插入操做了~~~~

　　　　　　咱们前面用的插入是直接插入，因此数据才会杂乱无章，那么咱们如何在插入的时候边维护堆呢？

　　　　其实很简单，每次插入的时候呢，咱们都往最后一个插入，让后使它上浮。

　　　　　　(这个不须要图示了吧…)

　　　　　　伪代码以下：

Push ( x )
    {
        n++;
        堆数组名[ n ] = x;
        Shift_up( n );
    }

　　　　　　咳咳，说完了插入，咱们总须要会弹出吧~~~~~

　　　　　　弹出，顾名思义就是把顶元素弹掉，可是，弹掉之后不是群龙无首吗？？

　　　　　　咱们如何去维护这堆数据呢?

　　　　　　稍加思考，咱们不可贵出一个十分巧妙的算法：

　　　　让根节点元素和尾节点进行交换，而后让如今的根元素下沉就能够了!

　　　　　　(这个也不须要图示吧…)

　　　　　　伪代码以下：

Pop ( x )
    {
        swap( 堆数组名[1] , 堆数组名[ n ] );
        n--;
        Shift_down( 1 );
    }

　　　　　　接下来是取顶…..我想不须要说什么了吧，根节点数组下标一定是1，返回堆[ 1 ]就OK了~~

　　　　注意：每次取顶要判断堆内是否有元素，不然..你懂的

　　　　　　图示和伪代码省略，若是你这都不会那你能够从新开始学信息学了，固然若是你是小白….这种稍微高级的数据

　　　　结构仍是之后再说吧。

　　　　　　说完这些，咱们再来讲说堆排序。以前说过堆是没法以数组下标的顺序来来排序的对吧?

　　　　　　因此我我的认为呢，并不存在堆排序这样的操做，即使网上有不少堆排序的算法，可是我这里有个更加方便的算法：

　　　　开一个新的数组，每次取堆顶元素放进去，而后弹掉堆顶就OK了~

　　　　　　伪代码以下：

Heap_sort( a[] )
{
        k=0;
        while( size > 0 )
        {
            k++;
            a[ k ] = top();
            pop();    
        }        
}

　　　　　　堆排序的时间复杂度是O(nlogn)理论上是十分稳定的，可是对于咱们来讲并无什么卵用。

　　　　　　咱们要排序的话，直接使用快排便可，时间更快，用堆排还须要O(2*n)的空间。这也是为何我说堆的操做

　　　　时间复杂度在O(1)~O(logn)。

　　　　　　讲完到这里，堆也基本介绍完了，那么它有什么用呢？？

　　　　　　举个粒子，好比当咱们每次都要取某一些元素的最小值，而取出来操做后要再放回去，重复作这样的事情。

　　　　　　咱们如果用快排的话，最坏的状况须要O(q*n^2)，而如果堆，仅须要O(q*logn)，时间复杂度瞬间低了很多。

　　　　　　还有一种最短路算法——Dijkstra，须要用到堆来优化，这个算法我后面会找个时间介绍给你们。

　　　　　　最后附上我写的一份堆操做的代码(C++)：

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 #include<algorithm>
 5 #define maxn 100010   //这部分能够本身定义堆内存多少个元素 
 6 using namespace std;
 7 struct Heap
 8 {
 9     int size,queue[maxn];
10     Heap()         //初始化 
11     {
12         size=0;
13         for(int i=0;i<maxn;i++)
14             queue[i]=0;
15     }
16     void shift_up(int i)  //上浮 
17     {
18         while(i>1)
19         {
20             if(queue[i]<queue[i>>1])
21             {
22                 int temp=queue[i];
23                 queue[i]=queue[i>>1];
24                 queue[i>>1]=temp;
25             }
26             i>>=1;
27         }
28     }
29     void shift_down(int i)   //下沉 
30     {
31         while((i<<1)<=size)
32         {
33             int next=i<<1;
34             if(next<size && queue[next+1]<queue[next])
35                 next++;
36                if(queue[i]>queue[next])
37                {
38                 int temp=queue[i];
39                 queue[i]=queue[next];
40                 queue[next]=temp;
41                 i=next;
42             }
43             else return ;
44         }
45     }
46     void push(int x)   //加入元素 
47     {
48          queue[++size]=x;
49         shift_up(size);
50     }
51     void pop()         //弹出操做 
52     {
53         int temp=queue[1];
54         queue[1]=queue[size];
55         queue[size]=temp;
56         size--;
57         shift_down(1);
58     }
59     int top(){return queue[1];}
60     bool empty(){return size;} 
61     void heap_sort()    //另外一种堆排方式，因为难以证实其正确性 
62     {                    //我就没有在博客里介绍了，能够本身测试 
63         int m=size; 
64         for(int i=1;i<=size;i++)
65         {
66             int temp=queue[m];
67             queue[m]=queue[i];
68             queue[i]=temp;
69             m--;
70             shift_down(i);
71         }
72     }    
73 };
74 int main()
75 {
76     Heap Q;
77     int n,a,i,j,k;
78     cin>>n;
79     for(i=1;i<=n;i++)
80     {
81         cin>>a;
82         Q.push(a); //放入堆内 
83     }
84     
85     for(i=1;i<=n;i++)
86     {
87          cout<<Q.top()<<" ";  //输出堆顶元素 
88         Q.pop();        //弹出堆顶元素 
89     }
90     return 0;
91 }

HEAP CODE

　　　　　　推荐一道堆的基本操做的题目：

　　　　　　　　CODEVS 1063 合并果子：http://codevs.cn/problem/1063/