注：堆分為最大堆和最小堆兩種，下面我們討論的堆都是指的最大堆，最小堆的性質與其是類似的。

堆資料結構是一種陣列物件，可以被視為一棵完全二叉樹(這棵二叉樹除最後一層外，其餘每層都是填滿的)；我們用一個數組來儲存一個堆，表示堆的陣列有兩個屬性：length[A]表示的是陣列中的元素個數，headsize[A]表示堆中元素個數(也就是說陣列中的元素不一定都是堆中的元素)。
下面不加證明的給出一些堆的性質：
對於任何一個節點,其父節點為i/2(i>1)；左兒子:2*i,右兒子：2*i+1;
對於最大堆每個節點滿足：A[parent[i]]>=A[i]
含n個元素堆的高度為lgn
含n個元素堆的葉子節點的編號為:n/2+1,n/2+2,……,n。

一.堆的調整函式—保持堆的性質
考慮這樣一種情況，如果對於節點i，其左右子樹都是一個合法的大根堆，但是節點i不滿足堆的性質，那麼我們可以通過調整使得以i為根節點的樹滿足堆的性質。那麼具體的調整過程是怎樣的呢？我們令largest表示A[i],A[i*2],A[2*i+1]中最大的那個，如果largest不是i那麼我們就交換A[i]和A[largest]並且遞迴的進入到以largest為根節點的子樹中繼續進行調整。具體的程式碼實現如下：

void MaxHeadfly(int *a,int i,int HeadSize)
{  ///堆調整函式：調整以i為根的子樹,使得其符合大根堆的特性(在其左右子樹都是合法的大根堆的情況下)
 

  ///最大堆調整函式是堆排序中最重要的函式，是後面幾個函式的重要組成部分；
 ///其主要思想是：先是調整根節點然後遞迴的調整受影響的左(右)子樹，直到葉子節點

        int l=2*i,r=2*i+1; ///取出節點i的左右兒子節點的編號
        int largest;  ///記錄最大值的節點編號
        if(a[i]<a[l]&&l<=HeadSize)
            largest=l;
        else
            largest=i;
       if(a[largest]<a[r]&&r<=HeadSize)
            largest=r;
        if
 
(largest!=i)
        {///遞迴調整受影響的子樹
                swp(a[i],a[largest]);
                MaxHeadfly(a,largest,HeadSize);
        }
}

二.堆的建立
堆的建立其實就是一個不斷呼叫調整函式的過程。我們知道堆的葉子節點可以看成只含有一個元素合法的大根堆，這樣如果我們從第一個非葉子節點開始依次呼叫調整函式，就可以保證被調整的節點的左右子樹都是合法的大根堆，進而可以保證調整得到的樹也是合法的大根堆。具體的程式碼實現如下：

void BuildMaxHead(int *a,int n)
{ ///最大堆建立函式：通過對陣列元素有序的進行調整，使得陣列成為一個大根堆
  ///由完全二叉樹的性質：含n個元素的堆，其葉子節點編號為n/2+1,n/2+2。。。n;
  ///對於葉子節點可以看成合法的單個元素的大根堆，由MaxHeadfly函式的性質可以知道
  ///如果節點i不滿足大根堆的性質，但是其左右子樹都是合法的大根堆，那麼呼叫MaxHeadfly
  ///調整後以i為根節點可以構成一個合法的大根堆，而一個節點的左右兒子節點編號都是大於其的
  ///所以我們可以從編號n/2--1的節點依次呼叫堆的調整函式，然後就可以得到一個大根堆了。

  for(int i=n/2;i>=1;i--)
          MaxHeadfly(a,i,n);
}

三.堆排序
顧名思義堆排序就是利用堆的性質對陣列進行排序，對於一個堆來說我們能利用的性質就是其根節點中的元素是最大的，這次每次我們都可以將A[1]與A[HeadSize]進行交換，交換以後HeadSize的值減1,並且呼叫MaxHeadfly(a,1,HeadSize)對堆進行調整，使得A[1]又變成剩下元素中最大的，然後繼續這個過程。最後得到一個有序的陣列。堆排序的時間複雜度是nlgn；具體的程式碼實現如下：

void HeadSort(int *a,int n)
{///堆排序函式：實現對陣列中的n個元素進行從小到大的排序，時間複雜度nlgn
  ///我們知道如果一個數組構成大根堆後，那麼其根節點a[1]必定是其中最大的元素
  ///此時如果我們將a[1]與a[n]互換，那麼a[n]就是最大的元素了；
  ///但是a[1--n-1]構成的堆可能不再滿足最大堆的性質，我們再呼叫MaxHeadfly(a,1,n-1)調整成最大堆
  ///然後a[1]就成了a[1--n-1]中最大的元素了，然後我們交換a[1]和a[n-1]，那麼a[n-1]和a[n]就是有序的了。
  ///繼續這個過程直到堆的規模減少到2，然後進行最後一次調整交換，a陣列就有小到大排列了。
  ///時間複雜度：建立大根堆時間O(n),每次調整時間O(lgn)共調整n-1次，所以總的複雜度nlgn
        BuildMaxHead(a,n);  ///建立一個大根堆
        int HeadSize = n;
        for(int i=n;i>=2;i--) ///堆的規模不斷減少
        {
               swp(a[1],a[i]);
               HeadSize--;   ///交換以後就要減少堆的大小
               MaxHeadfly(a,1,HeadSize);   ///根節點改變了,重新調整成大根堆
        }
}

下面附上一份完整的堆排序的程式碼：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int swp(int &a,int &b)
{
       int t=a;
        a=b;
        b=t;
}

void MaxHeadfly(int *a,int i,int HeadSize)
{  
        int l=2*i,r=2*i+1; ///取出節點i的左右兒子節點的編號
        int largest;  ///記錄最大值的節點編號
        if(a[i]<a[l]&&l<=HeadSize)
            largest=l;
        else
            largest=i;
       if(a[largest]<a[r]&&r<=HeadSize)
            largest=r;
        if(largest!=i)
        {///遞迴調整受影響的子樹
                swp(a[i],a[largest]);
                MaxHeadfly(a,largest,HeadSize);
        }
}

void BuildMaxHead(int *a,int n)
{ 
  for(int i=n/2;i>=1;i--)
          MaxHeadfly(a,i,n);
}

void HeadSort(int *a,int n)
{
        BuildMaxHead(a,n);  ///建立一個大根堆
        int HeadSize = n;
        for(int i=n;i>=2;i--) ///堆的規模不斷減少
        {
               swp(a[1],a[i]);
               HeadSize--;   ///交換以後就要減少堆的大小
               MaxHeadfly(a,1,HeadSize);   ///根節點改變了,重新調整成大根堆
        }
}

int main()
{
      int n=5,a[10];
      cout<<"請輸入"<<n<<"個數："<<endl;
      for(int i=1;i<=n;i++)
           cin>>a[i];
      HeadSort(a,n);
      cout<<"排序以後的陣列："<<endl;
      for(int i=1;i<=n;i++)
          cout<<a[i]<<" ";
      cout<<endl;
   return 0;
}

四.優先佇列
對於一般的佇列來說，滿足先進先出的性質(隊尾入隊，對首出隊)，但對於優先佇列來說，每次都是最大的/最小的元素出隊。堆可以實現優先佇列的基本操作，利用的也是堆的性質。優先佇列一些具體的函式操作及其原理見下面的程式碼。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

#define INF 0x3f3f3f3f

///一般的佇列滿足先進先出的性質，而優選佇列不同，其
///總是最大的/最小的先出隊。藉助於堆的性質，我們可以
///在lgn的時間內實現優選佇列的任何操作
void swp(int &a,int &b)
{
      int t=a;
      a=b;
      b=t;
}

void MaxHeadfly(int *a,int i,int HeadSize)///堆調整函式
{
        int largest;
        int l=i*2,r=2*i+1;
        if(a[i]<a[l]&&l<=HeadSize)
             largest=l;
        else
             largest=i;
        if(a[largest]<a[r])
             largest=r;
        if(largest!=i)
        {
             swp(a[i],a[largest]);
             MaxHeadfly(a,largest,HeadSize);
        }
}

void BuildMaxHead(int *a,int n) ///建立一個最大堆
{
        int k=n/2;
        for(int i=k;i>=1;i--)
               MaxHeadfly(a,i,n);
}

///以下為優先佇列的操作

int MaxNum(int *a) ///取出最大的元素
{
      return a[1];   ///直接返回
}

void IncreaseKey(int *a,int x,int k)
{   ///將堆中編號為x的元素的值提升到k,k不能小於原來的值。
     ///這種提升只可能會導致父節點不滿足最大堆的性質，所以直接向上遞迴的檢查
     a[x]=k;
     while(x>1&&a[x/2]<a[x])
     {
             swp(a[x],a[x/2]);
             x=x/2;
     }
}

int ExtractMax(int *a,int &HeadSize)
{    ///去掉堆中最大的元素，並返回其值
      ///思想類似於堆排序的一次調整:我們先交換a[1]與a[HeadSize]的值
      ///然後再將HeadSize的值減1(相當於去掉一個葉子節點)；然後再呼叫
      ///MaxHeadfly(a,1,HeadSize)對堆進行調整，保證堆的性質。
      swp(a[1],a[HeadSize]);
      HeadSize--;
      MaxHeadfly(a,1,HeadSize);
      return a[HeadSize];
}

void Insert(int *a,int &HeadSize,int x)
{    ///向堆中加入一個元素x
     ///思想：先在堆中加入一個葉子節點，並將其值賦值為-INF
     ///然後再呼叫上面的調整函式將該葉子節點的值調整為x

     HeadSize++;  ///增加一個葉子節點
     a[HeadSize]=-1*INF;
     IncreaseKey(a,HeadSize,x);
}

int main()
{
        int a[10];
        int n=5;
        cout<<"請輸入5個數: "<<endl;
        for(int i=1;i<=n;i++)
             cin>>a[i];
        int HeadSize=n;
        BuildMaxHead(a,n);
        ///取出佇列中 最大的那個元素
        cout<<"最大的元素是: "<<MaxNum(a)<<endl;
        ExtractMax(a,HeadSize);
        cout<<"移除最大元素後，剩下元素中最大的是: "<<MaxNum(a)<<endl;
        ///將第4個元素增加到100
        IncreaseKey(a,4,100);
        cout<<"將第4個元素增加到100後,最大元素是: "<<MaxNum(a)<<endl;
        ///將110插入到佇列中
        Insert(a,HeadSize,110);
        cout<<"插入110後，最大元素是: "<<MaxNum(a)<<endl;
   return 0;
}