如果用vector實現，在運行時遍歷尋找最小的兩個節點，時間復雜度為O(N^2)

但是我們可以用priority_queue優化，達到O(N logN)的時間復雜度

需要註意的是priority_queue的模板type不能存指針。因為指針是64位整數，存的是數據在內存中的地址。但如果直接存Node

（Ｎｏｄｅ＝｛ｄａｔａ；＊ｌＣｈｉｌｄ；＊ｒＣｈｉｌｄ；｝）的話，因為每次堆調整內存地址都會發生改變，並且因為變量的生命周期，這也無法實現。

所以最好還是用一個Node數組靜態實現，左右子樹地址保存數組中的索引，這和數據結構中的“靜態鏈表”很相似，這種處理方法在編程中經常用到。

代碼：

#include<cstdio>
#include
 
<queue>
#include<algorithm>

using namespace std;

int arr[100];
typedef struct Node{
    int d,l,r,p;
    Node(int d=0):d(d){
        l=-1;
        r=-1;
    }
    bool operator < (const Node& obj) const
    {
        return d>obj.d;
    }
}Node;

Node nodes[100];

priority_queue<Node> pq;

 
int main(){
    freopen("huffman.txt","r",stdin);
    int i,n=0;
    while(~scanf("%d",&i)){
        nodes[n]=Node(i);
        nodes[n].p=n;
        pq.push(nodes[n]);
        n++;
    }
    while(pq.size()>1){
        if(pq.empty()) break;
        Node a=pq.top();
        pq.pop();
        if
 
(pq.empty()) break;
        Node b=pq.top();
        pq.pop();
        Node c(a.d+b.d);
        c.l=a.p;
        c.r=b.p;
        nodes[n]=c;
        c.p=n++;
        pq.push(c);
    }
    queue<int> q;
    q.push(pq.top().p);
    while(!q.empty()){
        int sz=q.size();
        while(sz--) {
            int t=q.front();
            q.pop();
            printf("%d ",nodes[t].d);
            if(nodes[t].l>=0)
                q.push(nodes[t].l);
            if(nodes[t].r>=0)
                q.push(nodes[t].r);
        }
        puts("") ;
    }
}

測試數據（huffman.txt）：

1 5 6 8 6 5 8 7 9 7 3

效果：

優先隊列優化的 Huffman樹 建立