哈夫曼编码算法

最新推荐文章于 2024-02-24 18:39:30 发布

爻渡

最新推荐文章于 2024-02-24 18:39:30 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏：编程开发(c) 文章标签：哈夫曼编码算法 c

本文链接：https://blog.youkuaiyun.com/u011640816/article/details/24925875

编程开发(c) 专栏收录该内容

28 篇文章

订阅专栏

本文介绍了一种使用C语言实现哈夫曼编码的方法。文章首先引导读者输入节点数量及权重，然后通过构建哈夫曼树来为每个字符生成唯一的二进制编码。最后输出了所有字符对应的哈夫曼编码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
 ============================================================================
 Name        : Exercise.c
 Author      : Haier
 Version     : 1.01
 Copyright   : Copyright (c) 2014
 Description : Huffman Coding in C, Ansi-style,Compile by Code:Block
 ============================================================================
 */

#include <stdio.h>
#define MAXLEN (10)
#define MAXNODE (20)

typedef struct huffnode     /*哈夫曼树节点结构*/
{
    int weight;
    int flag;
    int parent;
    int lchild;
    int rchild;
}huffnode;

typedef struct huffcode     /*哈夫曼编码节点结构*/
{
    int bits[MAXLEN];
    int start;
}huffcode;

int main()
{
    huffnode huff_node[MAXNODE];
    huffcode huff_code[MAXLEN],Temp;
    int NumberOfNode,i,j,Smallest=32767,SecondSmallest=32767;
    int SmallestIndex=0,SecondSmallestIndex=0;
    int Parent,CurrentNode;

    /*第一部分：构造哈夫曼树*/

    printf("Please input the number of node: ");
    scanf("%d",&NumberOfNode);

    for(i=0; i<2*NumberOfNode-1; i++)
    {
        huff_node[i].weight=0;
        huff_node[i].flag  =0;
        huff_node[i].lchild=-1;
        huff_node[i].rchild=-1;
        huff_node[i].parent=0;
    }

    for(i=0; i<NumberOfNode; i++)
    {
        printf("\nPlease input the weight of %d node: ",i+1);
        scanf("%d",&huff_node[i].weight);
    }

    for(i=0; i<NumberOfNode-1; i++)
    {
        Smallest=32767;
        SecondSmallest=32767;
        SmallestIndex=0;
        SecondSmallestIndex=0;

        for(j=0; j<NumberOfNode+i; j++)
        {
            if(huff_node[j].flag==0 && huff_node[j].weight<Smallest)
            {
                SecondSmallest=Smallest;
                SecondSmallestIndex=SmallestIndex;
                Smallest=huff_node[j].weight;
                SmallestIndex = j;

            }
            else if(huff_node[j].flag==0 && huff_node[j].weight<SecondSmallest)
            {
                SecondSmallest=huff_node[j].weight;
                SecondSmallestIndex=j;
            }
        }

        huff_node[SmallestIndex].parent      =NumberOfNode+i;
        huff_node[SecondSmallestIndex].parent=NumberOfNode+i;
        huff_node[SmallestIndex].flag             =1;
        huff_node[SecondSmallestIndex].flag  =1;
        huff_node[NumberOfNode+i].lchild     =SmallestIndex;
        huff_node[NumberOfNode+i].rchild     =SecondSmallestIndex;
        huff_node[NumberOfNode+i].weight=huff_node[SmallestIndex].weight+huff_node[SecondSmallestIndex].weight;
    }

    /*第二部分：求哈夫曼编码*/

    for(i=0; i<NumberOfNode; i++)
    {
        Temp.start=NumberOfNode;
        Parent=huff_node[i].parent;

        while(Parent)
        {
            if(huff_node[Parent].lchild==i)
            {
                Temp.bits[Temp.start]=0;
            }
            else
            {
                Temp.bits[Temp.start]=1;
            }

            Temp.start-=1;
            Parent=huff_node[Parent].parent;
        }

        for(j=(Temp.start+1); j<=NumberOfNode; j++)
        {
            huff_code[i].bits[j]=Temp.bits[j];
        }
        huff_code[i].start=Temp.start+1;
    }

    /*第三部分：输出编码*/

    for(i=0; i<NumberOfNode; i++)
    {
        for(j=huff_code[i].start; j<=NumberOfNode; j++)
        {
            printf("%d,",huff_code[i].bits[j]);
        }
        printf("\n");
    }

}