哈夫曼树的代码实现

哈夫曼树的介绍

哈夫曼树（Huffman Tree）是一种二叉树，用于编码和解码数据。它是由David A. Huffman于1952年提出的。

        哈弗曼树的构建过程是基于哈弗曼编码的思想。哈夫曼编码是一种可变长度编码（Variable-Length Code）方式，用于将字符集中的每个字符映射为唯一的二进制编码。这种编码方式的特点是，出现频率高的字符使用较短的编码，出现频率低的字符使用较长的编码，以此来实现对文本数据的压缩。

        哈夫曼树的构建过程是根据字符的出现频率来创建的。每个字符都是哈夫曼树中的一个叶子节点，出现频率越高的字符离根节点越近，出现频率越低的字符离根节点越远。构建哈夫曼树的算法是：先将所有字符按照出现频率从小到大排序，然后选取频率最小的两个字符，将它们作为左右子节点构建一颗新的二叉树，该节点的权值为这两个字符的频率之和。然后将新生成的节点插入到原来的节点集合中，并重新排序。重复以上过程，直到只剩下一棵二叉树，即为哈夫曼树。

        构建哈夫曼树的时间复杂度为O(nlogn)，其中n为字符集的大小。哈夫曼树的应用非常广泛，主要用于数据压缩、加密解密、图像压缩等领域。

哈夫曼树的性质

哈夫曼树是一种用于数据压缩的树结构，其性质如下：

哈夫曼树是一棵带权树，即树中每个节点都有一个权值。
哈夫曼树是一棵最优树，即它可以使得树中所有叶子节点的权值和最小。
哈夫曼树是一棵二叉树，即每个节点最多有两个子节点。
在哈夫曼树中，权值较小的节点离根节点更近。
利用哈夫曼树进行数据压缩可以减小数据的存储空间，提高数据传输的效率。

哈夫曼树的代码实现

树的节点结构及常量定义：

#define TRUE 1
#define FALSE -1
typedef char ElemType;
typedef struct Node{
    ElemType elem;
    struct Node* left;
    struct Node* right;
    struct Node* parent;
    int weight;
}HTNode,*HTree;
typedef struct
{
    ElemType elem;
    char* huffcode;
    int code_length;
    int weight;
}HuffCode;

初始化树：

int InitHuffTree(HTree* tree,int weight,ElemType elem)
{
    HTNode* summon=(HTNode*)malloc(sizeof(HTNode));
    if(summon!=NULL)
    {
        summon->elem=elem;
        summon->weight=weight;
        summon->left=NULL;
        summon->parent=NULL;
        summon->right=NULL;
        (*tree)=summon;
        return TRUE;
    }else
    {
        return FALSE;
    }
}

销毁树：

void DestroyHuffTree(HTree* tree)
{
    if((*tree)!=NULL)
    {
        DestroyHuffTree(&(*tree)->left);
        DestroyHuffTree(&(*tree)->right);
        free((*tree));
        (*tree)=NULL;
    }
}

树的先序遍历：

void PreTraverseTree(HTree* htnode)
{
    if((*htnode)!=NULL)
    {
        printf("%c",(*htnode)->elem);
        PreTraverseTree(&(*htnode)->left);
        PreTraverseTree(&(*htnode)->right);
    }
}

树的中序遍历：

void InTraverseTree(HTree* htnode)
{
    if((*htnode)!=NULL)
    {
        PreTraverseTree(&(*htnode)->left);
        printf("%c",(*htnode)->elem);
        PreTraverseTree(&(*htnode)->right);
    }
}

树的后序遍历：

void PostTraverseTree(HTree* htnode)
{
    if((*htnode)!=NULL)
    {
        PreTraverseTree(&(*htnode)->left);
        PreTraverseTree(&(*htnode)->right);
        printf("%c",(*htnode)->elem);
    }
}

创建树：

HTree CreateHuffTree(int* weights,ElemType* elems,int length)
{
    HTNode* collection[length*2-1];
    HTNode* temp=NULL;
    for(int i=0;i<length;i++)
    {
        InitHuffTree(&collection[i],weights[i],elems[i]);
    }
    for(int i=length;i<length*2-1;i++)
    {
        InitHuffTree(&collection[i],0,'\0');
    }
    for(int i=length;i<length*2-1;i++)
    {
        for(int j=(i-length)*2;j<i;j++)
        {
            for(int k=j+1;k<i;k++)
            {
                if(collection[j]->weight>collection[k]->weight)
                {
                    temp=collection[j];
                    collection[j]=collection[k];
                    collection[k]=temp;
                }
            }
        }
        collection[i]->weight=collection[(i-length)*2]->weight+collection[(i-length)*2+1]->weight;
        collection[i]->left=collection[(i-length)*2];
        collection[i]->right=collection[(i-length)*2+1];
        collection[i]->left->parent=collection[i];
        collection[i]->right->parent=collection[i];
    }
    return collection[length*2-2];
}

获取叶子节点的长度：

int GetLength(ElemType* elems)
{
    int i=0;
    while(elems[i]!='\0')
    {
        ++i;
    }
    return i;
}

获取树节点：

HTNode* GetNode(HTree* tree,ElemType elem)
{
    HTNode* result=NULL;
    if((*tree)==NULL)
    {
        return NULL;
    }
    else if((*tree)->elem==elem)
    {
        return (*tree);
    }else
    {
        result=GetNode(&(*tree)->left,elem);
        if(result!=NULL)
        {
            return result;
        }
        result=GetNode(&(*tree)->right,elem);
        if(result!=NULL)
        {
            return result;
        }
    }
}

获取编码值：

HuffCode GetHuffCode(HTree* tree,ElemType elem)
{
    HTNode* tmp=GetNode(&(*tree),elem);
    HuffCode result;
    int counter=0,tag=0;
    result.elem=elem;
    if(tmp==NULL)
    {
        result.huffcode=(char*)malloc(sizeof(char));
        result.weight=0;
        result.code_length=0;
        return result;
    }
    while(tmp->parent!=NULL)
    {
        tmp=tmp->parent;
        counter++;
    }
    tmp=GetNode(&(*tree),elem);
    result.elem=elem;
    result.huffcode=(char*)malloc(sizeof(char)*(counter+1));
    result.weight=tmp->weight;
    while(tmp->parent!=NULL)
    {
        if(tmp->parent->left==tmp&&tmp->parent!=NULL)
        {
            result.huffcode[counter-tag-1]='0';
        }
        else if(tmp->parent->right==tmp&&tmp->parent!=NULL)
        {
            result.huffcode[counter-tag-1]='1';
        }
        tmp=tmp->parent;
        tag++;
    }
    result.huffcode[tag]='\0';
    result.code_length=counter;
    return result;
}

销毁编码：

void DestroyHuffCode(HuffCode* code)
{
    free(code->huffcode);
    code->huffcode=NULL;
}

获取树的深度：

int GetHuffTreeDepth(HTree* tree)
{
    int max_depth=0;
    int left=0;
    int right=0;
    if((*tree)==NULL)
    {
        return 0;
    }
    else
    {
        left=GetHuffTreeDepth(&(*tree)->left)+1;
        if(max_depth<left)
        {
            max_depth=left;
        }
        right=GetHuffTreeDepth(&(*tree)->right)+1;
        if(max_depth<right)
        {
            max_depth=right;
        }
        return max_depth;
    }
}

获取树的带权路径长度：

int GetWPL(HTree* tree,ElemType* elems)
{
    int counter=GetLength(elems);
    int start=0;
    int result=0;
    HuffCode temp;
    while(start<counter)
    {
        temp=GetHuffCode(&(*tree),elems[start]);
        result=result+temp.code_length*temp.weight;
        start++;
    }
    return result;
}

        写到这里感谢大家的耐心阅读。