【模板类、堆 实现Huffman树并对文件编码与解码】

最新推荐文章于 2022-11-30 16:07:30 发布
最新推荐文章于 2022-11-30 16:07:30 发布
阅读量403 收藏 2
点赞数 2
文章标签： 算法 数据结构 huffman tree cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzzzzyie/article/details/121420509
版权

目录

Huffman树的简单介绍

  • Huffman树是根据元素的权重建立的，权重较小的离根结点较远，而权重较大的离根结点较近，从而使得整个Huffman树有着最小的带权路径长度。

  • 比如一篇文章，里面有不同的字符，不同的字符出现的频率是不尽相同的，Huffman树的元素就是这个字符，而它出现的频率就是他的权重。

下面是创建它的简单过程示意图：

项目CDEKLMUZ
频率324212074224372

先将他整理为升序

项目ZKMCUDLE
频率272432374242120

请添加图片描述重复上述步骤若干次后
请添加图片描述
这样就能得到一颗Huffman树了，接下来我们看看他的实现

利用基类定义叶子节点和非叶子节点

  • 因为叶子节点和非叶子节点包含的信息不同，所以我们实现 包括了一个抽象基类HuffNode 和两个子类 LeafNode、Intlnode。
#ifndef HUFFMAN
#define HUFFMAN
#include<bits/stdc++.h>
using namespace std;

template<class E>
class HuffNode {
public:
    virtual ~HuffNode(){}     //Base destructor
    virtual int weight() = 0;   //Return frequency
    virtual bool isLeaf() = 0;  //Determine type
    virtual HuffNode<E>* left() {}  //return leftchild
    virtual HuffNode<E>* right() {} //return rightchild
    virtual E val() {}      //return value
    virtual string getCode(){}  // return Huffcode
    virtual void setCode(string code){}  //set Huffcode
};


template<class E>
class LeafNode : public HuffNode<E> {
private:
    E it;
    int wgt;
    string code;
public:
    LeafNode( E val,int freq){
        it = val; wgt = freq;;
    }
    ~LeafNode(){}

    int weight() {return wgt;}

    E val () {return it;}

    void setCode(string code){
        this->code = code;
    }

    string getCode() {return code;}

    bool isLeaf() {return true;}  //is leaf
};


template<class E>
class IntlNode : public HuffNode<E> {
private:
    HuffNode<E>* lc;   //Left Child
    HuffNode<E>* rc;   //Right Child
    int wgt;
public:
    IntlNode(HuffNode<E>* l, HuffNode<E>* r){
        wgt = l->weight()+r->weight(); lc = l ; rc = r;
    }
    ~IntlNode(){};

    int weight() {return wgt;}

    bool isLeaf() {return false;}  //not leaf

    HuffNode<E>* left()  {return lc;}

    void setLeft(HuffNode<E>* b){
        lc = (HuffNode<E>*) b;
    }

    HuffNode<E>* right()  {return rc;}

    void setRight(HuffNode<E>* b){
        rc = (HuffNode<E>*) b;
    }
};

template<class E>
class HuffTree{
private:
    HuffNode<E>* Root;
public:
    HuffTree(E val, int freq){   //叶节点的构造
        Root = new LeafNode<E>(val,freq);
    }

    HuffTree(HuffTree<E>* l, HuffTree<E>* r){    //非叶节点的构造
        Root = new IntlNode<E>(l->root(), r->root());
    }
    ~HuffTree(){}
    HuffNode<E>* root() {return Root;}
};
#endif

堆的建立

  • 实现Huffman 节点的定义后，我们就要想 通过何种方式去实现它。
  • 通过原理图发现，都是取权重最小的两个元素 将它们连接之后，再按升序放进这个序列中，在重复此步骤 直到这个序列仅剩一个元素。
  • 由此我们联想到 利用小根堆来简化这些步骤
  • 这里就不介绍堆的相关知识，不懂的可以自己先了解一下
#ifndef HEAP_H
#define HEAP_H
using namespace std;

template<class E,class Comp>  //这里的Comp是实现大根堆小根堆比较规则的类
class heap {
private:
    E* Heap;    //用来存HuffTree节点
    int maxsize;
    int n;

    void siftdown(int pos){  //置为小根堆
        while(! isLeaf(pos)) {
            int j = leftchild(pos); 
            int rc = rightchild(pos);
            if ( (rc < n) && Comp::prior(Heap[rc],Heap[j]))  //找到儿子节点更小的位置
                j = rc;
            if (Comp::prior(Heap[pos], Heap[j])) return;  //如果父亲节点更小，直接返回
            swap(Heap, pos,j);  //否则调换位置
            pos =  j;
        }
    }
public:
    heap(E* h, int num, int max){
        Heap = h ; n = num ; maxsize = max ; buildHeap();
    }
    void buildHeap(){
        for (int i = n/2-1 ;i >=0 ; i-- ) siftdown(i);  
    }
    int isLeaf(int pos) const {
        return ((pos >= n/2) && (pos < n ));
    }

    int leftchild(int pos)const  {
        return 2*pos +1;
    }
    int rightchild(int pos) const {
        return 2*pos +2;
    }
    int parent(int pos) const {
        return (pos-1)/2;
    } 
    int size() const {
        return n;
    }
    E removefirst(){
        if( n > 0){
            swap(Heap,0,--n);  //要remove最小的，先把首尾交换位置，再把这个数siftdown合适的位置
            if ( n!=0 ) siftdown(0);
            return Heap[n];   //把最小的那个元素return 出来
        } 
    }

    void insert(const E it){
        if ( n < maxsize ){
            int curr = n++;
            Heap[curr] = it;   //先把这个元素插入到堆的尾部
            while (( curr != 0) && (Comp::prior(Heap[curr],Heap[parent(curr)]))){  
            		//判断是否满足调整的条件
                swap(Heap, curr , parent(curr));
                curr = parent(curr);
            }
        }  
    }
    void swap(E* Heap, int i, int j){ //交换两个元素
        E temp = Heap[i];
        Heap[i] = Heap[j];
        Heap[j] = temp;
    }
};

#endif
  • 下面是Comp的实现类
#ifndef COMP_H
#define COMP_H

#include "HuffNode.h"

class minTreeComp{
public:
    template<class E>
    static bool prior( HuffTree<E>* a, HuffTree<E>* b){
        return a->root()->weight() < b->root()->weight();  //小根堆
    }
};

#endif

Huffman树的创建

  • Huffman节点 和 堆 都定义好了之后， 我们就可以开始创建Huffman树了
template<class E>
HuffTree<E>* bulidHuff(HuffTree<E>* *TreeArray, int count ){
//传入的是节点数组和它的长度
    heap<HuffTree<E>*,minTreeComp>* forest = new heap<HuffTree<E>*,minTreeComp>(TreeArray,count,count);
//这里生成元素是Hufftree的小根堆
    HuffTree<E> *temp1, *temp2, *temp3 = NULL;
    while (forest->size() > 1) {
        temp1 = forest->removefirst();
        temp2 = forest->removefirst();  //取出两个最小的叶节点
        temp3 = new HuffTree<E>(temp1, temp2);  //合成一棵树
        forest->insert(temp3);  
        delete temp1;
        delete temp2;
    }
    return temp3;
};
  • 下面做一个简单的检验：用前序遍历遍历出这棵树的元素和权重
template<class E>
void preOrder(HuffNode<E>* root){
    if (root->isLeaf()){
        cout << root->val()<<"--"<< root->weight()<<"--"<<endl; 
        return;
    } else cout << root->weight()<<endl;
    preOrder(root->left());
    preOrder(root->right());
}
int main() {
    HuffTree<char>* * TreeArray = new HuffTree<char>* [8];

    TreeArray[0] = new HuffTree<char>('C',32); 
    TreeArray[1] = new HuffTree<char>('D',42);
    TreeArray[2] = new HuffTree<char>('E',120);
    TreeArray[3] = new HuffTree<char>('K',7);
    TreeArray[4] = new HuffTree<char>('L',42);
    TreeArray[5] = new HuffTree<char>('M',24);
    TreeArray[6] = new HuffTree<char>('U',37);
    TreeArray[7] = new HuffTree<char>('Z',2);

    HuffTree<char>* Root = bulidHuff<char>(TreeArray,8);
    HuffNode<char>* root = Root->root();
    preOrder(root);
}
  • 得到测试结果正确
306   
E--120
186   
79    
U--37 
D--42 
107   
L--42 
65    
C--32 
33    
9     
Z--2  
K--7  
M--24

对叶子节点的编码

  • 只有叶子节点需要编码，从根往下遍历（如前序遍历），向左走编码+" 0 " ，向右走编码+” 1 “，直到到达叶子节点，为它setCode, 由此可以联想到递归
template<class E>
void Encode(string code, HuffNode<E>* root){
    if (root->isLeaf()){
        root->setCode(code);
        return;
    }
    Encode(code+"0",root->left());
    Encode(code+"1",root->right());
}

做一个简单的检验

template<class E>
void Encode(string code, HuffNode<E>* root){
    if (root->isLeaf()){
        root->setCode(code);
        return;
    }
    Encode(code+"0",root->left());
    Encode(code+"1",root->right());
}
int main() {
    HuffTree<char>* * TreeArray = new HuffTree<char>* [8];

    TreeArray[0] = new HuffTree<char>('C',32); 
    TreeArray[1] = new HuffTree<char>('D',42);
    TreeArray[2] = new HuffTree<char>('E',120);
    TreeArray[3] = new HuffTree<char>('K',7);
    TreeArray[4] = new HuffTree<char>('L',42);
    TreeArray[5] = new HuffTree<char>('M',24);
    TreeArray[6] = new HuffTree<char>('U',37);
    TreeArray[7] = new HuffTree<char>('Z',2);

    HuffTree<char>* Root = bulidHuff<char>(TreeArray,8);
    HuffNode<char>* root = Root->root();
    Encode("",root);
    preOrder(root);
}
  • 得到结果正确
306
E--120--0   
186
79
U--37--100  
D--42--101  
107
L--42--110  
65
C--32--1110 
33
9
Z--2--111100
K--7--111101
M--24--11111

对文件的编码与解码

  • 要对文件编码与解码，首先就要从文件中读取内容（文件的读写不做介绍），然后获取其中的字符种类与出现频率，由此我们容易联想到使用map来存放相应内容，让后通过map构建Huffman树，并对其编码。

这是text.txt文件里的内容

Stray birds of summer come to my window to sing and fly away.
And yellow leaves of autumn, which have no songs, flutter and fall there with
a sign. 

int main(){
    map<char,int> codeMap; //存放文件里的字符和频率
 
    ifstream in;
    ofstream out;
    in.open("text.txt");
    while (!in.eof()){
        char c ;
        in.get(c);
        codeMap[c]++;   //统计文件里的字符以及频率
    }
    in.close();

    int n = codeMap.size();
    HuffTree<char>* * TreeArray = new HuffTree<char>* [n];
    
    map<char,int>::iterator it = codeMap.begin();

    for (int i = 0; it != codeMap.end(); it++,i++){
        TreeArray[i] = new HuffTree<char>(it->first,it->second);   
    }
    HuffTree<char>* Root = bulidHuff<char>(TreeArray,n);    //创建Huffman树
    HuffNode<char>* root = Root->root();
    Encode("",root);  //为每个字符编码
    preOrder(root);
}

得到结果

149
62
 --28--00   
34
16
8
4
c--2--010000

--2--010001
4
v--2--010010
,--2--010011
t--8--0101
18
n--9--0110
o--9--0111
87
39
19
e--9--1000
10
d--5--10010
5
2
b--1--1001100
A--1--1001101
3
S--1--1001110
.--2--1001111
20
10
y--5--10100
r--5--10101
10
m--5--10110
f--5--10111
48
21
a--10--1100
11
h--5--11010
w--6--11011
27
13
i--6--11100
l--7--11101
14
7
g--3--111100
u--4--111101
s--7--11111
  • 要检验我们的编码是否正确，我们将文章内容编码后输出到另一个文件中，然后再利用这个文章的编码解码出对应的内容，看两者是否相同
  • 要实现该功能，我们首先需要一个能输出指定字符编码的函数，一个能对编码解码的函数
  • 对于对指定字符编码的函数，我们依然可以利用前序的思想找到对应字符的编码
  • 对于解码的函数，我们可以由上往下找，判断当前编码是 0 还是 1， 0 则往左走，1 则往右走，直到遇到叶子节点，然后再次从根出发·····
template <class E>
void findCharCode(string &code,char c, HuffNode<E>* root){
    if (root->isLeaf()){
        if (root->val() == c) code = root->getCode();
        return;
    }
    findCharCode(code,c,root->left());
    findCharCode(code,c,root->right());
}

    in.open("text.txt");
    out.open("textout.txt");
    while (!in.eof()){
        string code = "";
        char c;
        in.get(c);
        findCharCode(code,c,root);   //找到对应字符的编码
        // cout << c <<"--" << code <<endl;
        out << code;    //将编码放进编码文件
    }
    in.close();
    out.close();

//textout.txt文件内容
10011100101101011100101000010011001110010101100101111100011110111001111111110110110101101000101010001000001111011010000001010111001011010100001101111100011010010011111011000101011100111111110001101111000011000110100100010111111011010000110011011110010100100111101000110011010110100100010100100011101111010111110110011101100011000100101000111110001111011100110011110101011111011011001100100110011011110101110001000011010001101011000100101000000110011100111110111011011110011111010011001011111101111101010101011000101010011000110100100010111110011101111010001011101010001010110000011011111000101110100100011100001111111100111100011010011110000

然后解码

template<class E>
string decode(string code ,HuffNode<E>* root){
    string text = "";
    int len = code.length();
    HuffNode<E>* curr = root;
    int i= 0 ;

    while (i < len){
        if (code[i]=='0') curr = curr->left();
        else curr = curr->right();
        if (curr->isLeaf()){
            text += curr->val();
            curr = root;
        }
        i++;
    }
    return text;
}

    in.open("textout.txt");
    string code = "";
    while (!in.eof()){
        char str;
        in.get(str);
        code+=str;    //得到编码
    }
    in.close();
    string text = decode(code,root);  //对编码解码
    cout <<text;   //输入看是否与原文件相同
  • 得到输出结果与原内容一致
Stray birds of summer come to my window to sing and fly away.
And yellow leaves of autumn, which have no songs, flutter and fall there with
a sign.

结语

谨以此文记录自己的学习历程，如有错误，还望斧正
QWQ

zhper
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
堆优化的哈夫曼树模板
总理同学的编程尝试
07-04 291
写的比较低效丑陋，欢迎各路大佬纠错（估计大佬们应该也没有这给闲情逸致看我丑陋的代码）。
堆排序及哈夫曼编码实现数据压缩
qq_58679358的博客
09-18 248
1.将较小的值放在叶子节点。1.对压缩后文件进行解码。1.获得每个字符的数量。
数据结构（三）—— 树（8）：堆
大彤小忆的博客
05-28 2029
8. 堆8.1 什么是堆8.2 堆的抽象数据类型描述8.3 最大堆的操作8.3.1 最大堆的创建8.3.2 最大堆的插入8.3.3 最大堆的删除8.3.4 最大堆的建立8.3.5 最大堆的操作实现 8. 堆 8.1 什么是堆   堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。   堆总是满足下列性质：    1. 堆中某个结点的值总是不大于或不小于其父结点的值；    2. 堆总是一棵完全二叉树。   将根结点最大的堆叫做最大堆或大根堆，根结点最小的.
哈夫曼树
weixin_30645617的博客
11-07 133
一、定义 哈夫曼树，又称最优树，是一类带权路径长度最短的树。首先有几个概念需要清楚： 1、路径和路径长度 从树中一个结点到另一个结点之间的分支构成两个结点的路径，路径上的分支数目叫做路径长度。树的路径长度是从树根到每一个结点的路径长度之和。 2、带权路径长度 结点的带权路径长度为从该结点到树根之间的路径长度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和，通常记作W...
利用最小堆创建Huffman树代码（C++）
乃乃天外仙
09-25 825
#include"heap.h" #include<time.h> #include<iostream> using namespace std; //Huffman tree node abstract base class template<typename E> class HuffNode { public: virtual ~HuffNode(){...
java实现赫夫曼树编码和解码byte[]
12-21
首先对于赫夫曼编码有个大概的理解：赫夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度...
基于C++实现文件的哈夫曼编码与解码【100010226】
12-30
准备一个字符文件，要求： 统计该文件中各种字符的频率 对各字符进行 Huffman 编码，显示每个字符的...读取编码文件，根据哈夫曼编码进行解码，并写入新文件 对比二进制编码和哈夫曼编码后的文件字节大小，并计算压缩率
Huffman编码树通过MATLAB实现
03-18
Huffman编码树通过MATLAB实现
数字彩色图像的哈夫曼编码与解码的matlab实现
05-23
每组数据个数为 1920×1080，并对这三组数据分别进行哈夫曼编码和解码。计算熵和码字的平均码长。 （2）将彩色图像的像素 R、G、B 值作为独立符号，进行哈夫曼编码和解码，计算熵和码字平均码长。 （3）将彩色图像的...
java实现huffman编码解码
07-09
本程序利用Java实现以下功能： 1、读取一行或多行数据，统计出现的所有字母的出现次数 2、构造huffman树 3、生成出现字母的编码表 4、对输入的数据进行...5、输入编码结果，对编码结果进行解码，得到原来的输入数据。
赫夫曼树-Huffman编码
何解然_K|user
09-11 216
首先感叹，Huffman真牛逼！！ 尽量把文件压缩到最小 通过最优排序，大数据把人们最常用的字符放到树前面，以实现最小编码。 大致说一下原理，贴一下代码 1：用户提供常用字符，建立一棵最优树 2：得到每一个字符的编码code 3：用户输入0和1，通过遍历最优树实现解码 说起来很容易，编码设计到队列和二叉树，确实不容易敲出来 接下来敲一下代码：/*注：没使用头文件，分文件写，考虑看家...
C++ 数据结构学习 ---- 哈夫曼树
qq_58240448的博客
11-30 1万+
哈夫曼树，可以容纳超字符
最小堆与huffman树
zerlina98的博客
01-22 203
#include #include template class MinHeap { private: T * heapArray; int currentSize; int MaxSize; void siftUp(int position){ int par=parent(position); while (position
大学数据结构课程设计题目
热门推荐
Java
11-18 1万+
数据结构课程设计题目 1.         飞机订票系统（限1 人完成） 　　任务：通过此系统可以实现如下功能： 　　录入： 　　可以录入航班情况（数据可以存储在一个数据文件中，数据结构、具体数据自定） 　　查询： 　　可以查询某个航线的情况（如，输入航班号，查询起降时间，起飞抵达城市，航班票价，票价折扣，确定航班是否满仓）； 　　可以输入起飞抵达城市，查询飞机航班情况； 　　订票
数据结构实验三：Huffman树及Huffman编码的算法实现
qq_22657279的博客
05-20 3655
Exp03 Huffman树及Huffman编码的算法实现 Author: Maskros 实验目的 了解该树的应用实例，熟悉掌握Huffman树的构造方法及Huffman编码的应用， 了解Huffman树在通信、编码领域的应用过程。Huffman树及Huffman编码的算法实现 实验内容与要求 输入一段100—200字的英文短文，存入一文件a中。 写函数统计短文出现的字母个数n及每个字母的出现次数 写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffm
Huffman二叉树及Huffman编、译码。
m0_62238141的博客
11-17 597
种英文字符的出现频度，构造Huffman二叉树，对所有英文字符进行Huffman编码，将编码后的比特流用byte型（或char型）数组实现存储。在屏幕上输出该比特流的压缩率，然后利用该数组和Huffman二叉树进行译码，将译码后的字符序列输出到另一个字符文件。(2) 输入文件中的不可显示字符（如：回车、换行符）不进行统计和编码；提示：(1) 输入与输出字符文件每10个字符一行；(3) 压缩率=平均编码长度/log2。从字符文件读取若干个大写英文字符(英文字符种类数。=6，则英文字符可取A-F)，统计。
Huffman霍夫曼树，霍夫曼编码
rookie123222的博客
07-22 1925
霍夫曼树基本概念： 路径：从一个结点往下到孩子或孙子结点之间的同理 路径长度：如结点1到结点7的路径长度=2 结点的权：将结点的某一属性值作为结点的权 带权路径长度：从根节点到该结点*该结点的权；如结点1到结点7的带权路径长度：7*2=14 的带权路径长度（WPL）：该树的所有叶子结点的带权路径长度之和 霍夫曼树：给定n个权值，构造一颗二叉树并由这n个权值作为数的叶子结点，且该树的带权路径长度（WPL）达最小，这样的二叉树成为最优二叉树，也叫霍夫曼树 霍夫曼树特点：权值越大的叶子结点.
实验六 Huffman树及Huffman编码的算法实现
m0_51308557的博客
12-21 5619
输入一段100—200字的英文短文，存入一文件a中。写函数统计短文出现的字母个数n及每个字母的出现次数写函数以字母出现次数作权值，建Haffman树（n个叶子），给出每个字母的Haffman编码。用每个字母编码对原短文进行编码，码文存入文件b中。用Haffman树对文件b中码文进行译码，结果存入文件c中，比较a,c是否一致，以检验编码、译码的正确性。
用c++定义Huffman树,实现Huffman编码与译码操作
最新发布
11-15
以下是用C++定义Huffman树，实现Huffman编码与译码操作的示例代码： ```c++ #include #include #include #include using namespace std; // 定义Huffman树节点 struct HuffmanNode { char ch; // 字符 int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值