（1）輸入一段100—200字的英文短文，存入一檔案a中。
（2）寫函式統計短文出現的字母個數n及每個字母的出現次數
（3）寫函式以字母出現次數作權值，建Haffman樹（n個葉子），給出每個字母的Haffman編碼。
（4）用每個字母編碼對原短文進行編碼，碼文存入檔案b中。
（5）用Haffman樹對檔案b中碼文進行譯碼，結果存入檔案c中，比較a,c是否一致，以檢驗編碼、譯碼的正確性。

資料結構定義

typedef struct {
    unsigned int weight;
    unsigned int parent, lchild, rchild;
}   HTNode, *HuffmanTree;
 


typedef char **HuffmanCode;

統計字元個數

統計文章中各個字元的個數，即計算權值。

• （只考慮了大小寫字母，逗號，句號，空格這55個字元，其它字元情況編碼情況與此一致）

1、先一個個從檔案a裡讀入字元，用countletter陣列統計各字元出現的次數。因此，n = 55，m = 109。
2、陣列下標1到26用來按順序存放小寫字母出現次數，27到52存放大寫字母，53空格，54逗號，55句號。以便可以根據地址求得相應字元。

void count(int countletter[55])
{ 
    char ch;
    FILE *f;
    f = fopen
 
("a.txt","r");
    //freopen("a.txt","r",stdin);      此條語句用來從檔案“a.txt”中讀入資料
    while ((ch = fgetc(f)) != EOF)
    {
        if (ch <= 'z' && ch >= 'a')
        {
            countletter [ch-'a'+1] ++;
        } 
        else    if (ch <= 'Z' &&
 
 ch >= 'A')
        {
            countletter [ch-'A'+27] ++;
        }
        else if (ch == ',') 
            countletter [53] ++;
        else if (ch == '.')
            countletter [54] ++;
        else if (ch == ' ')
            countletter [55] ++;                                   
    } 
    fclose(f);
}

編碼

i 指向n + 1，在前i – 1 個結點中找權值最小的且parent域為0的兩個結點，將他們雙親域賦值為i，將第i個結點孩子域分別賦值為權值最小的倆結點的地址，且其權值為這兩個結點權值之和。然後i加一，在前i – 1個結點中重複上述步驟，直到i > m。

• 注：每次尋找權值最小的兩個結點時，他們的parent必須為0

void HuffmanCoding (HuffmanTree &HT, HuffmanCode &HC, int *w, int n)
{
    HuffmanTree p;
    int i, m, s1, s2, sum = 1;
    if (n <= 1)
        return;
    m = 2*n - 1; 	//由赫夫曼樹定義可知，存在n個字元時，最終會有2*n-1個結點
    w ++;
    HT = (HuffmanTree) malloc ((m+2) * sizeof(HTNode)); 	//開闢m+2個空間，因為（1）0號單元空置（2）與本人寫的select函式有關，需要一個單元來存放所有字元權值之和
    for (p = HT+1, i = 1; i <= n; ++ i, ++ p, ++ w)
        *p = {*w, 0, 0, 0};	//將字元出現次數作為權值賦值到55個字元的權值域，且將它們的雙親和孩子域都賦初值為0
    for (; i <= m; ++ i, ++ p)
        *p = {0, 0, 0, 0};	//剩下的結點權值、雙親、孩子域都賦初值為0
    for (i = 1; i <= n; ++ i)	//計算所有權值之和                                                  
        sum += HT[i].weight;
    HT[m+1].weight = sum + 1;	//求得的權值之和，放到多開闢的空間單位
    for ( i = n+1; i <= m; ++ i)
    {
        s1 = s2 = m+1;          
        /*
        s1,s2賦值為存放權值之和單元的下標，可以確保每次進入select函式時s1,s2
        指向的位置權值都不是當前最小的兩個（即s1,s2的值在select函式中一定會改變，那麼此時s1,s2指向的結點是否有雙親就不影響結果），
        就省去每次必須使s1,s2指向parent域為0結點的麻煩。 
        */                                        
        Select (HT, i-1, s1, s2);
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }
    
/*
對n 個結點建立Huffman樹，因為編碼長度最長為n - 1，建立一個長度為n的陣列cd，
每次用來暫時存放每個字元的編碼。Cd最後一個位置放“\0”，用來表示陣列結束位置。
*/
    int start;
    char *cd;
    HC = (HuffmanCode) malloc ((n+1)*sizeof(char *));
    cd = (char *)malloc(n * sizeof(char)); //用來記錄更新每個葉子結點編碼
    cd [n-1] = '\0';
    for (i = 1; i <= n; ++ i)
    {                                                                  
        start = n-1;
        for (int c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent)						//從葉子結點，沿著其雙親，判斷孩子與雙親的關係
        {
            if (c == HT[f].lchild)	//如果是雙親左孩子，則cd[start]賦值為0	
                cd[--start] = '0';
            else					//如果是雙親右孩子，則cd[start]賦值為1
                cd[--start] = '1';   
        }
        HC[i] = (char *)malloc ((n-start)* sizeof(char));
        strcpy (HC[i], &cd[start]); //把cd陣列從start到最後結束位置的字串複製到HC第i個結點對應的位置，即為第i個結點的編碼
    }
}

對前n個結點，i 先指向1，start用來表示cd陣列的下標，對每個字元從葉子到根逆向求編碼，即每次給start賦初值為n – 1，沿著葉子結點，取它的雙親結點地址（用c來記錄當前結點，f來記錄當前結點的雙親結點），判斷它是它雙親的左孩子還是右孩子，如果是右孩子，則cd[start]賦值為1，若是左孩子，則賦值為0，賦值後start --，c指向其雙親，f指向雙親的雙親，即沿著雙親結點一直往上，每次判斷左孩子還是右孩子，直到判斷到根結點，即雙親域為0的結點。此時，i 指向的葉子結點的編碼已經存到陣列cd中，因此只需要把cd陣列從start到最後結束位置的字串複製到HC第i個結點對應的位置，即為第i個結點的編碼。再將i加一，求下一個葉子結點的編碼。

select函式

void Select (HuffmanTree HT, int k, int &s1, int &s2)
//約定s1指向權值最小的結點，s2指向權值次小的結點
{
    for (int i = 1; i <= k; ++ i)
    {
        if (HT[i].parent == 0)
        {
            if (HT[i].weight <= HT[s1].weight)
            {
                s2 = s1;
                s1 = i;
            }
            else    if (HT[i].weight <= HT[s2].weight)
            {
                s2 = i;
            }  
        }
    }
}

把編碼存入檔案中

再從檔案a裡讀字元，根據每個字元把它對應的Huffman編碼輸入到檔案b裡。

void record(HuffmanCode HC)
{
    FILE *f1, *f2;
    f1 = fopen("b.txt","w");
    f2 = fopen("a.txt","r");
    char ch;
    while ((ch = fgetc(f2)) != EOF)
    {
        if (ch <= 'z' && ch >= 'a')
            fprintf(f1,"%s",HC[ch-'a'+1]);
        else    if (ch <= 'Z' && ch >= 'A')
            fprintf(f1,"%s",HC[ch-'A'+27]);
        else if (ch == ',')
            fprintf(f1,"%s",HC[53]);
        else if (ch == '.')
            fprintf(f1,"%s",HC[54]);
        else if (ch == ' ')
            fprintf(f1,"%s",HC[55]);                         
    } 
    fclose(f2);
    fclose(f1);
}

譯碼

從檔案b裡讀編碼，用ch記錄，每次從根結點開始，即地址為m的結點，讀到字元1，則取右孩子，讀到字元0，則取左孩子，一直到葉子結點，（即孩子域為0），根據它的地址計算它的字元並輸出。繼續從檔案裡讀編碼，從根結點開始，讀字元判斷左右孩子，到葉子結點，根據求得葉子結點的地址輸出相對應字元，重複上述步驟，一直到檔案結束。此時，已經根據編碼輸出了所有字元。

void yima(HuffmanTree HT, int n)
{
    FILE *f, *p;
    f = fopen ("b.txt", "r");
    p = fopen ("c.txt", "w");
    char ch;
    int i = 2*n - 1;
    ch = fgetc(f);
    while (ch!= EOF )
    {
        i = 2*n - 1;
        while (HT[i].rchild != 0)//一直到葉子結點
        {
            if (ch == '0')		//讀到字元0，則取左孩子
                i = HT[i].lchild;
            else				//讀到字元1，則取右孩子
                i = HT[i].rchild;
            ch = fgetc(f);
        }
        if (i >= 1 && i <= 26)
            fprintf (p, "%c", i + 96);
        else if( i >= 27 && i <= 52)
                fprintf(p, "%c", i + 38); 
        else if ( i == 53)
            fprintf(p, ",");
        else if (i == 54)
            fprintf(p, ".");
        else if (i == 55)
            fprintf(p, " ");
    }
    fclose(f);
    fclose(p);
}

主函式

int main()
{
    int countletter[100] = {0};
    HuffmanTree HT;
    HuffmanCode HC;
    count(countletter);
    HuffmanCoding (HT, HC, countletter, 55);
    record(HC); 
    yima (HT, 55);
    return 0;
}