文件压缩解压的哈夫曼树实现

数据结构课程设计时写的

#include
//使用时间时调用
/
#ifndef T_MS //
#define T_MS //
DWORD start,stop; //
#endif //
/

// 常量定义
/
#ifndef G_C //
#define G_C //
#define N 1000 //
#define MAX 99999 //
#endif //
/
// 统计文件中各个字符时相关结构体
///
#ifndef W_C //
#define W_C //
struct Word_Count{ //
char word ; //字符类型 //
int count ; //字符出现次数 //
}; //
struct Word_Count_Array{ //
struct Word_Count wC[N]; //
int point; //定位指针(指向数组wC中第一个空位) //
}; //
#endif //
///
// 构建Huffuman树相关结构体
/
#ifndef H_T //
#define H_T //
struct Node{ //构建哈夫曼树的节点 //
char word; //
int count; //
struct Node *leftChild,*rightChild; //
int myAdrr,lfAdrr,rgAdrr; //自己|左孩子|右孩子 Adrress //
}; //便于文件中树的生成 //
struct Node_Array{ //
struct Node node[N]; //
int point; //
}; //
struct Dynamic_Array{ //动态数组 //
int dArray[N]; //
int point; //指向数组中第一个空位 //
}; //
struct WordCode{ //存储字符以及其编 //
char word; //字符 //
int code[N]; //Huffu编码 //
int point; //指向数组中第一个空位 //
}; //
struct WordCode_Array{ //存储字符以及其编码 //
struct WordCode wCode[N]; //
int point; //指向数组中wCode第一个空位 //
}; //
struct Dynamic_Array dyArr; //辅组存储编码的动态数组 //
struct WordCode_Array wCArr; //存储字符及其编码 //
int Pos=0; //
#endif //
/


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Function Module : Statistical character frequency *
* *
* Explain : 统计字符频率(Hz),需要缓冲数组buff. *
* *
* @author: luewang *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include"GlobalVCS.h"
/**
*
* Role: compare word to count
*
* Explain: 将传入的字符与存储字符的结构体数组
* 中的字符进行比较，更新字符出现次数
* (Hz)
*
* @return: 无
*
*/
void OperateWC(struct Word_Count_Array* wCA,char word){
int i = 0;
for(; i point ; i++){
if(word==wCA->wC[i].word){
wCA->wC[i].count+=1;
break;
}
}
if(i==wCA->point){
wCA->wC[i].word=word;
wCA->wC[i].count=1;
wCA->point=i+1;
}
}
/**
*
* Role: count word
*
* Explain: 统计各个字符出现的频率(Hz)
*
* @return: 字符频率结构体数组wCA
*
*/
struct Word_Count_Array SingleChar_Hz(char buff[],int n){
struct Word_Count_Array wCA; //存储各个字符出现频数的结构体数组 *
wCA.point=0;
for(int i = 0 ; i OperateWC(&wCA,buff[i]);
}

//控制台打印统计好的字符出现的频率
printf("+----------+-----------+\n");
printf("+ wCA:字符频率统计数组 +\n");
printf("+----------+-----------+\n");
printf("| word | count |\n");
printf("+----------+-----------+\n");
for(int i = 0 ; i printf("|%10c|%11d|\n",wCA.wC[i].word,wCA.wC[i].count);
printf("+----------+-----------+\n");
}

printf("...Over.....OK...\n\n");
return wCA;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Function Module (core code) : Establishment Of Huffuman Tree. *
* *
* Explain : *
* 使用从文件中统计的字符频率的结构体数组,循环先序遍历构建Huffu- *
* -man树，并另外使用结构体数组统计各个字符哈夫曼编码。 *
* *
* @author: luewang *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include"GlobalVCS.h"
#include"GlobalVCS.h"
/**
*
* Role: Sort of Insert
*
* Explain: 利用插入排序将统计好个字符频率的结构体数组wCA
* 进行升序排序.
*
* @return: 返回后续构建树所需要的节点的数组
*
*/
struct Node_Array InsertSort(struct Word_Count_Array *wCA){
int i,j;
int tmpCount;
char tmpChar;
for(i = 1 ; i point ; i++){
tmpCount = wCA->wC[i].count;
tmpChar = wCA->wC[i].word ;
for(j = i ; j > 0 && wCA->wC[j-1].count > tmpCount ; j--){
wCA->wC[j].count = wCA->wC[j-1].count;
wCA->wC[j].word = wCA->wC[j-1].word ;
}
wCA->wC[j].count = tmpCount;
wCA->wC[j].word = tmpChar ;
}
struct Node_Array nodeArray;
for(int i = 0 ; i point ; i++){
nodeArray.node[i].count = wCA->wC[i].count;
nodeArray.node[i].word = wCA->wC[i].word ;
nodeArray.node[i].leftChild = NULL;
nodeArray.node[i].rightChild= NULL;
}
nodeArray.point = wCA->point;
return nodeArray;
}
/**
*
* Role: Sort of the specified interval
* |
* Explain: 利用插入排序指定范围,将构建哈夫曼树所需要的结
* 点的数组进行升序排序.(该函数将会被多次调用)
*
* @return: 无
*
*/
void InsertSortSE(struct Node_Array *nA,int start , int end){
if(end - start > 0){
int i,j;
int tmpCount;
char tmpChar;
struct Node *tmpLeft,*tmpRight;
for(i = start + 1 ; i <= end ; i++){
tmpCount = nA->node[i].count;
tmpChar = nA->node[i].word ;
tmpLeft = nA->node[i].leftChild;
tmpRight = nA->node[i].rightChild;
for(j = i ; j > start && nA->node[j-1].count > tmpCount ; j--){
nA->node[j].count = nA->node[j-1].count;
nA->node[j].word = nA->node[j-1].word ;
nA->node[j].leftChild = nA->node[j-1].leftChild;
nA->node[j].rightChild = nA->node[j-1].rightChild;
}
nA->node[j].count = tmpCount;
nA->node[j].word = tmpChar ;
nA->node[j].leftChild = tmpLeft ;
nA->node[j].rightChild= tmpRight;
}
}
}
/**
*
* Role: Copy Array
*
* Explain: 将数组a的指定范围(start~end)赋值给数组b该范围
*
* @return: 无
*
*/
void ArrayCopy(int a[],int b[],int start,int end){
if(end >= 0 && start >= 0 && end - start >= 0){
for(int i = start ; i <= end ; i++){
b[i] = a[i];
}
}
}
/**
*
* Role: Traverse
*
* Explain: 利用先序遍历构建哈夫曼树(根:Root) 并
* 将遍历的结果放在全局变量wCArr(保存字
* 符及其编码的数组)
*
* @return: 无
*
*/
void Traverse(struct Node* Root){
if(Root->leftChild==NULL&&Root->rightChild==NULL){ //已经到了根节点
Root->myAdrr=Pos;//
Root->rgAdrr=0;//
Root->lfAdrr=0;//
Pos+=1;//

wCArr.wCode[wCArr.point].word = Root->word;
ArrayCopy(dyArr.dArray,wCArr.wCode[wCArr.point].code,0,dyArr.point-1);
wCArr.wCode[wCArr.point].point = dyArr.point;
wCArr.point+=1;
dyArr.point-=1;

return;
}

Root->myAdrr=Pos;//
Pos+=1;//

if(Root->leftChild != NULL){
dyArr.dArray[dyArr.point] = 0;
dyArr.point+=1;
Root->lfAdrr=Pos;//
Traverse(Root->leftChild);
}
if(Root->rightChild != NULL){
dyArr.dArray[dyArr.point] = 1;
dyArr.point+=1;
Root->rgAdrr=Pos;//
Traverse(Root->rightChild);
}

dyArr.point-=1;

return ;
}
/**
*
* Role: Traverse
*
* Explain: 纯粹先序遍历树
*
* @return: 无
*
*/
void TreeT(struct Node* Root,int *count,int *max){
if(Root->leftChild==NULL&&Root->rightChild==NULL){ //已经到了根节点
printf("|%10c|%11d|\n",Root->word,Root->count);
printf("+----------+-----------+\n");

if(*max <*count){
*max = *count;
}

(*count)--;
return ;
}

printf("|%10c|%11d|\n",Root->word,Root->count);
printf("+----------+-----------+\n");

if(Root->leftChild){
(*count)++;
TreeT(Root->leftChild,count,max);
}

if(Root->rightChild){
(*count)++;
TreeT(Root->rightChild,count,max);
}

(*count)--;
return ;
}
int Traverset(struct Node* Root){
//开始时间
start =GetTickCount();

printf("Tree visting is working......\n");

printf("+----------+-----------+\n");
printf("| Visit Tree |\n");
printf("+----------+-----------+\n");
printf("| word | count |\n");
printf("+----------+-----------+\n");

if(Root==NULL){
return 0;
}

int count=1;
int max = 0;

TreeT(Root,&count,&max);

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

return max;
}
/**
*
* Role: Make a Huffuman Tree
*
* Explain: 根据存储字符频率的结构体数组wCA排序转化
* 为创建哈夫曼树所需要结点数组nodeArray,利
* 用结点数组进行多次排序并且动态增加元素构
* 建哈夫曼树
*
* @return: Root(Huffuman Tree Root)
*
*/
struct Node* HuffumanTreeBuild(struct Word_Count_Array *wCA){
//开始时间
start =GetTickCount();

struct Node_Array nodeArray = InsertSort(wCA); //对统计好的字符频率结构体数组进行排序并将排序放入nodeArray数组中

printf(">>>Building Huffuman tree is working......\n");

struct Node *Root;
for(int i = 1 ; i nodeArray.node[nodeArray.point].count = nodeArray.node[i].count + nodeArray.node[i-1].count;
nodeArray.node[nodeArray.point].leftChild = &(nodeArray.node[i-1]);
nodeArray.node[nodeArray.point].rightChild= &(nodeArray.node[i]) ;
nodeArray.node[nodeArray.point].word='~';

Root = &(nodeArray.node[nodeArray.point]);

nodeArray.point +=1;
InsertSortSE(&nodeArray,i+1,nodeArray.point-1);
if(i+1 == nodeArray.point||i+1 == nodeArray.point - 1){
break;
}
}

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

//开始时间
start =GetTickCount();

printf("Encoding is working......\n");

Traverse(Root); //遍历过程中将每个字符类型code编码存储存入全局变量wCArr中

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

return Root;
}
/**
*
* Role: Show Huffuman Code
*
* Explain: 显示(存放在全局变量wCA中的)字符编码
*
* @return: 无
*
*/
void ShowHuffumanCode(){
//开始时间
start =GetTickCount();

printf("+----------+---------------------------+\n");
printf("+ Huffuman Code +\n");
printf("+----------+---------------------------+\n");
printf("| word | code |\n");
printf("+----------+---------------------------+\n");

for(int i = 0 ; i char str = wCArr.wCode[i].word;

printf("|%-10c|",str);

int j;
for(j = 0 ; j printf("%d ",wCArr.wCode[i].code[j]);
}

for(int k = 0 ; k <27-2*j ; k++){
printf(" ");
}
printf("|\n");
printf("+--------------------------------------+\n");

}

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

}
//辅组二叉树格式二维数组形成 (树枝高度)
int F(int x){
if(x == 1){
return 1;
}else if(x == 2){
return 2;
}
if(x >= 3){
return 2*F(x-1) + 1;
}
return -1;
}
//辅组二叉树格式二维数组形成
int HelpFunc(int x,int base1,int base2,int spare){
if(x == 2){
return base1;
}else if(x == 3){
return base2;
}
if(x > 3){
return 2*HelpFunc(x-1,base1,base2,spare) + spare;
}
return -1;
}
/**
*
* Role: Draw binary tree in console
*
* Explain: 绘制二叉树在控制台
*
* @return: void
*
*/
void PaintBiTree(struct Node* Root){
//开始时间
start =GetTickCount();

int deep = Traverset(Root); //树的深度
int branch; //枝长
int baseW = HelpFunc(deep,4,11,1);//数组宽度{ f(2) = 4 f(3) = 11 f(n) = 2*f(n-1) + 1 (n>=2) }
int deepH = HelpFunc(deep,3,6,0); //数组高度{ f(2) = 3 f(3) = 6 f(n) = 2*f(n-1) (n>=2) }

//printf("deepH = %d baseW = %d\n",deepH,baseW);

struct Node *treeDim[deepH][baseW],*tmpL,*tmpR;

tmpL =(struct Node*)malloc(sizeof(struct Node));
tmpR =(struct Node*)malloc(sizeof(struct Node));
tmpL->word='\\';
tmpR->word='\/';
for(int i = 0 ; i for(int j = 0 ; j treeDim[i][j]=NULL;
}
}

treeDim[0][baseW/2] = Root;


//二叉树格式创建
int floor;
for(int i = 0,floor = 1 ; floor <= deep; floor++,i+=branch+1){
for(int j = 0 ; j if(treeDim[i][j]!=NULL){
if(treeDim[i][j]->leftChild!=NULL){ //左孩子
branch = F(deep - floor );
for(int k = 1 ; k <= branch ; k++){
treeDim[i+k][j-k] = tmpL;
}
treeDim[i+branch+1][j-branch-1] = treeDim[i][j]->leftChild;
}
if(treeDim[i][j]->rightChild!=NULL){ //右孩子
branch = F(deep - floor);
for(int k = 1 ; k <= branch ; k++){
treeDim[i+k][j+k] = tmpR;
}
treeDim[i+branch+1][j+branch+1] = treeDim[i][j]->rightChild;
}
}
}
}

//根据二维数组打印二叉树格式
for(int i = 0 ; i for(int j = 0 ; j if(treeDim[i][j]==NULL){
printf(" ");
}else if(treeDim[i][j]==tmpL){
printf("\/");
}else if(treeDim[i][j]==tmpR){
printf("\\");
}else if(treeDim[i][j]!=NULL){
printf("%c",treeDim[i][j]->word);
}
}
printf("\n");
}

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

getchar();
}

/* * * * * * * * * * * * * * * * * * * * * * * *
* *
* Function Module : <> File Operation *
* *
* Explain : 文件操作模块 *
* *
* @author: luewang *
* *
* * * * * * * * * * * * * * * * * * * * * * * */
#include"GlobalVCS.h"
/**
*
* Role: read word from src to buff
*
* Explain: 从文件中读入字符并将其存入buff数组中
*
* @return: buff
*
*/
char* FileInputStream(char* src){
//开始时间
start =GetTickCount();

FILE *file;
char buff[MAX];

if((file = fopen(src,"r"))==NULL){
printf("Error : Open File %s is Faile To Open!!! \n",src);
}

printf(">>>Open File directory is : %s \n",src);

int ch , count;
printf("\n-+-+-+-+-+-+-+Content-+-+-+-+-+-+-+-\n"); //显示从文件中读出的内容
for(count = 0;(ch=fgetc(file))!=EOF;count++){
buff[count] = ch;
printf("%c",ch);
}
printf("\n-+-+-+-+-+-+-+-End+-+-+-+-+-+-+-+-+-+-\n");

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

fclose(file);
return buff;
}
/**
*
* Role: file visit and save tree
*
* Explain: 先序遍历保存构建好的哈夫曼树
*
* @return: 无
*
*/
void SaveTreeVisit(struct Node *Root,FILE *file){
if(Root->leftChild==NULL&&Root->rightChild==NULL){ //叶子节点

printf("|%10c|%11d|%12d|%12d|%12d|\n",Root->word,Root->count,Root->myAdrr
,Root->lfAdrr,Root->rgAdrr);
printf("+----------+-----------+------------+------------+------------+\n");

fwrite(Root,sizeof(struct Node),1,file);

return;
}

printf("|%10c|%11d|%12d|%12d|%12d|\n",Root->word,Root->count,Root->myAdrr
,Root->lfAdrr,Root->rgAdrr);
printf("+----------+-----------+------------+------------+------------+\n");

fwrite(Root,sizeof(struct Node),1,file);
SaveTreeVisit(Root->leftChild,file);
SaveTreeVisit(Root->rightChild,file);
}
/**
*
* Role: save huffuman tree to file
*
* Explain: 将根节点是Root的树保存到dir路径文件中.
*
* @return : 无
*
*/
void SaveHuffumanTree(char *dir,struct Node *Root){
//开始时间
start =GetTickCount();

FILE *file;

if((file = fopen(dir,"wb+")) == NULL){
printf("Error : Save File %s is Faile To Open!!! \n",dir);
}
printf(">>>Save File directory is : %s \n",dir);

printf("+----------+-----------+------------+------------+------------+\n");
printf("| word | count | myAdrr | lfAdrr | rgAdrr |\n");
printf("+----------+-----------+------------+------------+------------+\n");

SaveTreeVisit(Root,file);

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

fclose(file);
}
/**
*
* Role: File Visit And Get Tree
*
* Explain: 从文件中取出哈夫曼树节点信息放入tmpRoot数组中
* 通过tmpRoot数组中构建哈夫曼树 , tmpRoot数组每
* 个元素存储了左右孩子和自己的地址(int)
*
* @return : tmpRoot头结点(哈夫曼树根结点)
*
*/
struct Node* GetTreeVisit(FILE *file){
int point = 0;
struct Node tmpRoot[N];
while(fread(&tmpRoot[point],sizeof(struct Node),1,file)!=NULL){

if(tmpRoot[point].lfAdrr==0&&tmpRoot[point].rgAdrr==0){
printf("|%10c|%11d|\n",tmpRoot[point].word,tmpRoot[point].count);
printf("+----------+-----------+\n");
}

point+=1;
}

for(int i = 0 ; i if(tmpRoot[i].lfAdrr == 0){
tmpRoot[i].leftChild = NULL;
}else if(tmpRoot[i].lfAdrr != 0){
for(int j = i + 1 ; j if(tmpRoot[j].myAdrr == tmpRoot[i].lfAdrr){
tmpRoot[i].leftChild = &tmpRoot[j];
break;
}
}
}
if(tmpRoot[i].rgAdrr == 0){
tmpRoot[i].rightChild = NULL;
}else if(tmpRoot[i].rgAdrr != 0){
for(int j = i + 1 ; j if(tmpRoot[j].myAdrr == tmpRoot[i].rgAdrr){
tmpRoot[i].rightChild = &tmpRoot[j];
break;
}
}
}
}
return tmpRoot;
}
/**
*
* Role: Get Huffuman Tree
*
* Explain: 从指定(*.dat)文件中获取获取哈夫曼树,给该树
* 根结点Root赋值 .
*
* @return : 无
*
*/
void GetHuffumanTree(char *dir,struct Node **Root){
//开始时间
start =GetTickCount();
FILE *file;

file = fopen(dir,"rb+");
if(file==NULL){
printf("Error : Get File Open is failed To Open : %s\n",dir);
}
printf(">>>Get File directory is : %s \n",dir);

printf("+----------+-----------+\n");
printf("| word | count |\n");
printf("+----------+-----------+\n");

*Root = GetTreeVisit(file); //哈夫曼树根结点

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

fclose(file);
}
/**
*
* Role: word zip
*
* Explain: 将指定字符ch根据哈夫曼树编码(wCArr)进行压缩至
* 文件 huffuFile 中.
*
* @return : 无
*
*/
void ZIP(int ch,FILE *huffuFile){
for(int i = 0 ; i if(ch == wCArr.wCode[i].word){
for(int j = 0 ; j
printf("%d",wCArr.wCode[i].code[j]);

fputc(wCArr.wCode[i].code[j]+48,huffuFile);
}
}
}
}
/**
*
* Role: file zip
*
* Explain: 指定文件路径src进行文件压缩至一个新的文
* 件中huffuFile
*
* @return : 无
*
*/
void FileZip(char* src){
//开始时间
start =GetTickCount();

FILE *file,*huffuFile;

if((file = fopen(src,"r+")) == NULL){
printf("Error : File %s Open is failed!!!\n",src);
}
printf(">>>ZIP File directory is : %s \n",src);

char dir[strlen(src)+5];
strcpy(dir,src);
dir[strlen(dir)-4]='\0';
strcat(dir,"_hf.txt");

if((huffuFile = fopen(dir,"w+")) == NULL){
printf("Error : Zipped File %s Open is failed!!!\n",dir);
}
printf(">>>Zipped File directory is : %s \n",dir);

int ch;

printf("\n-+-+-+-fake Binary l stream-+-+-+-+-\n");
while((ch=fgetc(file))!=EOF){
ZIP(ch,huffuFile);
}
printf("\n-+-+-+-+-+-+-+-End+-+-+-+-+-+-+-+-+-\n");

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);

fclose(file);
fclose(huffuFile);
}
/**
*
* Role: file unzip
*
* Explain: 将指定哈夫曼 0 1 文件(huffuFile)进行哈夫曼树解
* 码存入file文件中
*
* @return : 无
*
*/
void UnZIP(struct Node *Root,FILE *huffuFile,FILE *file){
struct Node *root = Root; //哈夫曼树根结点
int ch;
while((ch=fgetc(huffuFile))!=EOF){
printf("%c",ch);
if(ch - 48 == 0){
root=root->leftChild;
}else if(ch - 48 == 1){
root=root->rightChild;
}

if(root->rightChild==NULL&&root->leftChild==NULL){ //已经到了叶节点
fputc(root->word,file);
root=Root; //回到根节点
}
}
}
/**
*
* Role: file unzip
*
* Explain: 对给定文件路径进行哈夫曼树解压 Root:
* 为哈夫曼树根结点
*
* @return : 无
*
*/
void FileUnZip(char* dir,struct Node *Root){
//开始时间
start =GetTickCount();

FILE *file,*huffuFile;

if((huffuFile = fopen(dir,"r+")) == NULL){
printf("Unzip File Open is failed : %s\n",dir);
}
printf(">>>Unzip File directory is : %s \n",dir);

char Dir[strlen(dir)];
strcpy(Dir,dir);
Dir[strlen(dir)-7]='\0';
strcat(Dir,"`.txt");

printf("After UnZip FIle Is %s\n",Dir);

if((file= fopen(Dir,"w+")) == NULL){
printf("Unzipped File Open is failed : %s\n",Dir);
}
printf(">>>Unzipped File directory is : %s \n",Dir);

UnZIP(Root,huffuFile,file);
printf("\n");

//结束时间
stop =GetTickCount();
printf("...Over.....OK...(%lld ms)\n\n",stop-start);
fclose(file);
fclose(huffuFile);
}

#include
#include
#include
#include
#include"FileOperate.h"
#include"WordHzCount.h"
#include"HuffuTreeBuild.h"
//文件压缩项
void ZIPFILE(char *src){
char dir[strlen(src)+1]; //保存哈夫曼树的文件路径
strcpy(dir,src);
dir[strlen(dir)-4]='\0';
strcat(dir,".dat");

char *buff = FileInputStream(src); //获取指定文件中的资源
struct Word_Count_Array wCA = SingleChar_Hz(buff,strlen(buff));//统计指定资源文件中的字符出现频率
struct Node* Root = HuffumanTreeBuild(&wCA); //构建哈夫曼树Root 并且将字符编码存入全局wCA中
SaveHuffumanTree(dir,Root); //将哈夫曼树存入文件中去
ShowHuffumanCode(); //展示字符编码
PaintBiTree(Root); //展示哈夫曼树

FileZip(src); //文件压缩

}
//文件解压项
void UNZIPFILE(char *dir){
char huffile[strlen(dir)+10]; //保存哈夫曼树的文件路径
strcpy(huffile,dir);
huffile[strlen(huffile)-7]='\0';
strcat(huffile,".dat");

struct Node *root; //哈夫曼树根结点
GetHuffumanTree(huffile,&root);

FileUnZip(dir,root); //文件解压

PaintBiTree(root); //展示哈夫曼树
}
//帮助
void HELP(){
printf("\nYou need to enter two parameters.\n");
printf("The first parameter is the functional option(the following values are available).\n");
printf("'-zip' Or '-unzip' which means decompression and compression.\n");
printf("The second parameter is the filepath option(such as : 'D:\\a.txt').\n");
printf("It is important to note that the input format cannot have any extra Spaces, and the format is '-option' 'path'\n");
}
int main() {

printf("Welcome to Huffman coding by Wang.\nNotice : you can use the '-help' for help.\nLanguage: C \nAuthor : luewang \nVersion : 1.0\n");
char option[N];
char path[N];
while(1){
printf("WHuff>>>");
scanf("%s",option);

if(strcmp(option,"-help")==0){
HELP();
}else if(strcmp(option,"-zip")==0){
scanf("%s",path);
ZIPFILE(path);
}else if(strcmp(option,"-unzip")==0){
scanf("%s",path);
UNZIPFILE(path);
}else if(strcmp(option,"exit")==0){
exit(0);
}else{
printf("Error: Please input the correct format. You can also use '-help' to view the help document\n");
}
}
return 0;
}