Huffman编码译码算法的C++实现

最新推荐文章于 2021-12-21 14:18:48 发布
最新推荐文章于 2021-12-21 14:18:48 发布
阅读量256 收藏
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/zmjerry/blog/6115
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

头文件：

 

/*****************************************************************************
 *                               huffmancode.h
 *
 * Huffman coding algorighm implemented by C++ template.
 *
 * This class is designed for Huffman codeing and decoding algorighm. The
 * priority queue is used in building Huffman tree. For comparing pointers
 * of Huffman Tree Node by their pointing contents, I use the smart pointer
 * replacing nomal pointer. And for saving memory, the coded word is stored
 * bit-by-bit in an unsigned char array.
 *
 * Zhang Ming, 20010-07, Xi'an Jiaotong University.
 *****************************************************************************/


#ifndef HUFFMANCODE_H
#define HUFFMANCODE_H


#include <iostream>
#include <binaryheap.h>


using namespace std;


namespace itlab
{

    /**
     * Object node to be coded
     */
    template <typename Object, typename Weight>
    struct CodeObject
    {
        Object data;
        Weight cost;
    };
    // struct CodeObject


    /**
     * Huffman codeword node
     */
    const int CODESIZE = 2;
    template <typename Object>
    struct HCNode
    {
        Object data;
        unsigned char bits[CODESIZE];
        unsigned int length;
    };
    // struct HCNode


    /**
     * Huffman tree node
     */
    template <typename Object, typename Weight>
    struct HTNode
    {
        Object data;
        Weight cost;
        HTNode<Object,Weight> *left,
                              *right;

        HTNode() : data(Object()), cost(Weight(0)), left(NULL), right(NULL)
        { }
        HTNode( const Object &x, const Weight w,
                HTNode<Object,Weight> *lp=NULL, HTNode<Object,Weight> *rp=NULL )
        {   data = x; cost = w; left = lp; right = rp;    }

        operator Weight() const
        {   return cost;    }

    };
    // struct HTNode


    /**
     * Smart pointer for Huffman tree bode
     */
    template <typename Object, typename Weight>
    class HTNSmartPtr
    {

    public:

        HTNSmartPtr( HTNode<Object,Weight> *p = NULL )
        {   ptr = p;    }

        HTNode<Object,Weight> operator*()
        {   return *ptr;    }
        HTNode<Object,Weight>* operator->()
        {   return ptr;    }

        operator HTNode<Object,Weight> *()
        {   return ptr;    }
        bool operator<( HTNSmartPtr<Object,Weight> p )
        {   return ptr->cost < p->cost;    }
        bool operator>( HTNSmartPtr<Object,Weight> p )
        {   return ptr->cost > p->cost;    }

    private:

        HTNode<Object,Weight> *ptr;

    };
    // class HTNSmartPtr


    /**
     * Huffman tree
     */
    template <typename Object, typename Weight>
    class HuffmanTree
    {

    public:

        HuffmanTree();
        ~HuffmanTree();

//        HuffmanTree( const HuffmanTree &rhs );
//        HuffmanTree & operator=( const HuffmanTree &rhs );

        void code( CodeObject<Object,Weight> *codeArray, int length );
        bool decode( unsigned char bits[CODESIZE], unsigned int length, Object &decodeword );
        void printCode( unsigned char bits[CODESIZE], unsigned int length );
        void printCodeTable();

    private:

        HTNSmartPtr<Object,Weight> root;
        int arraySize;
        HCNode<Object> *codeTable;

        void createHuffmanTree( CodeObject<Object,Weight> *codeArray );
        void createCodeTable();
        void createCodeTableRecursive( HTNSmartPtr<Object,Weight> ht,
                                       unsigned char *code, int pos, int &index );

        void setBit( unsigned char *bits, unsigned int pos, unsigned int state );
        unsigned int getBit( unsigned char *codeword, unsigned int pos );

        void destroy( HTNode<Object,Weight> *&r );

    };
    // class HuffmanTree


    #include "huffmancode-impl.h"

}
// namespace itlab


#endif
// HUFFMANCODE_H

 

实现文件：

 

/*****************************************************************************
 *                             huffmancode-impl.h
 *
 * Implementation for Huffman code.
 *
 * Zhang Ming, 2010-07
 *****************************************************************************/


/**
 * constructors and destructor
 */
template <typename Object, typename Weight>
HuffmanTree<Object,Weight>::HuffmanTree() : root(NULL)
{
    arraySize = 0;
    codeTable = NULL;
}

template <typename Object, typename Weight>
HuffmanTree<Object,Weight>::~HuffmanTree()
{
    HTNode<Object,Weight> *r = root;
    destroy(r);
    root = NULL;
    delete []codeTable;
}


/**
 * Huffman codeing.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::code( CodeObject<Object,Weight> *codeArray, int length )
{
    arraySize = length;

    if( codeTable != NULL )
        delete []codeTable;
    codeTable = new HCNode<Object>[arraySize];

    createHuffmanTree( codeArray );
    createCodeTable();
}


/**
 * If decodeing successful return ture, else return false;
 */
template <typename Object, typename Weight>
bool HuffmanTree<Object,Weight>::decode( unsigned char codeword[CODESIZE], unsigned int length,
                                         Object &decodeword )
{
    unsigned int pos = 0;
    HTNSmartPtr<Object,Weight> p = root;
    for( pos=0; pos<length; ++pos )
        if( p != NULL )
        {
            if( getBit( codeword, pos ) == 0 )
                p = p->left;
            else
                p = p->right;
        }
        else
            break;

    if( pos == length && p != NULL && p->left == NULL && p->right == NULL  )
    {
        decodeword = p->data;
        return true;
    }

    else
        return false;
}


/**
 * Print the codedword.
 */
template <typename Object, typename Weight>
inline void HuffmanTree<Object,Weight>::printCode( unsigned char codewrod[CODESIZE], unsigned int length )
{
    for( unsigned int j=0; j<length; ++j )
        cout << getBit( codewrod, j );
}


/**
 * Print the coded table.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::printCodeTable()
{
	cout << "Object\tCode\tSize" << endl;
	for( int i=0; i<arraySize; ++i )
    {
        cout << codeTable[i].data  << "\t";
        printCode( codeTable[i].bits, codeTable[i].length );
        cout << "\t" << codeTable[i].length << endl;
    }
	cout << endl;
}


/**
 * Create the Huffman tree.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::createHuffmanTree( CodeObject<Object,Weight> *codeArray )
{
    BinaryHeap<HTNSmartPtr<Object,Weight> > heap( arraySize );
    HTNSmartPtr<Object,Weight>  tree = NULL,
                                subtreeL = NULL,
                                subtreeR = NULL;

    for( int i=0; i<arraySize; ++i )
    {
        tree = new HTNode<Object,Weight>( codeArray[i].data, codeArray[i].cost, NULL, NULL );
        heap.insert( tree );
    }

    while( heap.size() > 1 )
    {
        heap.deleteMin( subtreeL );
        heap.deleteMin( subtreeR );
        tree = new HTNode<Object,Weight>( Object(), subtreeL->cost+subtreeR->cost, subtreeL, subtreeR );
        heap.insert( tree );
    }
    heap.deleteMin( root );
}


/**
 * Create the coded character table.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::createCodeTable()
{
    for( int i=0; i<arraySize; ++i )
    {
        codeTable[i].data = Object();
        codeTable[i].length = 0;
    }

    unsigned char code[CODESIZE];
    int index = 0;
    createCodeTableRecursive( root, code, 0, index );
}


/**
 * Create the coded character table.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::createCodeTableRecursive( HTNSmartPtr<Object,Weight> ht,
                                                           unsigned char *code, int pos, int &index )
{
    if( ht->left )
    {
        setBit( code, pos, 0 );
        createCodeTableRecursive( ht->left, code, pos+1, index );
    }

    if( ht->right )
    {
        setBit( code, pos, 1 );
        createCodeTableRecursive( ht->right, code, pos+1, index );
    }

    if( ht->left==NULL && ht->right==NULL )
    {
        codeTable[index].data = ht->data;
        for( int i=0; i<CODESIZE; ++i )
            codeTable[index].bits[i] = code[i];
        codeTable[index].length = pos;
        index++;
    }
}


/**
 * Set the bit at position pos in the array bits to the value state.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::setBit( unsigned char *bits, unsigned int pos, unsigned int state )
{
	unsigned char mask = 0x80;
	for( unsigned int i=0; i<(pos % 8); ++i )
		mask = mask >> 1;

	if( state == 1 )
		bits[pos/8] = bits[pos/8] | mask;
	else if( state == 0 )
		bits[pos/8] = bits[pos/8] & (~mask);
    else
        cerr << endl << "The bit to be set should be '1' or '0'!" << endl;

	return;
}


/**
 * Get the state of the bit at position pos in the array bits.
 */
template <typename Object, typename Weight>
unsigned int HuffmanTree<Object,Weight>::getBit( unsigned char *bits, unsigned int pos )
{
	unsigned char mask = 0x80;
	for( unsigned int i=0; i<(pos%8); ++i )
		mask = mask >> 1;

	return ( ((mask & bits[(int)(pos/8)]) == mask) ? 1 : 0 );
}


/**
 * Destroy the tree.
 */
template <typename Object, typename Weight>
void HuffmanTree<Object,Weight>::destroy( HTNode<Object,Weight> *&r )
{
    if( r != NULL )
    {
        destroy( r->left );
        destroy( r->right );
        delete r;
    }
    r = NULL;
}

 

测试文件：

 

/*****************************************************************************
 *                              huffmancode_test.cpp
 *
 * Huffman Code class testing.
 *
 * Zhang Ming, 2010-07
 *****************************************************************************/


#include <iostream>
#include <string>
#include "huffmancode.h"


using namespace std;
using namespace itlab;


const int CHARNUM = 128;
template <typename Object, typename Weight>
void creatCodeInfo( string &str, CodeObject<Object,Weight> *&codeArr, int &length );
template <typename Object, typename Weight>
void printCodeInfo( CodeObject<Object,Weight> *&codeArr, int length );


int main()
{
    int length = 0;
    CodeObject<char, int> *codeArr = NULL;
    string str = "AAAABBCD";
    creatCodeInfo( str, codeArr, length );
    printCodeInfo( codeArr, length );

    HuffmanTree<char, int> ht;
    ht.code( codeArr, length );
    ht.printCodeTable();

    char decodedResult;
    unsigned char codeword[CODESIZE];
    cout << "Coding\t" << "Decodedwrod" << endl;
    codeword[0] = 0xC0;
    if( ht.decode( codeword, 3, decodedResult ) )
    {
        ht.printCode( codeword, 3 );
        cout << "\t" << decodedResult << endl;
    }
    else
        cerr << "invalid codeword! " << endl;
    codeword[0] = 0xC0;
    if( ht.decode( codeword, 4, decodedResult ) )
    {
        ht.printCode( codeword, 3 );
        cout << "\t" << decodedResult << endl;
    }
    else
    {
        ht.printCode( codeword, 4 );
        cerr << "\t" << "invalid codeword! " << endl;
    }
    codeword[0] = 0x40;
    if( ht.decode( codeword, 3, decodedResult ) )
    {
        ht.printCode( codeword, 3 );
        cout << "\t" << decodedResult << endl;
    }
    else
    {
        ht.printCode( codeword, 3 );
        cerr << "\t" << "invalid codeword! " << endl;
    }

    cout << endl;
    return 0;
}


/**
 * Generate the array for counting character frequency.
 */
template <typename Object, typename Weight>
void creatCodeInfo( string &str, CodeObject<Object,Weight> *&codeArr, int &length )
{
    char charFreq[CHARNUM];
    int index[CHARNUM];
    for( int i=0; i<CHARNUM; ++i )
    {
        charFreq[i] = 0;
        index[i] = -1;
    }

    length = 0;
    for( unsigned int i=0; i<str.size(); ++i )
        charFreq[int(str[i])] += 1;

    for( int i=0; i<CHARNUM; ++i )
        if( charFreq[i] )
            index[length++] = i;


    codeArr = new CodeObject<Object,Weight>[length];
    for( int i=0; i<length; ++i )
    {
        codeArr[i].data = index[i];
        codeArr[i].cost = charFreq[index[i]];
    }
}


/**
 * Print the characters and there frequency.
 */
template <typename Object, typename Weight>
void printCodeInfo( CodeObject<Object,Weight> *&codeArr, int length )
{
    cout << "Object\tCode" << endl;
    for( int i=0; i<length; ++i )
        cout << codeArr[i].data << "\t" << codeArr[i].cost << endl;
    cout << endl;
}

 

转载于:https://my.oschina.net/zmjerry/blog/6115

njit_peiyuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——Huffman编码及译码
codes_first的博客
10-23 5108
Huffman编码及译码 1．掌握二叉树的二叉链表存贮结构。 2．掌握Huffman算法。   要求： 使用文件保存初始的文本数据及最终的结果。 文件名为inputfile1.txt的文件保存的是一段英文短文； 文件名为inputfile2.txt的文件保存01形式的编码段； 文件名为outputfile1.txt的文件保存各字符的出现次数和对应的编码； 文件名为outputfi...
数据结构（C语言）-哈夫曼（Huffman）树编码译码操作
qq_44025638的博客
11-17 1万+
huffman树的编码和译码操作
Huffman树及Huffman编码，译码的算法实现
Wood_Du的博客
05-18 1万+
参考：https://blog.csdn.net/curson_/article/details/53771386 本来以为这个实验一会儿就可以搓出来，最后跟着要求搓了几个小时，菜是原罪，菜是真的菜，（助教小姐姐很好） 要求： 1、输入一段100—200字的英文短文，存入一文件a中。 2、写函数统计短文出现的字母个数n及每个字母的出现次数 3、写函数以字母出现次数作权值，建Haffman...
实验六 Huffman树及Huffman编码的算法实现
m0_51308557的博客
12-21 5714
输入一段100—200字的英文短文，存入一文件a中。写函数统计短文出现的字母个数n及每个字母的出现次数写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffman编码。用每个字母编码对原短文进行编码，码文存入文件b中。用Haffman树对文件b中码文进行译码，结果存入文件c中，比较a,c是否一致，以检验编码、译码的正确性。
哈夫曼树编码与译码(完整C/C++实现代码)
菜鸡逆袭的博客
07-02 3万+
哈夫曼编码的设计与应用 问题需求分析 用哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码(有时也称为霍夫曼编码)。 霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树...
huffman_tree_code.rar_Huffman编码_Huffman编码译码_huffman_huffman-tree
09-23
在提供的压缩文件中，`huffman.cpp`可能是一个C++程序，实现了Huffman编码和译码的过程。而`www.pudn.com.txt`可能是用来测试编码和解码功能的文本文件。通过运行`huffman.cpp`，我们可以对`www.pudn.com.txt`进行...
解析C++哈夫曼树编码和译码的实现
09-01
哈夫曼树是一种特殊的二叉树，用于...总的来说，哈夫曼树编码和译码是数据压缩中的基本技术，通过C++实现能够理解和应用这一概念，有助于提升对数据结构和算法的理解，同时在实际项目中也可以用它来提高数据传输效率。
哈弗曼编码译码(C++实现).pdf
10-30
哈弗曼编码是一种高效的数据压缩方法，主要用于通信和数据...总之，哈弗曼编码和译码的C++实现涉及到数据结构、算法和用户界面设计等多个方面，是计算机科学基础课程中的一个重要实践项目，有助于提升学生的综合能力。
Huffman编码译码实现
01-11
哈夫曼编码是一种高效的数据压缩方法，它基于一种特殊的二叉树——哈夫曼树（Huffman Tree），也称为最优二叉树。这种编码方式利用字符出现频率来构造树形结构，使得频率高的字符拥有较短的编码，而频率低的字符则...
huffman编码（c++源码）
10-21
哈夫曼编码（Huffman Coding）是一种用于无损数据压缩的高效算法，它基于字符的频率构建一棵特殊的二叉树——哈夫曼树。在哈夫曼树中，出现频率高的字符路径较短，而出现频率低的字符路径较长，以此达到数据编码的...
数控G代码C++译码源程序
03-03
这是一个很有用的数控系统运动控制译码程序，对于运动控制开发工程师很有参考价值。
c++实现唯一可译码
01-08
c++实现唯一可译码，信息论与编码，信息安全实习
哈夫曼树的构造、编码、译码实现
03-30
采用三叉链表结构：每个节点包含左右孩子指针和父指针。构造函数中，每次选取权值最小的两个根节点，构成新的节点。 每个符号的Huffman编码用0\1串。编码算法实现了给定节点实现它的0\1串,译码算法实现给定0\1串找出该节点
C/C++ 哈夫曼树的构造、编码以及译码
热门推荐
机器学习
01-05 4万+
题目：假设用于通信的电文由字符集{a,b,c,d,e,f,g,h}中的字母构成，这8个字母在电文中出现的 频率分别为： {0.19, 0.21, 0.02, 0.03, 0.06, 0.07, 0.1, 0.32}. 要求：画出哈夫曼树。哈夫曼树的构造 哈夫曼编码及译码的实现 我从课本上面摘抄了一个题目，题目大概是上面这样的，我们这里只是详细的说明一下哈弗曼树要怎么构建。借用一下这个题目。哈夫曼
C++实现哈夫曼编码/译码器（数据结构）
Lei Gong's blog
01-19 9178
设计一个哈夫曼编码、译码系统。对一个ASCII编码的文本文件中的字符进行哈夫曼编码，生成编码文件；反过来，可将编码文件译码还原为一个文本文件。 （1） 从文件中读入任意一篇英文短文（文件为ASCII编码，扩展名为txt）； （2） 统计并输出不同字符在文章中出现的频率（空格、换行、标点等也按字符处理）； （3） 根据字符频率构造哈夫曼树，并给出每个字符的哈夫曼编码； （4） 图形化输出哈夫曼树、哈...
哈夫曼编码和译码&&c++重点知识的应用
changke的博客
11-24 1103
又是一个摸鱼天，啥都没学就写了个哈夫曼编码和译码。将以前学的c++相关知识系统的用了一遍，反正是能想到啥，啥方便就用啥，但是说回来，也没省多少事。反正比用c语言写跟简单一点。 先看题目原型吧！ 假设某通信报文的字符集由A,B,C,D,E,F这6个字符组成，它们在报文中出现的频度（频度均为整数值）。 (1)构造一棵哈弗曼树，依次给出各字符编码结果。 (2)给字符串进行编码。 (3)给编码串进行译码。...
哈夫曼树的实现，编码以及译码
摆烂的小趴菜
10-24 1674
2. 编程实现如下功能： （1）建立由英文字符组成的文件f1（字符种类≥10，长度≥100），并统计不同字符出现的次数； （2）按字符出现的次数对其建立哈夫曼树，并求出各个字符的哈夫曼编码； （3）读入要编码的文件f1，编码后存入另一个文件f2； （4）接着再调出编码后的文件f2，对其进行译码输出，最后存入文件f3。 #include<iostream> #include<fstream> #include<cstring> using namespace s
C++实现Huffman的编解码
酒
04-25 3271
Huffman用C++进行编解码的实现
实例图解哈夫曼树编码-解码及实现（c++）
努力做个书呆儿
01-15 1万+
hello everybody!你们机智大气的阿俊又回来了，最近事比较多，闲话少说，直接切入正题，聊聊如何给一篇全为英文字符的文章利用哈夫曼编码得到每个字符的最优编码，并完成解码功能，注意，这次也是用文件操作哟，今天可被二进制文件折磨惨了，不过搞懂后真好用，呜呜呜，我该不会是个受虐狂叭。。。 需求分析 嘿嘿嘿，不瞒你说，这是我课设的题目 注意一下，测试数据一定是所有的字符一定是要英文输入法能...
huffman树编码译码c++
最新发布
09-04
Huffman树编码和译码是一种常用的数据压缩算法。Huffman树是一种特殊的二叉树，它通过统计字符出现的频率来构建树结构。频率较高的字符在树中的路径较短，而频率较低的字符则路径较长。 Huffman树编码先根据字符出现的频率构建Huffman树，然后通过遍历树来得到字符的编码。编码是树中从根节点到叶节点的路径表示的，节点的左边路径表示0，右边路径表示1。编码的长度取决于字符在树中的位置。 Huffman树译码是根据编码和Huffman树来还原原始的字符序列。从根节点开始，根据编码的位依次向左或向右遍历树，直到找到叶节点，即对应一个字符。然后将该字符记录下来，继续遍历下一个编码。最后，将记录下的字符重新排列，即可得到原始的字符序列。 Huffman树编码和译码可以实现数据的无损压缩和解压缩。它可以通过统计字符出现的频率来建立对应的编码表，将较频繁出现的字符用较短的编码表示，而较不频繁出现的字符用较长的编码表示。这样可以有效地减少数据的存储空间和传输速度。同时，Huffman树编码和译码也是一种前缀编码，即任何一个字符的编码都不是另一个字符编码的前缀，保证了译码的唯一性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值