📃博客主页: 小镇敲码人
💚代码仓库,欢迎访问
🚀 欢迎关注:👍点赞 👂🏽留言 😍收藏
🌏 任尔江湖满血骨,我自踏雪寻梅香。 万千浮云遮碧月,独傲天下百坚强。 男儿应有龙腾志,盖世一意转洪荒。 莫使此生无痕度,终归人间一捧黄。🍎🍎🍎
❤️ 什么?你问我答案,少年你看,下一个十年又来了 💞 💞 💞
【ZZULI数据结构实验】压缩与解码的钥匙:赫夫曼编码应用
- [🏆 实验目的和要求](#🏆 实验目的和要求)
- [🏆 实验前的准备工作](#🏆 实验前的准备工作)
-
- [🔑 确定汉字编码](#🔑 确定汉字编码)
- [🔑 在文件中实现汉字的读和写](#🔑 在文件中实现汉字的读和写)
-
- [🍸 知道汉字的高位和低位在屏幕上打印汉字](#🍸 知道汉字的高位和低位在屏幕上打印汉字)
-
- [👘 字符串形式(%s)打印](#👘 字符串形式(%s)打印)
- [👘 字符形式(%c)打印](#👘 字符形式(%c)打印)
- [🍸 在文件中写入汉字(以GBK编码的形式)](#🍸 在文件中写入汉字(以GBK编码的形式))
- [🍸 在文件中读入中文,并以GBK编码的形式来输出](#🍸 在文件中读入中文,并以GBK编码的形式来输出)
- [🏆 赫夫曼树的结构设计](#🏆 赫夫曼树的结构设计)
-
- [🔑 知识点介绍](#🔑 知识点介绍)
- [🔑 结构设计](#🔑 结构设计)
- [🏆 赫夫曼树函数的具体实现](#🏆 赫夫曼树函数的具体实现)
-
- [🔑 List_Init(链表初始化)和 Node_Init(节点初始化)](#🔑 List_Init(链表初始化)和 Node_Init(节点初始化))
- [🔑 链表的销毁和赫夫曼树的销毁](#🔑 链表的销毁和赫夫曼树的销毁)
- [🔑 链表的插入](#🔑 链表的插入)
- [🔑 buildHuffmanTree(构造赫夫曼树)](#🔑 buildHuffmanTree(构造赫夫曼树))
- [🔑 assignCodes(编码)](#🔑 assignCodes(编码))
-
- [🍸 strdup函数介绍](#🍸 strdup函数介绍)
- [🍸 编码函数实现](#🍸 编码函数实现)
- [🔑 打印字符出现的频次](#🔑 打印字符出现的频次)
- [🔑 打印字符的编码](#🔑 打印字符的编码)
- [🏆 最终效果演示](#🏆 最终效果演示)
-
- [🔑 菜单及调用函数实现](#🔑 菜单及调用函数实现)
- [🔑 效果展示](#🔑 效果展示)
前言:上篇博客,博主分享了多项式的运算实验,今天我们继续来看实验二------赫夫曼编码及应用。相关代码在博主的代码仓库自行查看。
🏆 实验目的和要求
🏆 实验前的准备工作
🔑 确定汉字编码
我们这次实验采用GBK编码来编码汉字,该编码标准兼容GB2312(ANSI),由两个字节来编码确定一个汉字,而且高位和低位为了和英文字符做区分,都是大于128的。我们可以看一下编码表。
- 也可以使用UTF-8编码,但是该编码会出现3个乃至4个字节编码一个汉字的情况,控制起来太复杂,所以我们不采用这个。
🔑 在文件中实现汉字的读和写
在学习如何在汉字中编码前,我们先来学习一下如何在屏幕上(标准输出流stdout
)上打印一个用GBK编码的汉字。
🍸 知道汉字的高位和低位在屏幕上打印汉字
👘 字符串形式(%s)打印
我们通过查阅资料,知道了中文阿的高位和低位是0xB0、0xA2。
c
#include <stdio.h>
int main()
{
// 定义GBK编码的高位字节
int high = 0xB0;
// 定义GBK编码的低位字节
int low = 0xA2;
// 创建一个字符数组来存储GBK编码的汉字
unsigned char s[3] = { (unsigned char)high, (unsigned char)low, '\0' };
printf("%s", s);
return 0;
}
运行结果:
👘 字符形式(%c)打印
c
#include <stdio.h>
int main()
{
// 定义GBK编码的高位字节
int high = 0xB0;
// 定义GBK编码的低位字节
int low = 0xA2;
printf("%c%c",high,low);
return 0;
}
运行结果:
- 这里高位字节和低位字节用大小为1字节的类型也是可以的,但是要注意,应该使用
unsigned char
无符号类型,这样就不会出现负数的情况(GBK编码高位和低位第一位都为1),便于我们的判断。的如果4字节的会发生截断。
🍸 在文件中写入汉字(以GBK编码的形式)
c
#include <stdio.h> // 引入标准输入输出库,用于文件操作和输入/输出函数
int main() // 主函数入口
{
// 声明一个文件指针pf,并尝试以写入("w")模式打开名为"诗.txt"的文件
FILE* pf = fopen("诗.txt", "w");
// 检查文件是否成功打开
if (NULL == pf)
{
// 如果文件打开失败,则输出错误信息(来自perror函数)
perror("fopen");
// 并返回错误代码1
return 1;
}
// 定义一个无符号字符数组s,用于存储用户输入的字符串,并初始化为全0
unsigned char s[600] = { 0 };
// 使用scanf函数从标准输入(通常是键盘)读取一个字符串,并存储在s中
// 注意:这里使用%s可能会引发缓冲区溢出问题,因为scanf不会检查目标数组的大小
// 更好的做法是使用fgets函数或者限制scanf读取的字符数
scanf("%s", s);
// 初始化一个循环计数器i,用于遍历字符串s
int i = 0;
// 循环遍历字符串s,直到遇到字符串结束符'\0'
while(s[i] != '\0')
{
// 声明两个无符号字符变量high和low,用于存储GBK编码的汉字的高位和低位字节
// 假设字符串s中包含GBK编码的汉字,但实际上这种假设可能不正确
unsigned char high = '\0';
unsigned char low = '\0';
// 将s中的当前字符赋值给high
high = s[i++];
// 如果high的值大于128(通常表示这是一个非ASCII字符),则假设它是GBK编码的汉字的高位字节
if(high > 128)
{
// 尝试将s中的下一个字符赋值给low(假设它是GBK编码的汉字的低位字节)
low = s[i++];
}
// 将high写入文件
fputc(high, pf);
// 如果low不为'\0'(即存在低位字节),则将其写入文件
if (low != '\0')
fputc(low, pf);
}
// 关闭文件
fclose(pf);
// 将文件指针设置为NULL,避免野指针
pf = NULL;
// 程序正常结束,返回0
return 0;
}
这是我们写入的内容:
看看文件中是否生成了对应内容:
从右边的预览我们可以看见确实写入了对应的内容,有小伙伴可以会好奇,为什么换行了呢?我们刚刚我们明明没有换行呀,其实你如果点进这个文件会发现,其实并没有换行,只是预览这样可能更方便我们阅读:
🍸 在文件中读入中文,并以GBK编码的形式来输出
首先我们需要新建一个文件写入内容后,另存选择编码为GBK或者是它兼容的,因为程序编码格式和文件的编码格式必须保持一致。
选择GB
类型的编码或者ANSI
都是,因为ANSI
也是GB
类型的一种,GBK
都是兼容的他们的。这里我们选择ANSI
编码。
文件中的内容如下:
下面我们用代码来以GBK
的形式读一下文件中的内容并输出到屏幕上。
c
#include <stdio.h> // 引入标准输入输出库
int main()
{
// 声明一个文件指针pf,并尝试以只读("r")模式打开名为"十年.txt"的文件
FILE* pf = fopen("十年.txt", "r");
// 检查文件是否成功打开
if (NULL == pf)
{
// 如果文件打开失败,则输出错误信息
perror("fopen");
// 并返回错误代码1
return 1;
}
// 初始化两个变量high和low,high用于存储从文件中读取的字符,low用于存储汉字的低字节(如果存在)
int high = 0, low = '\0';
// 使用while循环从文件中逐个字符地读取,直到遇到文件结束符EOF
while ((high = fgetc(pf)) != EOF)
{
// 如果读取到的字符(存在于high中)大于128(假设是GBK或其他多字节编码的汉字的高字节)
if (high > 128)
{
// 读取下一个字符作为汉字的低字节(如果存在)
low = fgetc(pf);
// 输出高字节和低字节,但由于low可能不是汉字的低字节(例如遇到非汉字字符),
// 直接输出可能会导致乱码或不正确的输出。
printf("%c%c", high, low);
}
else
{
// 如果不是汉字的高字节,则只输出该字符
printf("%c", high);
}
}
// 关闭文件
fclose(pf);
// 将文件指针设置为NULL,避免野指针
pf = NULL;
// 程序正常结束,返回0
return 0;
}
运行结果:
这里还是用int
来保存低位和高位较好,因为既要与128
作比较来区分因为字符和中文字符,不能让系统把首位的1当作负号位,又要做判断文件结束的判断,因为EOF
是-1,无符号数没有负数,所以如果使用无符号数,程序会陷入死循环。
所以接下来的实验中我们会以int
类型保存字符的高位和低位。最终系统会发生截断的,所以我们不用担心int
和char
不匹配的问题。
🏆 赫夫曼树的结构设计
🔑 知识点介绍
🔑 结构设计
赫夫曼树是一种特殊的二叉树,WPL最小的二叉树,所以赫夫曼树又叫最优二叉树。
首先就是哈夫曼树的节点类型,我们需要在这个类型里面放5个数据,节点的左孩子、右孩子、还有这个节点保存的字符即它的低位和高位,还有这个字符的字符串编码(char*
类型,动态开辟内存按需申请)。
c
typedef struct HuffmanNode* NodeP;
typedef struct HuffmanNode {
unsigned int freq;//出现的频率
NodeP left, right;//节点的左孩子和右孩子
int low;//低位
int high;//高位
char* code; // 编码,在构造树后分配
}Node;
然后我们还需要一个线性表的结构,这个线性表用来保存每种字符的频率,可以使用链表或者线性表,这里我们使用的是链表。因为链表无需我们考虑申请空间的问题,省事很多。
c
typedef struct HuffmanList* ListP;//创建一个双向循环链表,存储节点的频度
typedef struct HuffmanList{
NodeP data;//哈夫曼树节点
ListP next;
}List;
这里我们把链表指针和树的节点指针类型取了一下别名,因为后面要多次使用,这样做可以少写一个*
,指针的英文是Pointer
,所以我们后面加了P
代表这个是指针类型。
函数接口:
c
void List_insert(ListP Head,ListP newnode);//插入新的节点
ListP List_Init(NodeP data);//初始化链表
void Print_freq(ListP Head);//打印各个词出现的频率
void Destroy_List(ListP newnode);//销毁链表
NodeP Node_Init(int freq, int low, int high);//节点初始化
NodeP buildHuffmanTree(ListP* Head);//构造哈夫曼树
void assignCodes(NodeP root, char* code);//编码
void decode(NodeP root, FILE* encodedFile, FILE* decodedFile);//解码
void dfs(NodeP root);//前序遍历,打印节点和其对应的编码
🏆 赫夫曼树函数的具体实现
🔑 List_Init(链表初始化)和 Node_Init(节点初始化)
过于简单不过多叙述。
c
ListP List_Init(NodeP data)//链表节点初始化
{
ListP newL = (ListP)malloc(sizeof(List));//为链表节点申请空间
if (NULL == newL)
{
printf("malloc Failed\n");
exit(-1);
}
//初始化
newL->data = data;//初始化数据节点
newL->next = NULL;//初始化next为空
}
NodeP Node_Init(int freq, int low, int high)//赫夫曼树节点初始化
{
NodeP NewN = (NodeP)malloc(sizeof(Node));//为赫夫曼树节点申请空间
if (NULL == NewN)
{
printf("malloc Failed\n");
exit(-1);
}
//初始化
NewN->freq = freq;
NewN->high = high;
NewN->low = low;
NewN->left = NULL;
NewN->right = NULL;
NewN->code = NULL;
}
🔑 链表的销毁和赫夫曼树的销毁
- 注意:虽然链表里面存的有赫夫曼树的节点指针,但是节点的内存并不是和链表节点一起申请的,链表节点只是有一个4字节的变量也指向那片空间而以,而且链表里有的节点在赫夫曼树中肯定是存在的,节点的内存在赫夫曼树中走一个后序就可以释放,但是如果你在链表中就释放了,在释放赫夫曼树的时候,释放叶子节点时还需要特判一下,因为叶子节点已经释放过了(重复释放程序会崩溃),而且非法访问也会出问题,所以我们统一走后序在树中释放节点的内存。
c
void Destroy_List(ListP Head)
{
assert(Head);//断言,头节点不能为空
ListP Cur = Head;
while (Cur != NULL)
{
ListP next = Cur->next;
free(Cur);
Cur = next;
}
}
void Destroy_HuffmanTree(NodeP root)//销毁赫夫曼树
{
if (root == NULL)
return;
Destroy_HuffmanTree(root->left);//先去释放根节点的左树
Destroy_HuffmanTree(root->right);//再去释放根节点的右树
free(root);//最后释放根节点
}
🔑 链表的插入
链表的插入就是用来统计每个字符出现的频次的 ,具体逻辑是这样的,我们在外面的函数只需要传入字符的高位和低位即可,如果high
和low
已经出现了,就没有构造链表节点和赫夫曼树节点的必要,如果没有出现,外面就需要依次构造赫夫曼树节点和链表节点头插进链表中。
c
void List_insert(ListP Head,int high,int low)//插入节点
{
ListP cur = Head->next;
//循环遍历,看是否该字符已经存在
while (cur != NULL)
{
if (cur->data->high == high && cur->data->low == low)
{
cur->data->freq++;
break;
}
cur = cur->next;
}
if (cur == NULL)//没有找到,或者链表为空(只有一个头节点)
{
//构造新节点
NodeP newHnode = Node_Init(1,low, high);
ListP newLnode = List_Init(newHnode);
//头插进链表中
newLnode->next = Head->next;//先把Head后面的节点和新节点链接
Head->next = newLnode;//在把头节点的next更新
}
}
🔑 buildHuffmanTree(构造赫夫曼树)
统计完文件中每个字符的频次,我们得到对应的树节点,也可以将它们视作森林。因为此时它们还没有链接起来,因为每次我们需要依次取两个频次最小的节点,所以我们可以使用小堆(按照频次来调整)这种数据结构,一共有N个节点,每次调整只需要logN,调整N次,时间复杂度的量级在O(N * logN),我们来看排序一次排序是NlogN,有N次,大概在O(N logN* N)的量级。如果你直接找两个最小的,比排序还快一点N*N量级。如何构造我们不再详细赘述,在之前的思维导图中已经叙述过了。如果你对堆这种数据结构不太了解,可以看一下博主这篇博客。
c
NodeP buildHuffmanTree(ListP Head)//构造哈夫曼树
{
// 初始化最小堆,并将所有叶子节点加入堆中
Heap hp;
HeapInit(&hp);
ListP cur = Head->next;
while (cur != Head)
{
HeapPush(&hp, cur->data);
cur = cur->next;
}
//开始构造赫夫曼树
while (HeapSize(&hp) > 1) {
NodeP left = HeapTop(&hp);
HeapPop(&hp);
NodeP right = HeapTop(&hp);
HeapPop(&hp);
NodeP top = (NodeP)malloc(sizeof(Node));
top->freq = left->freq + right->freq;
top->left = left;
top->right = right;
top->high = -1;
top->low = -1;
top->code = NULL;
// 暂时不分配编码
HeapPush(&hp, top);//把新节点插入到堆中
}
// 堆中只剩一个节点,即根节点
NodeP root = HeapTop(&hp);
HeapDestory(&hp);
return root;
}
🔑 assignCodes(编码)
编码就是为叶子节点的code
写入相应的字符编码,左孩子写字符0
,右孩子写字符1
,这是前缀编码模式,可以保证我们的每个叶子节点的编码都是唯一的,不存在二义性。我们先来隆重介绍一下一个非常棒的字符串函数strdup
,如果你会使用这个函数,那简直是太酷了!
🍸 strdup函数介绍
这个函数主要做两件事,第一件事是拷贝字符串,第二件事是为这个字符串重新申请一片空间(在堆上),所以这个函数相当于是strcpy
和malloc
函数的结合,它拷贝的结束条件是\0
,并且这个函数会给\0
开一个空间。它会返回新开空间的起始地址。
- 如果我们给普通的字符指针的
\0
位置赋值,是会报错的:
c
#include<stdio.h>
int main()
{
char* s = "11";
s[2] = '\0';
return 0;
}
运行结果:
说我们非法访问了,但是字符串的结束标志不就是\0
吗,如果你不把那一个字节的空间给我,该如何处理呢?这里我们先理解为是字符指针,系统会给它开这个空间但是不允许我们访问,这也算是一种保护机制,因为字符串是以\0
来判断结束的,如果你随意更改,就会打印乱码。
- 如果我们把这个相同的字符串给
_strdup
函数,执行同样的操作,系统不会报错但是打印出来会乱码。
c
#include<stdio.h>
int main()
{
char* s = _strdup("11");
s[2] = '2';
printf("%s", s);
return 0;
}
运行结果:
这是因为我们把原先的\0
给修改了,这个函数变相的给了我们控制字符指针\0
的权利,有好处也有坏处。
- 将
strcat
和strdup
函数结合,恢复字符串特性(以\0
)结尾。
因为strcat
函数会把源字符串的\0
也拷贝进去,如果你不懂字符串拼接函数strcat
,可以看一下博主这篇博客,这里正常应该会报错因为那个字节的空间,并不是我们的。我们暂且认为这里是特殊处理,但是博主发现这个函数还是存在很大的不确定性,所以实际项目里面还是老老实实的使用malloc
和循环去计算字符串长度。
c
#include<stdio.h>
int main()
{
char* s = _strdup("11");
strcat(s, "1");
printf("%s", s);
return 0;
}
运行结果:
不再出现乱码。
🍸 编码函数实现
c
void assignCodes(NodeP root, char* code)//编码
{
if (root == NULL) return;
if (root->left == NULL && root->right == NULL) {
// 叶子节点,分配编码
root->code = _strdup(code);
}
else {
// 递归为左树和右树上的叶子节点分配编码
assignCodes(root->left, strcat(_strdup(code),"0"));
assignCodes(root->right, strcat(_strdup(code),"1"));
}
}
🔑 打印字符出现的频次
c
// 打印各个词及其出现频度的函数
// 参数:
// ListP Head - 指向链表头部的指针,链表中的每个节点存储了一个词及其相关信息
void Print_freq(ListP Head) // 打印各个词出现的频度
{
assert(Head);//Head不能为空
// cur 是一个临时指针,用于遍历链表
ListP cur = Head->next; // 从链表的第一个有效节点开始遍历(假设Head是头节点,不存储数据)
// 当cur不为空时,说明还有节点未遍历
while (cur != NULL)
{
// 检查当前节点的数据(词)是否有'low'属性(可能是指多字符的词或某种特殊标识)
if (cur->data->low == -1)
{
// 如果'low'为-1,说明只有一个字符(可能是单字符词或特殊标识),直接打印该字符和它的频度
char c = cur->data->high;
if (c == '\n' || c == '\r')
printf("\\n\\r: %d次\n", cur->data->freq);
else
printf("%c: %d次\n", cur->data->high, cur->data->freq);
}
else
{
// 如果'low'不为-1,说明是多字符的词,打印两个字符(或特殊标识)和它的频度
printf("%c%c: %d次\n", cur->data->high, cur->data->low, cur->data->freq);
}
// 移动到下一个节点
cur = cur->next;
}
}
🔑 打印字符的编码
c
// 深度优先搜索函数,用于遍历树结构
// 参数:
// NodeP root - 指向树节点的指针,该节点是遍历的起始点
void dfs(NodeP root)
{
// 如果当前节点为空(到达叶子节点的下一层或根节点之前就是空的),则直接返回
if (!root)
return;
// 如果当前节点是叶子节点(即没有左孩子和右孩子)
if (root->left == NULL && root->right == NULL)
{
// 检查节点是否有'low'属性(可能是某种辅助信息或键值)
if (root->low == -1)
{
// 如果'low'为-1,说明只有一个字符(可能是单字符词或特殊标识),直接打印该字符和它的频度
char c = root->high;
if (c == '\n' || c == '\r')//换行符特殊处理
printf("\\n\\r: %s\n",root->code);
else
printf("%c: %s\n", root->high, root->code);
}
// 如果'low'不是-1(即存在'low'属性),则按照指定格式打印
else
printf("%c%c: %s\n", root->high, root->low, root->code);
}
// 递归遍历左子树
dfs(root->left);
// 递归遍历右子树
dfs(root->right);
}
🏆 最终效果演示
🔑 菜单及调用函数实现
c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Huffman_tree.h"
char file[200] = { 0 };//存储原始文件路径
ListP Head = NULL;//链表头指针
NodeP root = NULL;//赫夫曼树的根节点指针
void Test1()//完成统计字符频次的事情
{
FILE* pf = fopen(file, "r");//打开原始文件
if (NULL == pf)//如果打开失败
{
perror("fopen");
return 1;
}
int high = 0;
int low = -1;
Head = List_Init(NULL);//带头单链表,创建它的头
while ((high = fgetc(pf)) != EOF)//开始读取文件的内容
{
if (high > 128)//如果是中文字符
low = fgetc(pf);
List_insert(Head,high,low);
low = -1;//注意要及时置为-1,因为有时候不是中文字符
}
}
void Test2()//完成打印字符频次表的工作
{
assert(Head != NULL);//Head不能为空
Print_freq(Head);
}
void Test3()//完成构建赫夫曼树,并打印每个字符对应的01编码的工作
{
assert(Head != NULL);//Head不能为空
root = buildHuffmanTree(Head);
assignCodes(root, "");//编码
dfs(root);//遍历打印
}
void Test4()//完成写入加密文件并打印加密文件的路径的工作
{
assert(Head != NULL);//Head不能为空
assert(root != NULL);//root不能为空,保证已经加密过了
FILE* pf = fopen(file, "r");//打开原始文件
if (NULL == pf)
{
perror("fopen");
return 1;
}
FILE* pfw = fopen("encryption.txt", "w");//创建加密文件,相对路径
if (NULL == pfw)
{
perror("fopen");
return 1;
}
int high = -1, low = -1;
while ((high = fgetc(pf)) != EOF)//读取文件字符
{
if (high > 128)//判断中文字符
{
low = fgetc(pf);
}
ListP cur = NULL;
cur = Head->next;
while (cur != NULL)//依次在表中找对应的字符并写入它的编码
{
if (cur->data->high == high && cur->data->low == low)
{
fputs(cur->data->code, pfw);
break;
}
cur = cur->next;
}
low = -1;//防止中文字符对英文字符产生干扰
}
printf("加密文件的路径为:D:\\code_2023_5\\test_c\\数据结构\\c++\\哈夫曼树编码\\encryption.txt\n");//打印加密文件路径,这个是自己事先就确定的
//关闭对应的文件
fclose(pfw);
fclose(pf);
pfw = NULL;
pf = NULL;
}
void Test5()//完成解密的工作,并打印解密的路径
{
assert(root != NULL);//root不为空
FILE* pfw = fopen("encryption.txt", "r");//打开加密的文件
if (NULL == pfw)
{
perror("fopen");
return 1;
}
FILE* pfD = fopen("Decoding_files.txt", "w");//创建解密文件
if (NULL == pfD)
{
perror("fopen");
return 1;
}
decode(root, pfw, pfD);//调用解密函数
printf("解密文件的路径为:D:\\code_2023_5\\test_c\\数据结构\\c++\\哈夫曼树编码\\encryption.txt\n");//打印解密文件的绝对路径
//关闭文件
fclose(pfw);
fclose(pfD);
pfw = NULL;
pfD = NULL;
}
void Test6()//完成清理资源的操作
{
Destroy_HuffmanTree(root);//清理赫夫曼树中的资源
root = NULL;
Destroy_List(Head);//清理链表中的资源
Head = NULL;
printf("清理资源成功<>\n");
}
void menu()//菜单函数
{
int instructions = 0;
printf("请输入指令以执行操作<>\n: ");
printf("***********************************************************************************************************\n");
printf("****************************1.输入要加密的文件路径(绝对路径和相对路径均可)*******************************\n");
printf("****************************2.打印字符频次表***************************************************************\n");
printf("****************************3.打印字符编码*****************************************************************\n");
printf("****************************4.输出加密01文件路径***********************************************************\n");
printf("****************************5.输出解码文件路径*************************************************************\n");
printf("****************************6.清理相关资源*****************************************************************\n");
printf("****************************7.刷新屏幕*********************************************************************\n");
printf("****************************8.结束程序*********************************************************************\n");
scanf("%d", &instructions);
switch(instructions)
{
case 1: { printf("请输入要加密的文件路径<>:\n"); scanf("%199s", file); Test1(); }
break;
case 2: Test2();
break;
case 3: Test3();
break;
case 4: Test4();
break;
case 5: Test5();
break;
case 6: Test6();
break;
case 7: system("cls");
break;
case 8: exit(0);
break;
default: printf("指令不合法,重新输入\n");
break;
}
}
int main()
{
while (1)//循环打印菜单
{
menu();
}
return 0;
}
🔑 效果展示
- 代码运行结果:
词频及字符串编码打印:
- 加密01字符串文件
- 解密文件与原文件对比结果。