哈夫曼编码（C语言字符的压缩+解压）

最新推荐文章于 2024-05-02 20:20:31 发布
最新推荐文章于 2024-05-02 20:20:31 发布
阅读量1.5k 收藏 30
点赞数 19
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xioaxiang_/article/details/136116672
版权

1 哈夫曼编码

1.1 哈夫曼编码定义

规定哈夫曼树的左分支为0， 右分支为1，则从根节点到每个叶子节点经过的分支对应的0和1组成的序列便为该结点字符的编码。这样的编码成为哈夫曼编码。

1.2 哈夫曼编码是一种前缀编码

前缀编码 是指对字符集进行编码时，要求字符集中任意字符的编码都不是其他字符的编码的前缀。

例如：3：0000

           23：01

那么3前面绝对不会出现01这样的，就证明哈夫曼编码是一种前缀编码。

1.3 C语言实现哈夫曼编码 

1.3.1 比较最小值和次小值
// 寻找最小值和次小值的下标函数
void compare(int *s1, int *s2, Node* ps, int n)
{
    int min1 = 9999999, min2 = 9999999, i;
    
    // 获取最小值的下标
    for (i = 0; i < 2 * n - 1; i++)
    {
        if (ps[i].weight != 0 && ps[i].parent == -1)        // 如果当前权重不为0，并且父结点为-1，就是孤结点
        {
            if (min1 > ps[i].weight)
            {
                *s1 = i;        // 获取下标 
                min1 = ps[i].weight;    // 每次比较后获取较小值，进行下一次比较  
            }
        }
    }

    // 获取次小值的下标
    for (i = 0; i < 2 * n - 1; i++)
    {
        if (ps[i].weight != 0 && ps[i].parent == -1)        // 如果当前权重不为0，并且父结点为-1，就是孤结点
        {
            if (min2 > ps[i].weight && i != *s1)
            {
                *s2 = i;        // 获取下标
                min2 = ps[i].weight;    // 每次比较后获取较小值，进行下一次比较  
            }
        }
    }
}
1.3.2 创建哈夫曼树并初始化
Node *create(int leaf_weight[], const char hanzi[][20], int n) {
    int s1, s2;
    Node *ps = (Node *)malloc((2 * n - 1) * sizeof(Node));

    for (int i = 0; i < 2 * n - 1; i++) {
        ps[i].parent = ps[i].lchild = ps[i].rchild = -1;
        if (i < n) {
            ps[i].weight = leaf_weight[i];
            ps[i].name = strdup(hanzi[i]);
        } else {
            ps[i].weight = 0;
            ps[i].name = "";  // 初始化为空字符串
        }
    }

    for (int i = n; i < 2 * n - 1; i++) {
        compare(&s1, &s2, ps, n);
        ps[i].weight = ps[s1].weight + ps[s2].weight; 
        ps[s2].parent = ps[s1].parent = i;
        ps[i].lchild = s1;
        ps[i].rchild = s2;
    }
    return ps;
}
1.3.3 构建哈夫曼编码并写到文本文件
void writeHuffmanCodeToFile(Node *ps, int n) {
    FILE *file;
    file = fopen("哈夫曼.txt", "w");
    if (file == NULL) {
        printf("无法打开文件");
        exit(1);
    } 
    else {
        for (int i = 0; i < n; i++) {
            fprintf(file, "%s:", ps[i].name);
            int current = i;
            char huffmanCode[256] = "";  // 使用数组来存储哈夫曼编码
            while (ps[current].parent != -1) 
            {
                if (current == ps[ps[current].parent].lchild) {//如果该节点是左孩子
                    strcat(huffmanCode, "0");
                } 
                else if (current == ps[ps[current].parent].rchild) {//如果该节点是右孩子
                    strcat(huffmanCode, "1");
                }
                current = ps[current].parent;
            }
            int len = strlen(huffmanCode);
            for (int j = 0; j < len / 2; j++) {//倒置
                char temp = huffmanCode[j];
                huffmanCode[j] = huffmanCode[len - j - 1];
                huffmanCode[len - j - 1] = temp;
            }
            fprintf(file, "%s\n", huffmanCode);
            printf("%s\n", huffmanCode);
        }
        fclose(file);  // 在写入完成后关闭文件
    }
}

代码实现，得到的都是叶子节点的权重和哈夫曼编码，所以没有左孩子右孩子节点。

2 压缩

先要读取权重文件和哈夫曼编码文件并存储在数组里，方便对照

// 读取权重文件
void ReadWeight() {
    FILE *file1;    // 权重文件

    // 打开文件
    file1 = fopen("权重.txt", "r");
    if (file1 == NULL) {
        printf("权重文件打开失败");
        exit(1);
    }

    // 逐个读取文件内容并存储
    char line[50];
    while (fgets(line, sizeof(line), file1) != NULL) {
        n++;//为了得到节点数 
        char *token = strtok(line, ":\n");
        strcpy(leaf_name[n], token);//copy文字到数组 
        token = strtok(NULL, ":\n"); 
        leaf_weight[n] = atoi(token);//把权重放数组 
    }

    // 关闭文件
    fclose(file1);
    printf("权重文件读取成功\n");
}


// 读取哈夫曼编码
void code_read() {
    // 打开文件
    FILE *file2 = fopen("哈夫曼编码.txt", "r"); // 以只读方式打开文件
    if (file2 == NULL) {
        printf("打开文件失败\n"); // 如果文件打开失败，输出错误信息
        exit(1); // 退出程序
    }

    // 读取内容
    char line[50]; // 定义一个字符数组来存储每行的文本
    while (fgets(line, sizeof(line), file2) != NULL) { // 逐行读取文件内容
        line[strcspn(line, "\n")] = '\0'; // 去除换行符
        char *token = strtok(line, ":"); // 使用冒号分割每行文本，获取第一部分
        strcpy(huf[hu][0], token);//将第一部分存储在 huf 的第一列中
        token = strtok(NULL, ":"); // 继续获取下一部分
        strcpy(huf[hu++][1], token);//将第二部分存储在 huf 的第二列中，并递增huf的索引
    	
	}

    // 关闭文件
    fclose(file2); // 关闭文件
    printf("哈夫曼编码文件读取成功\n"); // 输出成功读取文件的信息
}

压缩为二进制文件，那么就是bin文件，但是为了方便看一看压缩后的文件内容，可以把后缀改为txt查看

以下代码就是对一个字符的哈夫曼编码进行左移操作，以将其添加到正在构建的压缩数据中。

思路：依次查找文本文件的字与权重的字对比，对比正确的按照左移操作对其压缩。

注意：1.为读取的是ANSI文件，那么最多就是三个字符读取到word里面，因为汉字不止一个字符

           2.一个字节是8个比特（bit）

           3.压缩得到的文件内容是乱码

           4.压缩得到的文件绝对比原文件小

void compress() {
    // 逐字压缩
    char word[3]; // 用于存储从原始文件中读取的字符数组
	unsigned char ch; // 用于存储压缩后的字符
	int b = 0; // 用于跟踪当前字节中的位数
	
	// 从原始文件中读取最多3个字符到word中
	fgets(word, 3, originalfile);//(ANSI文件)
	
	// 循环处理读取的字符
	do {
	    int n1 = 1; // 辅助变量n1的初始化
	    for (int i = 0; i <= hu; i++) { // 遍历哈夫曼编码表
	        if (strcmp(huf[i][0], word) == 0) { // 如果找到与word对应的编码
	            for (int k = 0; k < strlen(huf[i][1]); k++) { // 对编码进行处理
	                ch += (huf[i][1][k] - '0'); // 按位将编码转换为字符
	                b++; // 记录处理位数
	                if (b == 8) { // 如果已经处理了一个完整的字节
	                    fwrite(&ch, sizeof(char), 1, file); // 将字符写入文件
	                    b = 0; // 重置位数
	                }
	                ch = ch << 1; // 左移一位
	            }
	            memset(word, '\0', sizeof(word)); // 清空word数组
	        }
	        n1++; // 增加辅助变量n1的值
	    }
	    if (n1 == 1) fprintf(file, "%s,", word); // 如果在哈夫曼编码表中找不到对应的编码，直接将原始字符写入文件
	} while (fgets(word, 3, originalfile)); // 继续读取原始文件的内容并进行处理

}

3 解压

压缩就是左移操作，那么解压就是右移操作。

解压得到的是看得懂的字，并非乱码

// 解压得到原文
void decompress(Huffman ps) {

    // 逐字解压
    int current = 2 * n - 1;  // 从哈夫曼树的根节点开始
    char bit;
    while (fread(&bit, sizeof(char), 1, file) > 0) {
        for (int i = 7; i >= 0; --i) {
            if ((bit >> i) & 1) {  // 读取一个比特
                current = ps[current].right;  // 如果为1，移动到右孩子
            } else {
                current = ps[current].left;  // 如果为0，移动到左孩子
            }
            if (current <= n) {  // 到达叶子节点，输出对应字符
                fprintf(outfile, "%s", ps[current].name);
                current = 2 * n - 1;  // 从根节点重新开始
            }
        }
    }
}

4 完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//错误点，把三国演义汉字提取到二维数组再与权重文本文件比较得到哈夫曼编码（麻烦）
//strtok分离，strcopy，copy 
//压缩对一个字符的哈夫曼编码进行左移操作，以将其添加到正在构建的压缩数据中。
//解压对已经解压的哈夫曼编码进行右移操作，以逐位地获取哈夫曼编码中的每个比特位（bit）

// 定义节点结构体
typedef struct Node {
    char name[8];  // 存放汉字字符
    int weight;  // 存放权重
    int left;  // 左孩子
    int right;  // 右孩子
    int parent;  // 父节点
} Node, *Huffman;

// 全局变量
int n;  // 节点个数
char leaf_name[5000][4];   // 节点字符
int leaf_weight[5000]; // 节点权重
char huf[5000][2][30];//二维字符数组
//包含 5000 个元素的二维数组，每个元素都是一个包含两个字符串的数组，每个字符串最多包含 30 个字符。
int hu = 0;

void ReadWeight();
void compare(Huffman ps, int n1, int *s1, int *s2);
void Create(Huffman ps); 
void code_read();
void compress();
void decompress(Huffman ps);

int main() {
    ReadWeight();//权重 
    Huffman ps = (Huffman) malloc((2 * n+1) * sizeof(Node));//获取内存 
    Create(ps);//哈夫曼树 
    code_read();//把哈夫曼编码读取 
    compress();//压缩 
    decompress(ps);//解压 
	
    free(ps);
    return 0;
}

// 读取权重文件
void ReadWeight() {
    FILE *file1;    // 权重文件

    // 打开文件
    file1 = fopen("权重.txt", "r");
    if (file1 == NULL) {
        printf("权重文件打开失败");
        exit(1);
    }

    // 逐个读取文件内容并存储
    char line[50];
    while (fgets(line, sizeof(line), file1) != NULL) {
        n++;//为了得到节点数 
        char *token = strtok(line, ":\n");
        strcpy(leaf_name[n], token);//copy文字到数组 
        token = strtok(NULL, ":\n"); 
        leaf_weight[n] = atoi(token);//把权重放数组 
    }

    // 关闭文件
    fclose(file1);
    printf("权重文件读取成功\n");
}

// 选择两个最小的节点
void compare(Huffman ps, int n1, int *s1, int *s2) {
    int min1 = 9999999, min2 = 9999999;  // 初始化最小权重和次小权重
    *s1 = 0;  // 初始化最小权重节点的索引
    *s2 = 0;  // 初始化次小权重节点的索引
    for (int i = 1; i <= n1; ++i) {
        if (ps[i].parent == 0 && ps[i].weight < min1) {  // 如果节点没有父节点且权重比最小权重小
            *s2 = *s1;  // 更新次小权重节点的索引
            min2 = min1;  // 更新次小权重
            *s1 = i;  // 更新最小权重节点的索引
            min1 = ps[i].weight;  // 更新最小权重
        } else if (ps[i].parent == 0 && ps[i].weight < min2) {  // 如果节点没有父节点且权重比次小权重小
            *s2 = i;  // 更新次小权重节点的索引
            min2 = ps[i].weight;  // 更新次小权重
        }
    }
}

// 创建哈夫曼树
void Create(Huffman ps) {
    for (int i = 1; i <= 2 * n - 1; i++) {
        ps[i].parent = ps[i].left = ps[i].right = 0;
        if (i <= n) {
            ps[i].weight = leaf_weight[i-1];
            strcpy(ps[i].name, leaf_name[i-1]);
        } else {
            ps[i].weight = 0;
            strcpy(ps[i].name, "\0");
        }
    }

    for (int i = n + 1; i <= 2 * n - 1; ++i) {
        int s1, s2;
        compare(ps, i - 1, &s1, &s2);
        ps[i].weight = ps[s1].weight + ps[s2].weight;//父节点权重 
        ps[s2].parent = ps[s1].parent = i;
        ps[i].left = s1;
        ps[i].right = s2;
    }
    printf("哈夫曼树创建成功\n");
}

// 读取哈夫曼编码
void code_read() {
    // 打开文件
    FILE *file2 = fopen("哈夫曼编码.txt", "r"); // 以只读方式打开文件
    if (file2 == NULL) {
        printf("打开文件失败\n"); // 如果文件打开失败，输出错误信息
        exit(1); // 退出程序
    }

    // 读取内容
    char line[50]; // 定义一个字符数组来存储每行的文本
    while (fgets(line, sizeof(line), file2) != NULL) { // 逐行读取文件内容
        line[strcspn(line, "\n")] = '\0'; // 去除换行符
        char *token = strtok(line, ":"); // 使用冒号分割每行文本，获取第一部分
        strcpy(huf[hu][0], token);//将第一部分存储在 huf 的第一列中
        token = strtok(NULL, ":"); // 继续获取下一部分
        strcpy(huf[hu++][1], token);//将第二部分存储在 huf 的第二列中，并递增huf的索引
    	
	}

    // 关闭文件
    fclose(file2); // 关闭文件
    printf("哈夫曼编码文件读取成功\n"); // 输出成功读取文件的信息
}

// 压缩原文并得到二进制文件
void compress() {
    // 打开文件
    FILE *originalfile = fopen("三国演义.txt", "r");
    if (originalfile == NULL) {
        printf("原文打开失败");
        exit(1);
    }
    FILE *file = fopen("压缩.txt", "w");
    if (file == NULL) {
        printf("压缩文件打开失败");
        exit(1);
    }

    // 逐字压缩
    char word[3]; // 用于存储从原始文件中读取的字符数组
	unsigned char ch; // 用于存储压缩后的字符
	int b = 0; // 用于跟踪当前字节中的位数
	
	// 从原始文件中读取最多3个字符到word中
	fgets(word, 3, originalfile);//(ANSI文件)
	
	// 循环处理读取的字符
	do {
	    int n1 = 1; // 辅助变量n1的初始化
	    for (int i = 0; i <= hu; i++) { // 遍历哈夫曼编码表
	        if (strcmp(huf[i][0], word) == 0) { // 如果找到与word对应的编码
	            for (int k = 0; k < strlen(huf[i][1]); k++) { // 对编码进行处理
	                ch += (huf[i][1][k] - '0'); // 按位将编码转换为字符
	                b++; // 记录处理位数
	                if (b == 8) { // 如果已经处理了一个完整的字节
	                    fwrite(&ch, sizeof(char), 1, file); // 将字符写入文件
	                    b = 0; // 重置位数
	                }
	                ch = ch << 1; // 左移一位
	            }
	            memset(word, '\0', sizeof(word)); // 清空word数组
	        }
	        n1++; // 增加辅助变量n1的值
	    }
	    if (n1 == 1) fprintf(file, "%s,", word); // 如果在哈夫曼编码表中找不到对应的编码，直接将原始字符写入文件
	} while (fgets(word, 3, originalfile)); // 继续读取原始文件的内容并进行处理

    // 关闭文件
    fclose(originalfile);
    fclose(file);
    printf("压缩成功\n");
}

// 解压得到原文
void decompress(Huffman ps) {
    // 打开文件
    FILE *file = fopen("压缩.txt", "rb");
    if (file == NULL) {
        printf("压缩文件打开失败");
        exit(1);
    }
    FILE *outfile = fopen("解压.txt", "w");
    if (outfile == NULL) {
        printf("解压文件打开失败");
        exit(1);
    }

    // 逐字解压
    int current = 2 * n - 1;  // 从哈夫曼树的根节点开始
    char bit;
    while (fread(&bit, sizeof(char), 1, file) > 0) {
        for (int i = 7; i >= 0; --i) {
            if ((bit >> i) & 1) {  // 读取一个比特
                current = ps[current].right;  // 如果为1，移动到右孩子
            } else {
                current = ps[current].left;  // 如果为0，移动到左孩子
            }
            if (current <= n) {  // 到达叶子节点，输出对应字符
                fprintf(outfile, "%s", ps[current].name);
                current = 2 * n - 1;  // 从根节点重新开始
            }
        }
    }

    //关闭文件
    fclose(file);
    fclose(outfile);
    printf("解压成功\n");
}

5 完结撒花

感谢观看

Xioaxiang_
关注
  • 19
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
用C语言实现哈夫曼编码
m0_50914476的博客
02-06 795
创作灵感： 哈夫曼编码是一种用于数据压缩的常用技术，它可以将字符集中的字符映射到不同长度的二进制编码，以实现高效的数据压缩。本文将介绍一个用C语言编写的程序，演示如何构建哈夫曼树并生成字符的哈夫曼编码。通过这个程序，我们可以学习哈夫曼编码的基本原理以及如何在C语言中实现。在主函数main中，程序首先获取用户输入的字符集和频率信息，并使用createHuffmanTree函数构建哈夫曼树。然后，使用printHuffmanCodes函数生成并打印字符的哈夫曼编码。
用哈夫曼编码实现文件压缩（代码+报告）
04-04
根据ASCII码文件中各ASCII字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。 五、概要设计： 1、数据结构类型定义 /*****Huffman结构定义**********/ typedef struct node ...
C语言实现的基于Huffman哈夫曼编码的数据压缩与解压缩.7z
06-08
根据ASCII码文件中各ASCII字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。
C语言实现数据结构——哈夫曼编码
qq_45746876的博客
11-22 1万+
哈夫曼编码前言哈夫曼树与哈夫曼编码介绍思路哈夫曼树的建立对外部结点进行哈夫曼编码代码实现勉强算是总结 前言 又快一周没有更新了，最近事情比较多，回家几天拖欠了一些作业和实验，所以最近小杨在疯狂的补作业和实验，所以就没有更新新文章，希望大家理解哈~ 有没有细心的小伙伴发现本人改了昵称又换了头像呢，没有的话就让本人来带大家稍微了解一下叭： 之前在刷最右的时候偶然看到了一个关于 山野下 的帖子，看完之后又去仔细的了解了一下，真的很有感触，现在我也是小榆的眼睛啦，想带她看看有关计算机的知识，希望她不会觉得枯燥呀。
哈夫曼编码--c语言实现
weixin_60243362的博客
05-02 336
【代码】哈夫曼编码--c语言实现。
哈夫曼压缩与解压缩（c语言版）
qq_42034205的博客
09-29 1万+
目录 哈夫曼压缩与解压缩（c语言版） 一：引言 二：主要原理 三：主要技术点 四：实现过程 1.压缩： 2.解压缩： 五：详细分析，及代码实现 哈夫曼压缩与解压缩（c语言版） 一：引言 学过数据结构的同学，应该都听过哈夫曼树，和哈夫曼压缩算法，今天小编向大家讲解哈夫曼压缩与压缩的过程以及代码也算是记录一下自己所学所做的东西。 哈夫曼压缩，其实效率不是很高，一般情况下压缩率1...
(数据结构)哈夫曼编码实现（C语言）
laterstage的博客
07-22 1055
(数据结构)哈夫曼编码实现（C语言）
哈夫曼树编码译码器（你们懂的）
小帅博客
04-09 5543
哈夫曼树编码译码器 希望点赞一下，哈哈哈哈哈 #include<stdio.h> #include<malloc.h> #define maxval 10000.0 #define maxsize 100 //哈夫曼编码的最大位数 typedef struct { char ch; float weight; int lchild,rchild,parent;...
基于哈夫曼编码的文件压缩解压程序的C语言实现
06-07
在C语言中实现基于哈夫曼编码的文件压缩解压程序，需要深入理解哈夫曼编码的基本原理以及C语言编程技巧。 首先，哈夫曼编码是根据字符出现频率进行编码的一种方法。它通过构建一棵特殊的二叉树——哈夫曼树（也称为...
基于C语言实现的利用哈夫曼树实现文本文件压缩解压.zip
最新发布
05-10
6. **解压文件**：读取压缩文件，恢复哈夫曼编码表，然后按照编码表将编码还原为原始字符，从而得到解压后的文本文件。 在实际编程中，还需要考虑错误处理、内存管理和效率优化等问题。例如，可以使用动态内存分配...
c语言实现哈夫曼图像压缩和解压缩课程设计
01-27
在本课程设计中，我们将探讨如何使用C语言来实现哈夫曼编码技术，这是一种高效的无损数据压缩方法，尤其适用于文本和图像数据。哈夫曼编码是基于字符频率的变长编码，它能够将出现频繁的字符用较短的编码表示，而...
哈夫曼编码的 C 语言实现
08-14
哈夫曼编码是一种无损的高效的压缩方法。对文本文件进行哈夫曼编码，使用计算信源熵打开一个文件进行概率计算，然后将输出的 submit.txt 文件用哈夫曼编码打开，之后就会对文本文件中出现的字符进行哈夫曼编码。
C语言之霍夫曼编码学习
csdn's blog
07-01 1万+
​1，霍夫曼编码描述 哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。 在计算机信息处理中,“哈夫曼编码”是一种一致性编码法（又称“熵编码法”），用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用...
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
wardseptember的博客
06-17 11万+
Huffman Tree简介&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,…,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,…,wn}，则所构造出的带权路径长度最小的二叉树就被称为赫夫曼树。&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;a
基于C语言利用哈夫曼树实现文件压缩
qq_49750651的博客
07-03 5851
一、哈夫曼树 具有n个权值的n个叶子结点，构造出一个二叉树，使得该树的带权路径长度（WPL）最小，则称此二叉树为最优二叉树，也称为哈夫曼树（Huffman Tree）。 注意：哈夫曼树是带权路径长度最短的树，且权值越大的叶子结点离根结点越近。 二、哈弗曼编码 哈弗曼编码是一种编码方式，又称“霍夫曼编码”，其是可变字长的编码（VCL）的一种，是由霍夫曼于1952年提出的一种编码方式，有时被称为最佳编码，一般称为Huffman编码。 2.1如何得到哈弗曼编码 .........
C语言:字符串的解压缩
sanfengshaonian的博客
08-10 754
void decompressString(char* str) { //解压。if(num == 0){//字符前没有数字 只放一个字符。void compressString(char* str) { //压缩。printf("请输入要解压缩的字符串：");printf("请输入要压缩的字符串：");printf("压缩后的字符串为：");
C语言中的数据压缩与解压缩：实现简单的无损压缩算法（如Huffman编码）（二）
weixin_56154577的博客
04-06 934
尽管Huffman编码是一种有效的无损压缩技术，但数据压缩领域还有许多其他算法值得学习和探索，如LZ系列算法（LZ77、LZ78、LZW等）、Run-length encoding（RLE）、Arithmetic coding等。掌握这些算法不仅能提升编程技能，更能增强对数据特性和压缩原理的理解，从而在面对不同应用场景时，选择或设计出最适合的数据压缩解决方案。
C语言压缩与解压缩字符串（可用于进程间通信）
云淡风轻ing的博客
07-16 1214
C语言压缩与解压缩字符串（可用于进程间通信） #include <stdio.h> #include <stdio.h> #include <string.h> #include <malloc.h> #include <zlib.h> #define dPrint(fmt, ...) do{fprintf(stderr, "[%s:%d] " fmt "\r\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
哈夫曼编码（霍夫曼、赫夫曼）
m0_54136420的博客
07-14 3187
在数字电视大力发展的今天，
c语言哈夫曼编码译码
05-07
哈夫曼编码是一种用于压缩数据的技术，它的基本思想是根据数据出现的频率构建一棵二叉树，并将出现频率较高的字符编码为较短的二进制码，出现频率较低的字符编码为较长的二进制码，从而达到压缩数据的目的。哈夫曼编码的解码过程就是根据构建的二叉树进行反向遍历，将二进制码转换为原来的字符。 哈夫曼编码的具体步骤如下： 1. 统计待压缩数据中每个字符出现的频率，将其保存在一个字符频率表中。 2. 将字符频率表中的每个字符作为叶子节点，构建哈夫曼树。构建哈夫曼树的过程可以采用贪心算法，每次选取频率最小的两个节点合并。 3. 对哈夫曼树进行编码，从根节点开始遍历哈夫曼树，遇到左子节点为0，遇到右子节点为1。将每个字符的编码保存在一个编码表中。 4. 将待压缩数据中的每个字符转换为其对应的哈夫曼编码，并将所有编码拼接起来，形成压缩后的数据。 哈夫曼解码的具体步骤如下： 1. 读取压缩后的数据，并从根节点开始遍历哈夫曼树。 2. 遇到0则遍历左子节点，遇到1则遍历右子节点，直到遍历到叶子节点。 3. 根据叶子节点对应的字符进行解码，并将解码后的字符保存起来，直到所有编码都被解码完毕。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值