堆的基本概念及其操作
轉：https://www.cnblogs.com/JVxie/p/4859889.html
堆是利用完全二叉樹的結構來維護一組數據，然後進行相關操作，一般的操作進行一次的時間復雜度在 O(1) ~ O(logn) 之間。
若設二叉樹的深度為h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第 h 層所有的結點都連續集中在最左邊，這就是完全二叉樹。我們知道二叉樹可以用數組模擬，堆自然也可以。
現在讓我們來畫一棵完全二叉樹：
從圖中可以看出，元素的父親節點數組下標是本身的1/2(只取整數部分)，所以我們很容易去模擬，也很容易證明其所有操作都為
堆還分為兩種類型：大根堆、小根堆
顧名思義，就是保證根節點是所有數據中最大/小，並且盡力讓小/大的節點在上方
不過有一點需要註意：堆內的元素並不一定數組下標順序來排序的！！
很多的初學者會錯誤的認為大/小根堆中
下標為1就是第一大/小，2是第二大/小……
原因會在後面解釋，現在你只需要深深地記住這一點！
我們剛剛畫的完全二叉樹中並沒有任何元素，現在讓我們加入一組數據吧！
下標從1到9分別加入：{8，5，2，9，3，7，1，4，6}。
如下圖所示
我們可以發現這組數據是雜亂無章的，我們該如何去維護
現在我就來介紹一下堆的幾個基本操作：
- 上浮 shift_up
- 下沈 shift_down
- 插入 push
- 彈出 pop
- 取頂 top
- 堆排序 heap_sort
那麽我們開始講解操作過程吧，我們以小根堆為例
剛剛那組未處理過的數據中我們很容易就能看出，根節點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與其交換。
由此我們可以得出下沈的算法了：
讓當前結點的左右兒子(如果有的話)作比較，哪個比較小就和它交換，並更新詢問節點的下標為被交換的兒子節點下標，否則退出。
模擬操作圖示：
偽代碼如下：
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