基本數據結構——堆(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 }