轉載自：https://www.cnblogs.com/JVxie/p/4859889.html，同時感謝大佬的分析 

     在我剛聽到堆這個名詞的時候，我認為它是一堆東西的集合

　　　　　　但其實吧它是利用完全二叉樹的結構來維護一組資料，然後進行相關操作，一般的操作進行一次的時間複雜度在

　　O(1)~O(logn)之間。

　　　　　　可謂是相當的引領時尚潮流啊(我不信學資訊學的你看到log和1的時間複雜度不會激動一下下)！。

　　　　　　什麼是完全二叉樹呢？別急著去百度啊，要百度我幫你百度：

　　　　　　若設二叉樹的深度為

　　　　在最左邊，這就是完全二叉樹。我們知道二叉樹可以用陣列模擬，堆自然也可以。

　　　　　　現在讓我們來畫一棵完全二叉樹：

　　　　　　從圖中可以看出，元素的父親節點陣列下標是本身的1/2(只取整數部分)，所以我們很容易去模擬，也很

　　　　容易證明其所有操作都為log級別~~

　　　　　　堆還分為兩種型別：大根堆、小根堆

　　　　　　顧名思義，就是保證根節點是所有資料中最大

　　　　　　不過有一點需要注意：堆內的元素並不一定陣列下標順序來排序的！！很多的初學者會錯誤的認為大/小根堆中

　　　　下標為1就是第一大/小，2是第二大/小……

　　　　　　原因會在後面解釋，現在你只需要深深地記住這一點！

　　　　　　我們剛剛畫的完全二叉樹中並沒有任何元素，現在讓我們加入一組資料吧！

　　　　　　下標從1到9分別加入：{8，5，2，10，3，7，1，4，6}。

　　　　　　如下圖所示

　　　　　　（不要問我怎麼加，想想你是怎麼讀入陣列的。）

　　　　　　我們可以發現這組資料是雜亂無章

　　　　　　現在我就來介紹一下堆的幾個基本操作：

1. 上浮 shift_up；
   1. 下沉 shift_down
   2. 插入 push
   3. 彈出 pop
   4. 取頂 top
   5. 堆排序 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)，時間複雜度瞬間低了不少。

最後附上一份堆操作的程式碼(C++)：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define maxn 100010   //這部分可以自己定義堆記憶體多少個元素 
using namespace std;
struct Heap
{
    int size,queue[maxn];
    Heap()         //初始化 
    {
        size=0;
        for(int i=0;i<maxn;i++)
            queue[i]=0;
    }
    void shift_up(int i)  //上浮 
    {
        while(i>1)
        {
            if(queue[i]<queue[i>>1])
            {
                int temp=queue[i];
                queue[i]=queue[i>>1];
                queue[i>>1]=temp;
            }
            i>>=1;
        }
    }
    void shift_down(int i)   //下沉 
    {
        while((i<<1)<=size)
        {
            int next=i<<1;
            if(next<size && queue[next+1]<queue[next])
                next++;
               if(queue[i]>queue[next])
               {
                int temp=queue[i];
                queue[i]=queue[next];
                queue[next]=temp;
                i=next;
            }
            else return ;
        }
    }
    void push(int x)   //加入元素 
    {
         queue[++size]=x;
        shift_up(size);
    }
    void pop()         //彈出操作 
    {
        int temp=queue[1];
        queue[1]=queue[size];
        queue[size]=temp;
        size--;
        shift_down(1);
    }
    int top(){return queue[1];}
    bool empty(){return size;} 
    void heap_sort()    //另一種堆排方式，由於難以證明其正確性 
    {                    //我就沒有在部落格裡介紹了，可以自己測試 
        int m=size; 
        for(int i=1;i<=size;i++)
        {
            int temp=queue[m];
            queue[m]=queue[i];
            queue[i]=temp;
            m--;
            shift_down(i);
        }
    }    
};
int main()
{
    Heap Q;
    int n,a,i,j,k;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a;
        Q.push(a); //放入堆內 
    }
    
    for(i=1;i<=n;i++)
    {
         cout<<Q.top()<<" ";  //輸出堆頂元素 
        Q.pop();        //彈出堆頂元素 
    }
    return 0;
}

HEAP CODE

注：在回顧資料結構堆時候發現這個連結講述的也很好，感興趣的可以看看，連結如下：http://www.cnblogs.com/skywang12345/p/3610187.html