哈夫曼编码的设计与实现

最新推荐文章于 2024-04-04 11:18:58 发布
最新推荐文章于 2024-04-04 11:18:58 发布
阅读量1.5k 收藏
点赞数
分类专栏： 数据结构 文章标签： algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzuhuang/article/details/12611621
版权
#include   "stdafx.h"
#include   <iostream>
#include   <vector>
#include   <list>
#include   <algorithm>

const   static   int   nBufferSize   = 1024;

char   g_szBuffer [   nBufferSize ] =   "ABCEFHDILASJBNDBBBBSAAUILDK"   ;
int       g_nMaxNum   = 100000;

enum   {    TREE_TAG_LEFT   = 0,   TREE_TAG_RIGHT   = 1, };

struct   SBinaryTreeNode
{
        char     cByte   ;
        int      nValue   ;
        bool     bTakeTag   ;

        SBinaryTreeNode *   pParent   ;
        SBinaryTreeNode *   pLeftChild   ;
        SBinaryTreeNode *   pRightChild   ;
};

struct   SByteCoding
{
        char   cByte   ;
        std :: list   < int >   listByteCodes ;
};

//  ===========================================================================================================================
//    仿函数
//  ===========================================================================================================================

struct   SFindByte
{
        SFindByte (   char   byte   ):   cByte (   byte   ) { }
        bool   operator   () (   SBinaryTreeNode *   pNodeInfo   )
     {
             if (   pNodeInfo   &&   pNodeInfo ->   cByte   ==   cByte   )
                 return   true   ;

             return   false   ;
     }
private   :
        char   cByte   ;
};

struct   SFindByteFormCodings
{
        SFindByteFormCodings   (   char   byte   ):   cByte   (   byte   ) { }
        bool   operator   () (   SByteCoding *   pFindByte   )
     {
             if (   pFindByte   &&   pFindByte ->   cByte   ==   cByte   )
                 return   true   ;

             return   false   ;
     }
private   :
        char   cByte   ;
};
//  ===========================================================================================================================
//    仿函数
//  ===========================================================================================================================

int   _tmain (   int   argc   ,   _TCHAR *   argv [])
{

        std :: vector   < SBinaryTreeNode *>   vecBinaryNode ;
        vecBinaryNode . clear   ();
     
        std :: vector   < SBinaryTreeNode *>::   iterator   iVecTreeNode   ;
        char   c   ;
        for (   int   i   = 0;   i   <   nBufferSize   &&   g_szBuffer [   i ] !=   '/0' ; ++ i   )
     {
             c   =   g_szBuffer   [ i ];
             iVecTreeNode   =   std   :: find_if (   vecBinaryNode   . begin (),   vecBinaryNode . end   (),   SFindByte (   c   ) );
             if (   iVecTreeNode   ==   vecBinaryNode .   end () )
          {
                 SBinaryTreeNode *   pBinaryNode   =   new   SBinaryTreeNode   ;
                 if ( ! pBinaryNode   )
              {
                      std :: cout   << "Error 3" <<   std :: endl   ;
                      system (   "pause"   );
                      return   0;
              }

                 pBinaryNode -> pLeftChild     =   NULL ;
                 pBinaryNode -> pRightChild   =   NULL ;
                 pBinaryNode -> pParent        =   NULL ;

                 pBinaryNode -> cByte       =   c ;
                 pBinaryNode -> nValue      = 1;
                 pBinaryNode -> bTakeTag   =   false ;

                 vecBinaryNode . push_back   (   pBinaryNode   );
          }
             else
          {
                 SBinaryTreeNode *   pExistNode   = (* iVecTreeNode   );
                 if ( ! pExistNode   )
              {
                      std :: cout   << "Error 4" <<   std :: endl   ;
                      system (   "pause"   );
                      return   0;
              }

              ++   pExistNode -> nValue   ;
          }
     }

        //   通过 vecBinaryNode    搭建哈夫曼树
        int   nMinValue   ,   nSecMinValue ;
        int   nByteNum   =   vecBinaryNode .   size ();
        for (   int   i   = 1;   i   <=   nByteNum   - 1; ++ i   )    // nSize - 1   次合并两个顶点
     {
             SBinaryTreeNode *   pMinValueNode           =   NULL ;
             SBinaryTreeNode *   pSecondMinValueNode     =   NULL ;
             nMinValue      =   g_nMaxNum   - 1;
             nSecMinValue   =   g_nMaxNum   ;
 
             std :: vector   < SBinaryTreeNode *>::   iterator   iVecBegin   =   vecBinaryNode .   begin ();
             std :: vector   < SBinaryTreeNode *>::   iterator   iVecEnd      =   vecBinaryNode   . end ();
             for ( ;   iVecBegin   !=   iVecEnd ; ++   iVecBegin   )
          {
                 SBinaryTreeNode *   pNowBinary   = (* iVecBegin );
                 if ( ! pNowBinary   )
              {
                      std :: cout   << "Error 5" <<   std :: endl   ;
                      system (   "pause"   );
                      return   0;
              }

                 if (   true   ==   pNowBinary ->   bTakeTag   )
                      continue ;

                 if (   pNowBinary   -> nValue   <   nMinValue   )
              {
                      pSecondMinValueNode   =   pMinValueNode   ;
                      pMinValueNode        =   pNowBinary ;

                      nSecMinValue   =   nMinValue   ;
                      nMinValue     =   pNowBinary ->   nValue ;
              }
                 else   if   (   pNowBinary ->   nValue   >=   nMinValue   &&   pNowBinary   -> nValue   <   nSecMinValue   )
              {
                      pSecondMinValueNode   =   pNowBinary   ;
                      nSecMinValue   =   pNowBinary   -> nValue ;
              }
          }

             if ( ! pMinValueNode   || ! pSecondMinValueNode   )
          {
                 std :: cout   << "Error 6" <<   std :: endl   ;
                 system (   "pause"   );
                 return   0;
          }

             SBinaryTreeNode *   pConnectionNode   =   new   SBinaryTreeNode   ;
             if ( ! pConnectionNode   )
          {
                 std :: cout   << "Error 7" <<   std :: endl   ;
                 system (   "pause"   );
                 return   0;
          }

             pMinValueNode -> bTakeTag   =   true ;
             pMinValueNode -> pParent     =   pConnectionNode ;

             pSecondMinValueNode -> bTakeTag   =   true ;
             pSecondMinValueNode -> pParent     =   pConnectionNode ;

             pConnectionNode -> bTakeTag       =   false ;
             pConnectionNode -> cByte          = 0;
             pConnectionNode -> nValue         =   pMinValueNode   -> nValue   +   pSecondMinValueNode -> nValue   ;
             pConnectionNode -> pLeftChild     =   pMinValueNode ;
             pConnectionNode -> pRightChild   =   pSecondMinValueNode   ;
             pConnectionNode -> pParent        =   NULL ;

             vecBinaryNode . push_back   (   pConnectionNode   );
     }

        //   求哈夫曼树的编码   同时求其跟结点
        std :: vector   < SByteCoding *>   vecByteCoding ;
        vecByteCoding . clear   ();

        SBinaryTreeNode *   pBinaryTreeRoot   =   NULL ;
        std :: vector   < SBinaryTreeNode *>::   iterator   iVecTreeBegin   =   vecBinaryNode .   begin ();
        std :: vector   < SBinaryTreeNode *>::   iterator   iVecTreeEnd      =   vecBinaryNode   . end ();
        for ( ;   iVecTreeBegin   !=   iVecTreeEnd ; ++   iVecTreeBegin   )
     {
             SBinaryTreeNode *   pFindLeafCodes   = (* iVecTreeBegin   );
             if ( ! pFindLeafCodes   )
          {
                 std :: cout   << "Error 8" <<   std :: endl   ;
                 system (   "pause"   );
                 return   0;
          }

             if ( 0 !=   pFindLeafCodes   -> cByte   )
          {
                 SByteCoding *   pByteCoding   =   new   SByteCoding ;
                 if ( ! pByteCoding   )
              {
                      std :: cout   << "Error 9" <<   std :: endl   ;
                      system (   "pause"   );
                      return   0;
              }

                 pByteCoding -> cByte   =   pFindLeafCodes ->   cByte ;
                 pByteCoding -> listByteCodes   . clear ();

                 while (1)
              {
                      if (   pFindLeafCodes   -> pParent   !=   NULL   )
                   {
                           if (   pFindLeafCodes   -> pParent ->   pLeftChild   ==   pFindLeafCodes   )
                                pByteCoding -> listByteCodes   . push_front (   TREE_TAG_LEFT   );
                           else   if   (   pFindLeafCodes   -> pParent ->   pRightChild   ==   pFindLeafCodes   )
                                pByteCoding -> listByteCodes   . push_front (   TREE_TAG_RIGHT   );

                           pFindLeafCodes   =   pFindLeafCodes   -> pParent ;
                   }
                      else
                   {
                           if (   NULL   ==   pBinaryTreeRoot   )
                                pBinaryTreeRoot   =   pFindLeafCodes   ;

                           break ;
                   }
              }

                 vecByteCoding . push_back   (   pByteCoding   );
          }
     }

        //   输出编码格式   std::vector<SByteCoding*> vecByteCoding;
        std :: vector   < SByteCoding *>::   iterator   iVecCodingBegin   =   vecByteCoding   . begin ();
        std :: vector   < SByteCoding *>::   iterator   iVecCodingEnd      =   vecByteCoding   . end ();
        for ( ;   iVecCodingBegin   !=   iVecCodingEnd ; ++ iVecCodingBegin   )
     {
             SByteCoding *   pPrintByteCoding   = (* iVecCodingBegin   );
             if ( ! pPrintByteCoding   )
          {
                 std :: cout   << "Error 10" << std   :: endl ;
                 system (   "pause"   );
                 return   0;
          }

             std :: cout   << " Byte --->" <<   pPrintByteCoding -> cByte   << "  Coding --->" ;
             std :: list   < int >::   iterator   ilistBegin   =   pPrintByteCoding   -> listByteCodes .   begin ();
             std :: list   < int >::   iterator   ilistEnd      =   pPrintByteCoding   -> listByteCodes .   end ();
             for ( ;   ilistBegin   !=   ilistEnd ; ++   ilistBegin   )
                 std :: cout   <<(* ilistBegin );
             std :: cout   << std ::   endl << std   :: endl ;
     }

        //   将 g_szBuffer[nBufferSize]   编码
        //   将编码完的编码串用   list   容器存起来
        std :: list   < int >   listBufferCodes ;
        listBufferCodes . clear   ();
        std :: vector   < SByteCoding *>::   iterator   iVecFindCodes   ;
        for (   int   i   = 0;   i   <   nBufferSize   &&   g_szBuffer [   i ] !=   '\0' ; ++ i   )
     {
             char   cByte   =   g_szBuffer [   i ];    // SFindByteFormCodings
             iVecFindCodes   =   std   :: find_if (   vecByteCoding   . begin (),   vecByteCoding . end   (),   SFindByteFormCodings   (   cByte   ) );
             if (   iVecFindCodes   ==   vecByteCoding .   end () )
          {
                 std :: cout   << "Error 11" << std   :: endl ;
                 system (   "pause"   );
                 return   0;
          }
             std :: list   < int >::   iterator   ilistBegin   = (* iVecFindCodes   )-> listByteCodes .   begin ();
             std :: list   < int >::   iterator   ilistEnd      = (* iVecFindCodes   )-> listByteCodes .   end ();
             for ( ;   ilistBegin   !=   ilistEnd ; ++   ilistBegin   )
                 listBufferCodes . push_back   ( (* ilistBegin ) );
     }

        // PrintCodes( listBufferCodes );
        std :: cout   << g_szBuffer <<   "   编码 : "   ;
        std :: list   < int >::   iterator   ilistPrintCodesBegin   =   listBufferCodes   . begin ();
        std :: list   < int >::   iterator   ilistPrintCodesEnd      =   listBufferCodes   . end ();
        for ( ;   ilistPrintCodesBegin   !=   ilistPrintCodesEnd ; ++ ilistPrintCodesBegin   )
             std :: cout   <<(* ilistPrintCodesBegin );
        std :: cout   << std ::   endl ;
     
        //   解码
        std :: vector   < char >   vecDecodeStr ;
        vecDecodeStr . clear   ();

        ilistPrintCodesBegin   =   listBufferCodes .   begin ();
        ilistPrintCodesEnd    =   listBufferCodes   . end ();
        SBinaryTreeNode *   pFindNode   =   pBinaryTreeRoot ;
        for ( ;   ilistPrintCodesBegin   !=   ilistPrintCodesEnd ; ++ ilistPrintCodesBegin   )
     {
             int   nTag   = (* ilistPrintCodesBegin );

             if (   TREE_TAG_LEFT   ==   nTag   )
          {
                 pFindNode   =   pFindNode   -> pLeftChild ;
          }
             else
                 pFindNode   =   pFindNode   -> pRightChild ;

             if (   pFindNode   -> cByte   != 0 )
          {
                 char   cNewByte   =   pFindNode ->   cByte ;
              
                 vecDecodeStr . push_back   (   cNewByte   );
                 pFindNode   =   pBinaryTreeRoot   ;
          }
     }

        //   输出解码
        std :: cout   << std ::   endl << "   解码   : " ;
        std :: vector   < char >::   iterator   iVecCharBegin   =   vecDecodeStr   . begin ();
        std :: vector   < char >::   iterator   iVecCharEnd      =   vecDecodeStr   . end ();
        for ( ;   iVecCharBegin   !=   iVecCharEnd ; ++   iVecCharBegin   )
             std :: cout   <<(* iVecCharBegin );
        std :: cout   << std ::   endl ;

        system ( "pause"   );
        return   0;
}
郑祖煌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼编/译码系统的设计与实现
SCaryon的博客
06-22 1万+
问题描述利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。基本要求 初始化（Initialzation）。从数据文件DataFile.data中读入字符及每个
设计哈夫曼树编码
焦玉丽
09-04 8159
通过一个小例题来总结一下哈夫曼树的知识点： 问题：设某通讯系统中一个待传输的文本有六个不同的字符，他们的出现频率分别是0.5,0.8,1.4,2.2,2.3,2.8式设计哈夫曼编码。 如何构造哈夫曼树： 第一步：将这些频率看做权值，每个都看作是一棵树（这棵树只有一个叶子，既是叶子也是根）。 第二步：选出最小的两棵树，合并成一棵新的二叉树。（这时的元素个数变为n-1,去掉
哈夫曼编码（Huffman Code）的设计与实现
10-27
二叉树实现哈夫曼编码，功能模块：初始化、编码、译码、打印。VC++6.0环境，windows console application.
简单哈夫曼 编/译码系统的设计与实现
Feynman1999的博客
06-21 4187
问题描述 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。 基本要求 （1）初始化（Initialzation）。从数据文件DataFile
哈夫曼编码 算法设计与分析
最新发布
yuluo_liuli的博客
04-04 283
哈夫曼编码算法的时间复杂度主要取决于构建哈夫曼树的过程，即统计字符频率和构建优先队列，并不会超过O(nlogn)，n为输入文本的长度。另外，由于哈夫曼编码的贪心特性，虽然过程中可能会存在多种编码结果，但是这些编码都能够满足哈夫曼编码的基本要求。哈夫曼编码的主要目标是通过将出现频率高的字符赋予较短的编码，出现频率低的字符赋予较长的编码，以达到数据压缩的目的。因此，哈夫曼编码的关键在于通过构建哈夫曼树，将字符集中每个字符的频率映射到唯一的二进制编码上。- 遍历输入文本，统计每个字符出现的频率。
哈夫曼编/译码系统的简单设计与实现
06-21
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。该代码设计一个哈夫曼编译码系统： （1）初始化（Initialzation）。从数据文件DataFile.data中读入字符及每个字符的权值，建立哈夫曼树HuffTree； （2）编码（EnCoding）。用已建好的哈夫曼树，对文件ToBeTran.data中的文本进行编码形成报文，将报文写在文件Code.txt中； （3）译码（Decoding）。利用已建好的哈夫曼树，对文件CodeFile.data中的代码进行解码形成原文，结果存入文件Textfile.txt中； （4）输出（Output）。输出DataFile.data中出现的字符以及各字符出现的频度（或概率）；输出ToBeTran.data及其报文Code.txt；输出CodeFile.data及其原文Textfile.txt；
C++实现哈夫曼编码
08-19
C++实现哈夫曼编码 哈夫曼编码是一种变长编码方式，它可以根据符号的出现频率来调整编码的长度，以达到压缩数据的目的。哈夫曼编码的实现可以使用树形结构来表示符号的编码关系。 在C++实现哈夫曼编码中，我们首先...
哈夫曼编码算法实现
12-21
哈夫曼编码算法实现 哈夫曼编码是一种变长编码技术，用于压缩数据，提高信道的利用率，缩短信息传输的时间，降低传输成本。哈夫曼编码的原理是根据字符出现的频率，建立哈夫曼树，然后对各个字符进行哈夫曼编码。 ...
山东科技大学算法设计与分析实验5：实现哈夫曼编码 源.cpp+报告
07-20
全都是自己写的，都能跑出来 实打实写的哦~ 仅供参考 最重要的还是自己理解 1.实现哈夫曼编码的贪心算法。 2.学会分析哈夫曼编码的算法复杂性。 预览地址：
基于C++文件的哈夫曼编码与解码.zip
06-21
本人的小工具仅针对英文大小字母及 ' '\n' ' ' 字符针对性的进行了哈夫曼编码，若想实现中文及各种支持语言的编码，可在此代码基础上，进行优化。 详细介绍参考：...
哈夫曼编码译码设计与实现.pdf
10-30
《哈夫曼编码译码设计与实现》是关于数据结构课程设计的一份报告，主要探讨了如何设计和实现哈夫曼编码和译码的过程。哈夫曼编码是一种基于频率优化的前缀编码方法，常用于数据压缩，尤其在文本、图像和音频的压缩中...
哈夫曼编码的演示系统设计
01-18
图形化绘制huffman码树的MATLAB的程序。特色是一步一步绘制。这其实是我的课程设计。由于时间仓促，编码风格比较怪，读程序的人可能会觉得比较痛苦吧。设计报告中的流程图画得也不是很规范。不过有一点必须指出来：互联网上像课件一样关于逐步分解huffman码树绘制的程序几乎没有。 NOTE: 如果您想要引用本程序代买及设计报告中的文字和图表，请您务必声明出处！ 压缩包包括： MATLAB程序 设计报告
哈夫曼编码/译码实现
11-14
建立一个文本文件，统计该文件中各字符频率，对各字符进行Huffman编码，将该文件翻译成Huffman编码文件，再将Huffman编码文件翻译成原文件。压缩文件即读文件，统计文件中的字符个数，对文件进行哈夫曼编码和译码，并将编码译码后的字符存储在文件中。 完成功能的详细说明： 1．统计文本文件中各字符的频率（涉及读文件，统计字符个数）； 2．对文件中的内容进行哈夫曼编码并存储入文件（涉及到创建哈夫曼树，进行哈夫曼编码和写文件）； 3．对编码文件进行译码（涉及到哈夫曼译码和写文件）。 4．输出要求：输出原文、译文、打印编码规则、打印哈夫曼树。 5．哈夫曼树构造时，要求左孩子的值比右孩子的值小
哈夫曼编码系统（C语言实现）
07-01
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个基于哈夫曼编码的通信系统。 系统应具有以下功能： 1）初始化处理：建立通信系统 2）发送端信息编码 3）接受端信息译码
哈夫曼树及其编码(数据结构课程设计),
09-11
哈夫曼树及其编码(数据结构课程设计),已经调试过了
二叉树的基本操作及哈夫曼编码译码系统的实现
05-23
一、实验目的和要求 目的：1、掌握二叉链表上实现二叉树基本操作。 2、学会设计基于遍历的求解二叉树应用问题的递归算法。 3、理解哈夫曼树的构造算法，学习设计哈夫曼编码和译码系统 要求：能成功演示二叉树的有关算法，运算完毕后能成功释放二叉树所有结点占用的系统类存。
Huffman编码的设计与实现
qq_43573663的博客
03-27 4775
（一）设计描述 1.题目描述 设计一个利用哈夫曼算法的编码和译码系统，重复地显示并处理以下项目，直到选择退出为止。 1) 输入一串字符，然后统计其中各个字符的个数,即每个字符的权值。 2) 进行初始化操作,并建立哈夫曼树； 3) 编码：利用建好的哈夫曼树生成哈夫曼编码，并输出编码； 4) 译码，即输入每个字符对应的二进制的编码（0或1），然后输出对应的字符。 5) 结束操作。 2.设计目的......
数据结构：哈夫曼编码基本操作演示程序的设计与实现
m0_63464778的博客
01-01 567
内容如下： 1.编写构造Huffman树的函数，以及相关的Select函数（选择两个权值最小的序号）和输出Huffman树的函数。 2、现有文本“HUFFMAN”，请统计每个字符出现的次数，以次数为权值构造Huffman树并输出。 3、根据输出情况，绘制Huffman树的逻辑结构图（即结点-连线图）。 4、根据结点-连线图，列出每个字符的Huffman编码。 5、计算Huffman树的WPL。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值