基本數據結構——堆(Heap)的基本概念及其操作

　　　　　　　　　　基本數據結構――堆的基本概念及其操作

　　　　　　　　　　　　　小廣告：福建安溪一中在線評測系統 Online Judge 

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

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

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

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

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

　　　　　　若設二叉樹的深度為h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第 h 層所有的結點都連續集中

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

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

　　　　　　　　　　　　　　　　　　

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

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

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

　　　　　　顧名思義，就是保證根節點是所有數據中最大/小，並且盡力讓小的節點在上方

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

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

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

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

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

　　　　　　如下圖所示

　　　　　　　　　　　　　　　　　　

　　　　　　（不要問我怎么加，想想你是怎么讀入數組的。）

　　　　　　我們可以發現這組數據是雜亂無章的，我們該如何去維護呢？

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

1. 上浮 shift_up；
2. 下沉 shift_down
3. 插入 push
4. 彈出 pop
5. 取頂 top
6. 堆排序 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++)：

#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;
}

　　　　　　推薦一道堆的基本操作的題目：

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