1. 目標

讀取一段字元，生成哈夫曼編碼，並輸出。如下所示：

2. 程式碼結構

2.1 統計各個字元出現的次數，並排序；

2.2 根據生成的哈夫曼樹，生成哈夫曼編碼；

3. 原始碼

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define title "------------------------------Life is a fight!------------------------------------"
#define queueSize_Max 256 //佇列的最大長度
#define code_Max 256 //編碼的最大長度

/**************************************/
/*定義Huffman Tree節點                */
/*其中symbol記錄節點儲存的字元        */
/*left, right指向左右子節點           */
/**************************************/
typedef struct hfmTreeNode{
    int symbol;
    struct hfmTreeNode *left;
    struct hfmTreeNode *right;
} hfmTreeNode, *phTreeNode;

/**************************************/
/*定義一個指向Huffman Tree的根節點    */
/**************************************/
typedef struct hHfmTreeNode{
    hfmTreeNode* rootNode;
} hHfmTreeNode;

/**************************************/
/*定義佇列的節點                      */
/*ptr是一個指向phTreeNode的指標，     */
/*主要是方便後續建立Huffman Treee     */
/*Count記錄字元出現的頻次，           */
/*next指向下一個節點                  */
/**************************************/
typedef struct queueNode{
    phTreeNode ptr;
    int count;
    struct queueNode *next;
} queueNode, *ptrQueue;

/**************************************/
/*定義指向queueNode的頭節點           */
/*其中size記錄節點的數量              */
/*first指向queueNode的第一個節點      */
/**************************************/
typedef struct hQueueNode{
    int size;
    ptrQueue first;
} hQueueNode;

/**************************************/
/*定義指向記錄編碼的table節點         */
/*symble為字元，code指向對應的編碼    */
/*next用來指向下一個節點              */
/**************************************/
typedef struct tableNode{
    char symbol;
    char* code;
    struct tableNode *next;
} tableNode;

/**************************************/
/*定義指向tableNode的頭節點           */
/*first標記第一個節點                 */
/*last指向最後一個節點                */
/**************************************/
typedef struct hdTableNode{
    tableNode *first;
    tableNode *last;
} hdTableNode;

/**************************************/
/*對佇列進行初始，新增一個頭節點      */
/*其中size記錄節點的數量              */
/*first指向queue節點                  */
/**************************************/
void initQueue(hQueueNode** hQueue)
{
    *hQueue=(hQueueNode*)malloc(sizeof(hQueueNode));
    (*hQueue)->size=0;
    (*hQueue)->first=NULL;
}

void addQueueNode(hQueueNode **hQueue,hfmTreeNode *hNode,int count)//新建一個佇列節點並按統計的結果從小到大的順序加入佇列
{
    queueNode *qNode=NULL;

    if((*hQueue)->size==queueSize_Max)//佇列規模檢查，正常情況下不會出現
    {
        printf("\nERR: The queue is full!!!");
    }
    else    //如果正常，則按照從小到大的順序，尋找正確的位置插入節點
    {
        if(0==(*hQueue)->size)//如果是新增的第一個節點，直接新增即可
        {
            qNode=(queueNode*)malloc(sizeof(queueNode));
            (*hQueue)->first=qNode;
            qNode->count=count;
            qNode->ptr=hNode;
            qNode->next=NULL;
            (*hQueue)->size++;
        }
        else if(count<(*hQueue)->first->count)//如果要新增的字元的統計數量小於現有最小的，則直接放在第一個節點處
        {
            qNode=(queueNode*)malloc(sizeof(queueNode));
            qNode->next=(*hQueue)->first;
            (*hQueue)->first=qNode;
            qNode->count=count;
            qNode->ptr=hNode;
            (*hQueue)->size++;
        }
        else    //對於第三類情況，則需要遍歷佇列，直到尋找到合適的位置
        {
            queueNode* p=(*hQueue)->first;
            qNode=(queueNode*)malloc(sizeof(queueNode));
            qNode->count=count;
            qNode->ptr=hNode;
            (*hQueue)->size++;

            while(p->next!=NULL && count>=p->next->count)
                p=p->next;
            qNode->next=p->next;
            p->next=qNode;
        }
    }
}

hfmTreeNode* getHfmTreeNode(hQueueNode* hQueue)
{
    hfmTreeNode* getNode;
    if(hQueue->size>0)
    {
        getNode=hQueue->first->ptr;
        hQueue->first=hQueue->first->next;
        hQueue->size--;
    }
    else
    {
        printf("\nERR: Can't get a node\n");
    }
    return getNode;
}


hHfmTreeNode* crtHfmTree(hQueueNode** hQueue)
{
    int count=0;
    hfmTreeNode *left, *right;

    while((*hQueue)->size>1)
    {
        count=(*hQueue)->first->count+(*hQueue)->first->next->count;
        left=getHfmTreeNode(*hQueue);
        right=getHfmTreeNode(*hQueue);

        hfmTreeNode *newNode=(hfmTreeNode*)malloc(sizeof(hfmTreeNode));

        newNode->left=left;
        newNode->right=right;

        addQueueNode(hQueue,newNode,count);
    }

    hHfmTreeNode* tree=(hHfmTreeNode*)malloc(sizeof(hHfmTreeNode));
    tree->rootNode=getHfmTreeNode(*hQueue);
    return tree;
}

hHfmTreeNode* creatTree(void)
{
    FILE *ifile;
    int *countArray;
    char c;
    int i;

    countArray=(int*)malloc(sizeof(int)*256);//分配空間用於儲存各字元出現的次數,並初始化為零
    for(i=0;i<256;i++)
    {
        countArray[i]=0;
    }

    ifile=fopen("D://1.txt","r");
    if(!ifile)  //檢查檔案是否開啟成功
        printf("Can't open the file\n");
    else
        {
            while((c=getc(ifile))!=EOF)
            {
                countArray[(unsigned int)c]++;
                printf("%c", c);
            }
            fclose(ifile);
        }
    hQueueNode *hQueue;
    initQueue(&hQueue);
    for(i=0;i<256;i++)
    {
        if(countArray[i])
        {
            //printf("%c %d\n",i, countArray[i] );
            hfmTreeNode *hNode=(hfmTreeNode*)malloc(sizeof(hfmTreeNode));//建立一個樹節點，並初始化（用來對應佇列queueNode中的ptr）

            hNode->symbol=(char)i;
            hNode->left=NULL;
            hNode->right=NULL;

            addQueueNode(&hQueue,hNode,countArray[i]);//將該節點插入佇列中的適當位置（按統計的結果，從小到大排列）
        }
    }
    free(countArray);//釋放不用的記憶體

    queueNode* q=hQueue->first;
    printf("\n");
    do
    {
        printf("\n%c %d",q->ptr->symbol, q->count);
        q=q->next;
    }    while(q!=NULL);
    //printf("%d",hQueue->size);

    hHfmTreeNode *tree=crtHfmTree(&hQueue);
    return tree;
}

void traverseTree( hdTableNode** table, hfmTreeNode* tree, char* code, int k)
{
    if(tree->left==NULL && tree->right==NULL)   //遞迴結束檢查，即找到葉子節點
    {
        code[k]='\0';   //新增字串結束標記
        tableNode *tNode=(tableNode*)malloc(sizeof(tableNode)); //建立一個節點，並將其新增到table連結串列中
        tNode->code=(char*)malloc(sizeof(char)*256+1);
        strcpy(tNode->code,code);
        tNode->symbol=tree->symbol;
        tNode->next=NULL;

        if((*table)->first==NULL)   //如果是第一個節點，直接新增即可， 否則新增到尾部即可
        {
            (*table)->first=tNode;
            (*table)->last=tNode;
        }
        else
        {
            (*table)->last->next=tNode;
            (*table)->last=tNode;
        }
    }

    if(tree->left!=NULL)    //向左邊遞迴，並記錄編碼為0
    {
        code[k]='0';
        traverseTree(table,tree->left, code, k+1);
    }

    if(tree->right!=NULL)   //向右邊遞迴，並記錄編碼為1
    {
        code[k]='1';
        traverseTree(table, tree->right, code, k+1);
    }
}

hdTableNode* crtTable(hHfmTreeNode* hfmTree)
{
    hdTableNode* hdTable=(hdTableNode*)malloc(sizeof(hdTableNode));
    hdTable->first=NULL;
    hdTable->last=NULL;

    char code[code_Max];
    int k=0; //記錄樹的層級

    traverseTree(&hdTable, hfmTree->rootNode, code, k);
    return hdTable;
}



int main(void)
{
    hHfmTreeNode* tree;
    hdTableNode* table;

    printf("%s\n\n\n",title);
    tree=creatTree();
    table=crtTable(tree);
    int i=0, j=0;
    tableNode* t=table->first;
    char* s=t->code;
    printf("\n\n*************************************************************************************\n");
    printf("The Huffman code is:\n");
    while(t!=NULL)
    {

        for(i=0;i<257;i++)
        {
            if((*s)!='\0')
            {
                printf("%c",*s);
                s++;
            }
        }
            printf("%8c\n",t->symbol);
            t=t->next;
            if(t)
                s=t->code;

    }
}