對於給定一個長度為m序列，構造一顆以序列值為權的m個外部結點的擴充二叉樹，使得帶權的外部路徑長度WPL最小，就稱這顆擴充二叉樹為 哈夫曼（Huffman）樹（最優二叉樹）。構造Huffman Tree 的演算法也就是哈夫曼演算法。

演算法基本思想：

1）給定m個權值，首先構造m課擴充二叉樹，每顆只有一個外部結點（根結點）。

2）在已經構造的所有擴充二叉樹中，選擇根結點權值最小的和次小的兩顆，將它們作為左、右子樹，構造一顆新的擴充二叉樹，它的根結點的權值為其左右子樹根結點的權值之和。

3）重複2），每次使得擴充二叉樹的數目減一，當只剩下最後一顆擴充二叉樹時，其便是所求的哈夫曼樹。

程式碼實現：

#include <iostream>
#define MAXINT 10000
#define N 13                        //構建13個結點
using namespace std;

struct HtNode{
    int var,parent,llink,rlink;
};
struct HtTree{
    int m,root;                     //外部結點個數、根結點在ht陣列中的下標
    struct  HtNode *ht;
};
typedef struct HtTree * PHtTree;

void print(PHtTree p)
{
    cout<<"index var parent lchild rchild\n";
    for(int i=0;i<2*N-1;i++)
        cout<<i<<"\t"<<p->ht[i].var<<"   "<<p->ht[i].parent<<"     "
            <<p->ht[i].llink<<"     "<<p->ht[i].rlink<<endl;
}

PHtTree huffman(int m,int *seq)
{
    PHtTree pht=new struct HtTree;  //分配空間
    pht->ht=new HtNode[2*m-1];      //外部結點為m，則內部結點為m-1，則總共點數為2m-1
    for(int i=0;i<2*m-1;i++){       //置ht陣列初態
        pht->ht[i].llink=pht->ht[i].rlink=pht->ht[i].parent=-1;
        pht->ht[i].var= i<m?seq[i]:-1;
    }
    cout<<"陣列ht的初態：\n";
    print(pht);
    for(int i=0;i<m-1;i++){         //每次迴圈構造一個內部結點
        int m1=MAXINT,m2=MAXINT;
        int x1=-1,x2=-1;
        for(int j=0;j<m+i;j++){
                                    //找最小權的無父節點的結點
            if(pht->ht[j].var<m1 && pht->ht[j].parent==-1){
                m2=m1;x2=x1;
                m1=pht->ht[j].var; x1=j;
            }                       //找次最小權的無父節點的結點
            else if(pht->ht[j].var<m2 && pht->ht[j].parent==-1){
                m2=pht->ht[j].var;x2=j;
            }
        }
                                    //構造內部結點
        pht->ht[x1].parent=pht->ht[x2].parent=m+i;
        pht->ht[m+i].var=m1+m2;
        pht->ht[m+i].llink=x1;
        pht->ht[m+i].rlink=x2;
    }
    pht->root=2*m-2;
    return pht;
}
int main()
{
    int sequence[N];
    for(int i=0;i<N;i++)
        cin>>sequence[i];
    PHtTree p=huffman(N,sequence);
    cout<<"陣列ht的終態：\n";
    print(p);
    return 0;
}
 

時間複雜度為O(n^2)。

Input

2 3 5 7 11 13 17 19 23 29 31 37 41

Output

陣列ht的初態：
index var parent lchild rchild
0       2   -1     -1     -1
1       3   -1     -1     -1
2       5   -1     -1     -1
3       7   -1     -1     -1
4       11   -1     -1     -1
5       13   -1     -1     -1
6       17   -1     -1     -1
7       19   -1     -1     -1
8       23   -1     -1     -1
9       29   -1     -1     -1
10      31   -1     -1     -1
11      37   -1     -1     -1
12      41   -1     -1     -1
13      -1   -1     -1     -1
14      -1   -1     -1     -1
15      -1   -1     -1     -1
16      -1   -1     -1     -1
17      -1   -1     -1     -1
18      -1   -1     -1     -1
19      -1   -1     -1     -1
20      -1   -1     -1     -1
21      -1   -1     -1     -1
22      -1   -1     -1     -1
23      -1   -1     -1     -1
24      -1   -1     -1     -1
陣列ht的終態：
index var parent lchild rchild
0       2   13     -1     -1
1       3   13     -1     -1
2       5   14     -1     -1
3       7   15     -1     -1
4       11   16     -1     -1
5       13   16     -1     -1
6       17   17     -1     -1
7       19   18     -1     -1
8       23   18     -1     -1
9       29   19     -1     -1
10      31   20     -1     -1
11      37   21     -1     -1
12      41   21     -1     -1
13      5   14     0     1
14      10   15     2     13
15      17   17     3     14
16      24   19     4     5
17      34   20     6     15
18      42   22     7     8
19      53   22     16     9
20      65   23     10     17
21      78   23     11     12
22      95   24     18     19
23      143   24     20     21
24      238   -1     22     23
 

構造的哈夫曼樹如下，