哈夫曼树编码写出一个解压缩软件源码

最新推荐文章于 2024-03-15 09:36:55 发布
最新推荐文章于 2024-03-15 09:36:55 发布
阅读量236 收藏 1
点赞数
分类专栏： 数据结构课设 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56144302/article/details/125653588
版权 
附录（源代码）


#include<iostream>
#include<string>
#include<fstream>
#include<math.h>

using namespace std;

struct element
{
    int weight;
    int lkid, rkid, parent;
};
void huffman_tree(element* hufftree, int* w, int n);//构造叶子节点长为n的哈夫曼树
void sort(element* hufftree, int& a, int& b, int n);//找出权值最小的两个节点
void huffman_code(element* hufftree, int n, string* code);//对哈夫曼树进行编码
void tongji(char* str, int len, int& n);
string dcr(int n);//根据index生成等长二进制编码
void compress();//压缩函数
void decompress();//解压函数
int ezs(string code);//二进制码转十进制
string i_to_s(int l);
int s_to_i(string str);
int getprefix(char* str, int l, string& type, int& len);//返回去除了前缀的新下标
string getstr(char* str, int begin, int l);
int dictionaries[256];//对应的是hufftree的下标 
int freq[256];
string equal_length_code[256];//等长的二进制编码

int main()
{
    string choose;

    while (true)
    {
        cout << "输入1压缩文件 输入2解压文件 输入其它退出" << endl;
        cin >> choose;
        if (choose == "1")
            compress();
        else if (choose == "2")
            decompress();
        else
            break;
        cout << "OK!" << endl;
    }
    return 0;
}

void sort(element* hufftree, int& a, int& b, int n)
{
    int t1, t2;
    for (int i = 0;i < 2 * n - 1;i++)
    {
        if (hufftree[i].parent == -1)
        {
            t1 = i;
            a = i;
            break;
        }
    }
    for (int i = 0;i < 2 * n - 1;i++)
    {
        if (hufftree[i].parent == -1 && i != a)
        {
            t2 = i;
            b = i;
            break;
        }
    }
    for (int i = 0;i < 2 * n - 1;i++)
    {
        if (hufftree[i].parent == -1 && i != a && (i < n || hufftree[i].lkid != -1))//比较所有有权值的节点
            if (hufftree[i].weight < hufftree[a].weight)
                a = i;
    }
    if (a == b)
        b = t1;
    for (int i = 0;i < 2 * n - 1;i++)
    {
        if (hufftree[i].parent == -1 && i != a && i != b && (i < n || hufftree[i].lkid != -1))
            if (hufftree[i].weight < hufftree[b].weight)
                b = i;
    }
}

void huffman_tree(element* hufftree, int* w, int n)
{
    for (int i = 0;i < 2 * n - 1;i++)
    {
        hufftree[i].parent = -1;
        hufftree[i].lkid = -1;
        hufftree[i].rkid = -1;
    }
    for (int i = 0;i < n;i++)
        hufftree[i].weight = w[i];
    for (int i = n;i < 2 * n - 1;i++)
    {
        int a, b;
        sort(hufftree, a, b, n);
        hufftree[a].parent = i;
        hufftree[b].parent = i;
        hufftree[i].lkid = a;//左最小
        hufftree[i].rkid = b;
        hufftree[i].weight = hufftree[a].weight + hufftree[b].weight;
    }
}

void huffman_code(element* hufftree, int n, string code[256])
{
    for (int i = 0;i < n;i++)
    {
        int p = i;
        while (p != 2 * n - 2)
        {
            if (hufftree[hufftree[p].parent].lkid == p)
                code[i] = '0' + code[i];
            else
                code[i] = '1' + code[i];
            p = hufftree[p].parent;
        }
    }
}

void tongji(char* str, int len, int& n)
{
    n = 0;

    for (int i = 0;i < len;i++)//ascii范围是-128-127
    {
        int ascii = str[i];
        if (ascii >= 0)
            freq[ascii]++;
        else
        {
            ascii = ascii * -1 + 127;
            freq[ascii]++;
        }
    }
    for (int index = 0;index < 256;index++)
        if (freq[index] != 0)
            n++;
}

string dcr(int n)
{
    int a[8];
    int i = 0;
    string str = "";
    while (n != 0)
    {
        a[i] = n % 2;
        n /= 2;
        i++;
    }

    for (n = i - 1;n >= 0;n--)
    {
        if (a[n] == 1)
            str += '1';
        else
            str += '0';
    }
    int l = str.length();
    if (l < 8)
        for (int k = 0;k < 8 - l;k++)
            str = '0' + str;
    return str;
}

void compress()
{
    string filename;
    cout << "输入要压缩的文件的完整路径" << endl;
    cin >> filename;
    int fl = filename.length();
    for (int i = 0;i < fl;i++)
        if (filename[i] == '\\')
        {
            filename.insert(i, "\\\\");
            i += 2;
        }
    for (int i = 0;i < 256;i++)
        equal_length_code[i] = dcr(i);

    for (int i = 0;i < 256;i++)
        freq[i] = 0;

    for (int i = 0;i < 256;i++)
        dictionaries[i] = -1;

    string name;
    string type;
    for (int i = filename.length() - 1;i >= 0;i--)
        if (filename[i] == '.')
        {
            name = filename.substr(0, i);
            //cout<<name<<endl;
            type = filename.substr(i + 1);
            //cout<<type<<endl;
            break;
        }
    int n;
    ifstream f1;
    char* fn = (char*)filename.data();
    f1.open(fn, ifstream::binary);
    f1.seekg(0, ios::end);
    int l = f1.tellg();
    f1.seekg(0, ios::beg);
    char* str = new char[l];
    f1.read(str, l);


    f1.close();
    tongji(str, l, n);


    element* hufftree = new element[2 * n - 1];
    string h_code[n];
    int* w = new int[n];

    int k = 0;
    for (int i = 0;i < 256;i++)
        if (freq[i] != 0)
        {
            w[k] = freq[i];//w是权
            dictionaries[i] = k;
            k++;
        }

    huffman_tree(hufftree, w, n);//构建哈夫曼树
    /*for(int i=0;i<2*n-1;i++)
        cout<<hufftree[i].weight<<endl;*/

    huffman_code(hufftree, n, h_code);//根据哈夫曼树生成每个字符对应的哈夫曼编码
    /*for(int i=0;i<n;i++)
        cout<<h_code[i]<<endl;*/

    if (n == 1)
        h_code[0] = '0';

    //cout<<l<<endl;
    string code = "";
    for (int i = 0;i < l;i++)
    {
        int ascii = str[i];
        if (ascii >= 0)
            code += h_code[dictionaries[ascii]];
        else
            code += h_code[dictionaries[ascii * -1 + 127]];
    }
    //cout<<"step2\n";
    int len = code.length();
    //cout<<len<<endl;
    //cout<<len;
    if (len % 8 != 0)//不够八位的补上0
    {
        int complement = 8 - l % 8;
        for (int i = 0;i < complement;i++)
            code += '0';
    }
    //cout<<"step3\n";
    string newstr = "";//压缩后的新字符串
    for (int i = 0;i * 8 < len;i++)
    {
        string s = "";
        for (int j = 0;j < 8;j++)//获得八位二进制码
            s += code[i * 8 + j];
        int index = ezs(s);//转化为十进制 八位二进制生成一个字节
        //cout<<index;
        if (index < 128)
            newstr += char(index);
        else
            newstr += char((index - 127) * -1);
    }
    string prefix;
    prefix += type + '|';
    prefix += i_to_s(l);//前缀 解压时用
    for (int i = 0;i < 256;i++)
    {
        if (freq[i] != 0)
        {
            prefix += '|';//字符前后用||分隔
            if (i < 128)
                prefix += char(i);
            else
                prefix += char((i - 127) * -1);
            prefix += i_to_s(freq[i]);
        }
    }
    prefix += '|';
    prefix += "stop";
    newstr = prefix + newstr;

    //cout<<prefix<<"\n";
    l = newstr.length();
    //cout<<endl;
    //cout<<l;

    string lmyfile = name + ".yasuo";
    char* lf = (char*)lmyfile.data();

    ofstream f2;
    f2.open(lf, ofstream::binary);
    const char* a = newstr.data();
    f2.write(a, l);
    f2.close();


    delete[] hufftree;
    delete[] w;

    delete[] str;
}

void decompress()
{
    string filename;
    cout << "输入要解压文件的完整路径" << endl;
    cin >> filename;
    int fl = filename.length();
    for (int i = 0;i < fl;i++)
        if (filename[i] == '\\')
        {
            filename.insert(i, "\\\\");
            i += 2;
        }

    for (int i = 0;i < 256;i++)
        equal_length_code[i] = dcr(i);

    for (int i = 0;i < 256;i++)
        freq[i] = 0;

    for (int i = 0;i < 256;i++)
        dictionaries[i] = -1;

    string hc[256];

    string name;
    string type;
    for (int i = filename.length() - 1;i >= 0;i--)
    {
        if (filename[i] == '.')
        {
            name = filename.substr(0, i);
            break;
        }
    }
    //cout<<name<<endl;

    ifstream f1;
    char* fn = (char*)filename.data();
    f1.open(fn, ifstream::binary);
    f1.seekg(0, ios::end);
    int l = f1.tellg();
    f1.seekg(0, ios::beg);
    char* str = new char[l];
    f1.read(str, l);
    f1.close();

    int len;//字符的总数

    int begin = getprefix(str, l, type, len);//begin是新的下标

    string code = "";
    for (int i = begin;i < l;i++)
    {
        int ascii = str[i];
        if (ascii >= 0)
            code += equal_length_code[ascii];
        else
            code += equal_length_code[ascii * -1 + 127];
    }

    //cout<<code.length();
    int n = 0;//原哈夫曼树叶子节点个数
    for (int i = 0;i < 256;i++)
        if (freq[i] != 0)
            n++;

    element* hufftree = new element[2 * n - 1];
    string h_code[n];
    int* w = new int[n];

    int k = 0;
    for (int i = 0;i < 256;i++)
        if (freq[i] != 0)
        {
            w[k] = freq[i];
            dictionaries[i] = k;
            k++;
        }

    huffman_tree(hufftree, w, n);

    huffman_code(hufftree, n, h_code);
    
    if (n == 1)
        h_code[0] = '0';

    for (int i = 0;i < 256;i++)
        if (freq[i] != 0)
            hc[i] = h_code[dictionaries[i]];

    int cl = code.length();
    string newstr = "";
    int a = 0;

    int max = 0;
    for (int i = 1;i < 256;i++)
        if (freq[i] > freq[max])
            max = i;
    int min_length = h_code[dictionaries[max]].length();
    
    for (int k = 0;k < len;k++)
    {
        string temp = "";
        while (a < cl)
        {
            bool found = false;
            temp += code[a];
            if (temp.length() < min_length)
            {
                a++;
                continue;
            }

            for (int index = 0;index < 256;index++)
            {
                if (temp == hc[index])
                {
                    found = true;
                    if (index < 128)
                        newstr += char(index);
                    else
                        newstr += char((index - 127) * -1);
                    break;
                }
            }
            a++;
            if (found == true)
                break;
        }
    }
    l = newstr.length();
    const char* b = newstr.data();


    string lmyfile = name + '.' + type;
    char* lf = (char*)lmyfile.data();
    ofstream f2;
    f2.open(lf, ofstream::binary);
    f2.write(b, l);
    f2.close();

    delete[] str;
    delete[] w;
    delete[] hufftree;
}

int ezs(string code)
{
    int l = code.length();
    int result = 0;
    for (int i = 0;i < l;i++)
        if (code[i] == '1')
            result += pow(2, l - i - 1);
    return result;
}

string i_to_s(int l)
{
    string str = "";
    while (l >= 10)
    {
        str = char(l % 10 + 48) + str;
        l /= 10;
    }
    str = char(l + 48) + str;
    return str;
}

int s_to_i(string str)
{
    int n = 0;
    for (int i = 0;i < str.length();i++)
        n = n * 10 + int(str[i] - 48);
    return n;
}

int getprefix(char* str, int l, string& type, int& len)
{
    string newstr;
    //cout<<l<<endl;
    int e = 0;//结束标志stop开始的地方
    for (int i = 0;i < l;i++)
        if (str[i] == 's' && str[i + 1] == 't' && str[i + 2] == 'o' && str[i + 3] == 'p')
            e = i;
    //cout<<str[e]<<str[e+1]<<str[e+2]<<str[e+3];
    int i = 0;
    int front, rear;
    for (i;i < e;i++)
        if (str[i] == '|')
        {
            rear = i;
            type = getstr(str, 0, rear);
            i++;
            break;
        }
    //cout<<type;
    front = rear + 1;
    for (i;i < e;i++)
        if (str[i] == '|')
        {
            rear = i;
            len = s_to_i(getstr(str, front, rear - front));
            break;
        }
    //cout<<len;

    //cout<<str[i+1];
    while (i < e)
    {
        if (str[i] == '|')
        {
            int w;
            i++;
            if (i >= e)
                break;
            int ascii = str[i];

            i++;
            front = i;
            for (i;i < e;i++)
            {
                if (str[i] == '|')
                {
                    rear = i;
                    w = s_to_i(getstr(str, front, rear - front));
                    break;
                }
            }
            if (ascii >= 0)
                freq[ascii] = w;
            else
                freq[ascii * -1 + 127] = w;
        }
    }
    return e + 4;
}

string getstr(char* str, int begin, int l)
{
    string s = "";
    for (int i = begin;i < begin + l;i++)
        s += str[i];
    return s;
}

（仅供参考）

羡青山有丝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解析C++哈夫曼树编码和译码的实现
09-01
本篇文章主要介绍了C++哈夫曼树编码和译码的实现，详细的讲诉了哈夫曼树编码的原理，有需要的同学可以了解一下。
基于哈夫曼编码的文本文件压缩与解压缩.zip
07-02
哈夫曼编码进行文本压缩
易语言7z解压缩源码.7z
05-17
易语言7z解压缩源码.7z
哎呀.zip_设计一个哈夫曼编码、译码系统
07-14
设计一个哈夫曼编码、译码系统。对一个ASCII编码的文本文件中的字符进行哈夫曼编码，生成编码文件；反过来，可将编码文件译码还原为一个文本文件。 （1）从文件中读入任意一篇英文短文（文件为ASCII编码，扩展名为txt）； （2）统计并输出不同字符在文章中出现的频率（空格、换行、标点等也按字符处理）； （3）根据字符频率构造哈夫曼树，并给出每个字符的哈夫曼编码； （4）图形化输出哈夫曼树、哈夫曼编码； （5）将文本文件利用哈夫曼树进行编码，存储成压缩文件（编码文件后缀名.huf） （6）用哈夫曼编码来存储文件，并和输入文本文件大小进行比较，计算文件压缩率； （7）进行译码，将huf文件译码为ASCII编码的txt文件，与原txt文件进行比较。
图片压缩神器源码系统：无损画质 带完整的代码安装包以及搭建教程
2301_77558505的博客
03-15 412
然而，随着图片数量的增加和质量的提升，存储空间的问题也日益凸显。如何在保证图片质量的前提下，有效减少图片的大小，成为了一个亟待解决的问题。罗峰给大家分享一款图片压缩神器源码系统，它能够在无损画质的前提下，大幅度压缩图片，为用户节省宝贵的存储空间。但我们的源码系统采用了先进的压缩算法，能够在不损害图片画质的前提下，实现大幅度的体积压缩。这意味着，用户无需担心压缩后图片质量的下降，可以放心地享受小体积带来的便利。为了满足用户的个性化需求，我们的源码系统提供了丰富的压缩参数设置选项。
基于C++ Huffman哈夫曼编码的文件压缩与解压缩【100013223】
08-25
https://www.yuque.com/sxbn/ks/100013223 根据ascii码文件中各ascii字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。
基于Huffman编码的压缩和解压缩小软件（附C++源码）
zLimbo的博客
04-20 3911
基于Huffman编码的压缩和解压缩小软件（C++，代码在下面）压缩前：将pic.png拖到.exe文件上，可得到.zLzip压缩文件：编码过程：压缩过程：将.zLzip压缩文件拖回可解压缩得到源文件：值得一提的是，当原文件内字符分布均衡时，压缩率非常低代码如下（编译器是TDM-GCC 4.9.2 64-bit Release， C++11标准）main.cpp文件：HuffmanEncoderC.........
c++实现基于哈夫曼编码的文本(中英混合)压缩和解压缩
yyl1025的博客
12-20 3564
c++实现基于哈夫曼编码的文本(中英混合)压缩和解压缩
linux源码怎么解压,linux 源码解压安装apache
weixin_39567943的博客
05-12 291
step1: 查看是否已安装apache软件，如果有则卸载原有的apache step2: 先装gcc和make yum -y install gcc yum -y install makeyum -y install gcc-c++ 没有这个gcc-c++一会编译不prcestep3: 从 http://httpd.apache.or 下载apache源码包httpd-2.4.4.tar.gz...
Python实现的解压缩软件及excel转图片工具源代码，基于pyqt5
Python代码大全
11-30 391
Python实现的解压缩软件源码及excel转图片工具源代码，基于pyqt5。2、 UnRAR64.dll和compress.py：压缩解压相关。3、 excel2image.py：excel转图片相关。1、GUI.py和GUI.ui：绘制界面相关。4、 main.py：主入口。
易语言WinXar压缩软件源码.zip
07-14
易语言WinXar压缩软件源码.zip
数据压缩软件源代码
11-19
这是数据压缩软件的源代码，就是压缩数据的算法
压缩软件源代码
07-04
有问题可和我联系，愿和所有喜欢编程的同志做朋友 QQ：520136718
LZW解压缩软件源代码
02-15
完整的LZW解压缩软件的代码； 软件环境：Qt5，Win10 64bit，MinGW 7.3； 功能：文本（ASCII）压缩、256色图像压缩（此功能还有一些问题）； 特点：现代的GUI，多线程操作，不支持中文路径和包含空格的文件名。
ZIP压缩程序源代码
11-04
使用C++对开源的ZIP压缩源程序进行了改写，增加了将字符串直接输入到ZIP压缩文件的代码。为了避免产生内存碎片，不使用动态内存申请函数。
Huffman 编码图像无损压缩和解压缩 Python示例代码 哈夫曼编码
08-13
3. 根据 Huffman 树为每个像素值赋予一个可变长度的二进制编码 4. 使用上一步得到的编码对原始图像进行编码 5. 对编码后的位串进行填充,确保长度是 8 的倍数 6. 将编码后的位串转换为字节序列写入压缩文件 解压原理...
基于c语言哈夫曼树编码压缩实践项目
最新发布
05-10
C语言哈夫曼树编码压缩实践项目 根据机器位数可以压缩理论值最大文件。 提供自主输入权值、字符进行编码的接口。 提供输入文件编码。 注释详细。 一、该项目理论上的优点 合理分配了所有变量，根据不同的使用...
基于C#的压缩与解压缩源码
IT技术猿猴的博客
04-03 635
基于C#的压缩与解压缩源码
由哈夫曼树写出对应的哈夫曼树编码
11-09
下面是由哈夫曼树写出对应的哈夫曼编码的步骤： 1. 对于哈夫曼树中的每个叶子节点，标记其对应的字符。 2. 从根节点开始遍历哈夫曼树，当遇到一个叶子节点时，记录下从根节点到该叶子节点的路径上的所有分支，将其...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值