有一说一，我太菜了，编码花了我十几个个小时才完成，终究是我不配了。
今天花了点时间，把哈夫曼树的编码和译码也完成了，后续会补充一下注释。
哈夫曼编码译码终于完结了。译码和源文件大小一致了，把换行符也加上去了。结。
运行结果和文件存储如下：
译码文件和源文化大小也一致：
区别：简陋版的和完全版的头文件完全一样。简陋版是以频率为权重，完结版是自己给字符设置权重
完全版创建文件来存放编码和存放译码（现已实现换行符功能）
完全版的源文件：
#include "优先权队列.h"
#include "哈夫曼的stack.h"
//构造一棵空的二叉树
void Create(BinaryTree* bt)
{
bt->root = NULL;
}
HFMTNode* NewBTNode(ElemType w, HFMTNode* lC, HFMTNode* rC)
{
HFMTNode* p = (HFMTNode*)malloc(sizeof(HFMTNode));
p->w = w;
p->lChild = lC;
p->rChild = rC;
p->Element = 0;
return p;
}
void MakeTree(BinaryTree* bt, ElemType w, BinaryTree* left, BinaryTree* right)
{
if (left == NULL || right == NULL)
return;
else
{
bt->root = NewBTNode(w, left->root, right->root);
left->root = right->root = NULL;
}
}
//哈夫曼先序遍历
void PreOrder(HFMTNode* t)
{
if (!t)
return;
printf("%d ", t->w);
PreOrder(t->lChild);
PreOrder(t->rChild);
}
void PreOrderHFMTree(BinaryTree* bt)
{
printf("\n先序遍历哈夫曼树的结果为：\n");
PreOrder(bt->root);
}
// 哈夫曼中序遍历
void InOrder(HFMTNode* t)
{
if (!t)
return;
InOrder(t->lChild);
printf("%d ", t->w);
InOrder(t->rChild);
}
void InOrderHFMTree(BinaryTree* bt)
{
printf("\n中序遍历哈夫曼树的结果为：\n");
InOrder(bt->root);
}
//构造哈夫曼树算法
void CreateHFMTree(BinaryTree* bt, int w[], int m)
{
PriorityQueue PQ; //定义优先权队列PQ，用于存放二叉树根节点指针
BinaryTree x, h, g; //x,y,z为二叉树变量
int size;
Create(&h);
Create(&g);
CreatePQ(&PQ, m); // 初始化优先权队列PQ，设优先权值存在于根节点的数据域
for (int i = 0; i < m; i++)
{
if (w[i] != 0)
{
MakeTree(&x, w[i], &h, &g);
Append(&PQ, x.root); //把传进来的数组里面的每一个元素都当做权值放入优先权队列中
}
}
printf("原森林为：\n");
for (int i = 0; i < PQ.n; i++)
{
printf("%d ", PQ.elements[i].w);
}
printf("\n");
while (PQ.n > 1)
{
HFMTNode* X = NewBTNode(0, NULL, NULL);
HFMTNode* Y = NewBTNode(0, NULL, NULL);
HFMTNode* Z = NewBTNode(0, NULL, NULL);
Serve(&PQ, X); //取出此时权值最小的
Serve(&PQ, Y); //取出此时权值最小的
//下面进行合并节点操作，再讲新的值放入优先权队列
if (X->w < Y->w)
{
Z->w = X->w + Y->w;
Z->lChild = X;
Z->rChild = Y;
Append(&PQ, Z);
}
else
{
Z->w = X->w + Y->w;
Z->lChild = Y;
Z->rChild = X;
Append(&PQ, Z);
}
}
*bt->root = PQ.elements[0];
}
//进行哈夫曼编码
HFMTNode* HFMBMFirst(BinaryTree* tree, Stack* S, char* temp, int* index, int* w, int length, int* frequency)
{
int fre = *frequency;
HFMTNode* p = tree->root;
if (!p || (fre >= length))
return NULL;
int k = *index;
while (p->lChild != NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
HFMTNode* HFMBMNext(HFMTNode* current, Stack* S, char* temp, int* index, int* w, int length, int* frequency)
{
int fre = *frequency;
int k = *index;
HFMTNode* change, * again = current;
HFMTNode* p;
BinaryTree h, i, j;
Create(&h);
Create(&i);
Create(&j);
MakeTree(&h, 'H', &i, &j);
change = h.root;
if (current->rChild && current->Element != 1 && (fre < length))
{
current->Element = 1;
stackPush(S, current);
p = current->rChild;
temp[k++] = '1';
while (p->lChild != NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
else if ((fre < length) && (!stackIsEmpty(S)))
{
stackTop(S, change);
stackPop(S);
if ((change->rChild) && (change->Element != 1) && (fre < length))
{
temp[--k] = '\0';
change->Element = 1;
stackPush(S, change);
p = change->rChild;
temp[k++] = '1';
while (p->lChild != NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
else if (change->rChild && change->Element == 1 && (fre < length))
{
while (change->Element == 1 && (fre < length))
{
stackTop(S, change);
stackPop(S);
temp[--k] = '\0';
}
if ((change->rChild) && (change->Element != 1) && (fre < length))
{
temp[--k] = '\0';
change->Element = 1;
stackPush(S, change);
change = change->rChild;
temp[k++] = '1';
while (change->lChild != NULL)
{
stackPush(S, change);
change = change->lChild;
temp[k++] = '0';
}
}
*w = change->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return change;
}
}
else
{
p = current;
p->w = 0;
return p;
}
}
void HFMBMAll(BinaryTree* bt, int* list, int length, char BMofchar[128][16])
{
char temp[STACKSIZE] = "";
int index = 0;
int w = 0;
int frequency = 0;
Stack S;
stackCreate(&S, STACKSIZE);
HFMTNode* current = HFMBMFirst(bt, &S, temp, &index, &w, length, &frequency);
while (current->w != 0)
{
for (int i = 0; i < 128; i++)
{
if (w == list[i])
{
printf("%c的编码是", i);
puts(temp);
printf("其权重为%d", w);
for (int j = 0; temp[j] != '\0'; j++)
{
BMofchar[i][j] = temp[j];
}
printf("\n");
puts(BMofchar[i]);
printf("\n");
}
}
current = HFMBMNext(current, &S, temp, &index, &w, length, &frequency);
}
}
void main()
{
//给每一个字符定义一个权重
int ASCll[128] = {
0 };
for (int i = 0; i < 128; i++)
{
ASCll[i] = i;
}
char BMofchar[128][16] = {
"" }; //将每个字符的编码存储到此二维字符数组中
char temp1[3] = "";
int length = 127;
int list[] = {
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26 };
BinaryTree bt, h, i, bt1;
Create(&bt);
Create(&bt1);
Create(&h);
Create(&i);
MakeTree(&bt, 0, &h, &i);
MakeTree(&bt1, 0, &h, &i);
//CreateHFMTree(&bt, list, 26);
//PreOrderHFMTree(&bt);
//InOrderHFMTree(&bt);
CreateHFMTree(&bt1, ASCll, 128);
PreOrderHFMTree(&bt1);
InOrderHFMTree(&bt1);
printf("\n");
HFMBMAll(&bt1, ASCll, length, BMofchar);
for (int i = 0; i < 128; i++)
{
printf("%c:", i);
puts(BMofchar[i]);
}
printf("asdghiu");
char str[500] = "";
FILE* fp1, * fp2, * fp3;
fopen_s(&fp1, "C:\\Users\\HP\\Desktop\\数据结构实验报告\\text.txt", "r");
fopen_s(&fp2, "C:\\Users\\HP\\Desktop\\数据结构实验报告\\secret.txt", "a+");
if (fp1 == 0 || fp2 == 0)
{
printf("file error\n");
exit(1);
}
while (!feof(fp1))
{
fgets(str, 300, fp1);
for (int i = 0; str[i] != '\0'; i++)
{
temp1[0] = str[i];
int direction = int(temp1[0]);
for (int num = 0; num < 128; num++)
{
if (num == direction)
{
fputs(BMofchar[num], fp2);
//printf("%d ", direction);
}
}
}
}
//puts(str);
fclose(fp1);
fclose(fp2);
printf("编码已完成并保存到secret.txt\n");
//实行哈夫曼译码算法如下：
fopen_s(&fp2, "C:\\Users\\HP\\Desktop\\数据结构实验报告\\secret.txt", "r");
fopen_s(&fp3, "C:\\Users\\HP\\Desktop\\数据结构实验报告\\re_text.txt", "a+");
if (fp2 == 0 || fp3 == 0)
{
printf("file error\n");
exit(1);
}
char transfer[300] = "";
char temp2[11] = "";
int Y = 0;
char thischar[3] = "";
fgets(transfer, 300, fp2);
for (int i = 0; !feof(fp2); i++)
{
temp2[Y++] = transfer[i];
temp2[Y] = '\0';
//每次添加一个字符都要判断temp2是否和BMofchar中的元素是否相等
for (int num = 0; num < 128; num++)
{
if (strcmp(temp2, BMofchar[num]) == 0)
{
thischar[0] = num;
//printf("%c",num+32);
fputs(thischar, fp3);
Y = 0;
}
}
if (transfer[i + 1] == '\0')
{
fgets(transfer, 300, fp2);
i = -1;
}
}
for (int i = 0; transfer[i] != '\0'; i++)
{
temp2[Y++] = transfer[i];
temp2[Y] = '\0';
for (int num = 0; num < 128; num++)
{
if (strcmp(temp2, BMofchar[num]) == 0)
{
thischar[0] = num;
//printf("%c",num);
fputs(thischar, fp3);
Y = 0;
}
}
}
printf("译码已完成，译码已放入re_text.txt中\n");
printf("搞定，爷太开心了！！！");
fclose(fp2);
fclose(fp3);
}
简陋版运行结果如下
简陋版统计a~z频率的哈夫曼树源文件：
#include "优先权队列.h"
#include "哈夫曼的stack.h"
//构造一棵空的二叉树
void Create(BinaryTree* bt)
{
bt->root = NULL;
}
HFMTNode* NewBTNode(ElemType w, HFMTNode* lC, HFMTNode* rC)
{
HFMTNode* p = (HFMTNode*)malloc(sizeof(HFMTNode));
p->w = w;
p->lChild = lC;
p->rChild = rC;
p->Element = 0;
return p;
}
void MakeTree(BinaryTree* bt,ElemType w, BinaryTree* left, BinaryTree* right)
{
if (left == NULL || right == NULL)
return;
else
{
bt->root = NewBTNode(w, left->root,right->root);
left->root = right->root = NULL;
}
}
//哈夫曼先序遍历
void PreOrder(HFMTNode* t)
{
if (!t)
return;
printf("%d ", t->w);
PreOrder(t->lChild);
PreOrder(t->rChild);
}
void PreOrderHFMTree(BinaryTree* bt)
{
printf("\n先序遍历哈夫曼树的结果为：\n");
PreOrder(bt->root);
}
// 哈夫曼中序遍历
void InOrder(HFMTNode* t)
{
if (!t)
return;
InOrder(t->lChild);
printf("%d ", t->w);
InOrder(t->rChild);
}
void InOrderHFMTree(BinaryTree* bt)
{
printf("\n中序遍历哈夫曼树的结果为：\n");
InOrder(bt->root);
}
//构造哈夫曼树算法
void CreateHFMTree(BinaryTree*bt,int w[], int m)
{
PriorityQueue PQ; //定义优先权队列PQ，用于存放二叉树根节点指针
BinaryTree x,h,g; //x,y,z为二叉树变量
int size;
Create(&h);
Create(&g);
CreatePQ(&PQ, m); // 初始化优先权队列PQ，设优先权值存在于根节点的数据域
for (int i = 0; i < m; i++)
{
if (w[i] != 0)
{
MakeTree(&x, w[i], &h, &g);
Append(&PQ, x.root); //把传进来的数组里面的每一个元素都当做权值放入优先权队列中
}
}
printf("原森林为：\n");
for (int i = 0; i < PQ.n; i++)
{
printf("%d ", PQ.elements[i].w);
}
printf("\n");
while (PQ.n > 1)
{
HFMTNode* X = NewBTNode(0 ,NULL, NULL);
HFMTNode* Y = NewBTNode(0, NULL, NULL);
HFMTNode* Z = NewBTNode(0, NULL, NULL);
Serve(&PQ, X); //取出此时权值最小的
Serve(&PQ, Y); //取出此时权值最小的
//下面进行合并节点操作，再讲新的值放入优先权队列
if (X->w < Y->w)
{
Z->w = X->w + Y->w;
Z->lChild = X;
Z->rChild = Y;
Append(&PQ, Z);
}
else
{
Z->w = X->w + Y->w;
Z->lChild = Y;
Z->rChild = X;
Append(&PQ, Z);
}
}
*bt->root = PQ.elements[0];
}
//进行哈夫曼编码
HFMTNode* HFMBMFirst(BinaryTree *tree,Stack *S,char * temp,int * index,int *w,int length,int *frequency)
{
int fre = *frequency;
HFMTNode* p = tree->root;
if (!p||(fre>=length))
return NULL;
int k = *index;
while (p->lChild!=NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
HFMTNode* HFMBMNext(HFMTNode* current, Stack* S, char* temp, int* index, int* w, int length, int* frequency)
{
int fre = *frequency;
int k = *index;
HFMTNode* change, * again = current;
HFMTNode* p;
BinaryTree h, i, j;
Create(&h);
Create(&i);
Create(&j);
MakeTree(&h, 'H', &i, &j);
change = h.root;
if (current->rChild && current->Element != 1 && (fre < length))
{
current->Element = 1;
stackPush(S, current);
p = current->rChild;
temp[k++] = '1';
while (p->lChild != NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
else if ((fre < length) && (!stackIsEmpty(S)))
{
stackTop(S, change);
stackPop(S);
if ((change->rChild) && (change->Element != 1) && (fre < length))
{
temp[--k] = '\0';
change->Element = 1;
stackPush(S, change);
p = change->rChild;
temp[k++] = '1';
while (p->lChild != NULL)
{
stackPush(S, p);
p = p->lChild;
temp[k++] = '0';
}
*w = p->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return p;
}
else if (change->rChild && change->Element == 1 && (fre < length))
{
while (change->Element == 1 && (fre < length))
{
stackTop(S, change);
stackPop(S);
temp[--k] = '\0';
}
if ((change->rChild) && (change->Element != 1) && (fre < length))
{
temp[--k] = '\0';
change->Element = 1;
stackPush(S, change);
change = change->rChild;
temp[k++] = '1';
while (change->lChild != NULL)
{
stackPush(S, change);
change = change->lChild;
temp[k++] = '0';
}
}
*w = change->w;
temp[k] = '\0';
*index = k;
fre++;
*frequency = fre;
return change;
}
}
else
{
p = current;
p->w = 0;
return p;
}
}
void HFMBMAll(BinaryTree* bt,int * list,int length, char BMofchar[26][18])
{
char temp[STACKSIZE] = "";
int index = 0;
int w=0;
int frequency = 0;
Stack S;
stackCreate(&S, STACKSIZE);
HFMTNode* current = HFMBMFirst(bt, &S, temp, &index,&w,length,&frequency);
while (current->w!=0)
{
for (int i = 0; i < 26; i++)
{
if (w == list[i])
{
printf("%c的编码是", i + 97);
puts(temp);
printf("其权重为%d\n\n", w);
for (int j = 0; temp[j] != '\0'; j++)
{
BMofchar[i][j] = temp[j];
}
}
}
current = HFMBMNext(current, &S, temp, &index, &w,length,&frequency);
}
}
void main()
{
int list[] = {
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26};
BinaryTree bt,h,i,bt1;
Create(&bt);
Create(&bt1);
Create(&h);
Create(&i);
MakeTree(&bt, 0, &h, &i);
MakeTree(&bt1, 0, &h, &i);
CreateHFMTree(&bt,list, 26);
PreOrderHFMTree(&bt);
InOrderHFMTree(&bt);
printf("\n");
char str[200000];
char BMofchar[26][18] = {
};
printf("\n请输入你想进行哈夫曼编码的字符串：\n");
gets_s(str);
int length = 0;
int num[128] = {
0 };
for (int i = 0; str[i] != '\0'; i++)
{
num[str[i]]++;
}
int list2[26] = {
0 };
for (int i = 97; i < 123; i++)
{
if (num[i] != 0)
list2[i - 97] = num[i];
}
for (int i = 0; i < 26; i++)
{
printf("%c:%d ",i+97, list2[i]);
if (list2[i] != 0)
{
length++;
}
}
printf("\n\n");
CreateHFMTree(&bt1, list2,26);
PreOrderHFMTree(&bt1);
InOrderHFMTree(&bt1);
printf("\n\n");
HFMBMAll(&bt1,list2,length,BMofchar);
//输出哈夫曼编码算法如下：
char AllBM[100000] = "";
char temp1[20] = "";
printf("此时存在已有的编码为：\n");
for (int i=0; i < 26; i++)
{
if (BMofchar[i][0] != '\0')
puts(BMofchar[i]);
}
/*
for (int i = 0; str[i] != '\0'; i++)
{
printf("%c", str[i]);
}*/
printf("\n");
for (int i = 0; str[i] != '\0'; i++)
{
temp1[0] = str[i];
int direction = int(temp1[0])-97;
for (int num = 0; num < 26; num++)
{
if (num == direction)
{
strcat_s(AllBM, BMofchar[direction]);
//printf("%s ", BMofchar[direction]);
}
}
}
printf("\n");
printf("字符转换为哈夫曼编码后的数据为：\n");
puts(AllBM);
printf("\n");
//下面进行哈夫曼译码操作：
printf("哈夫曼译码之后结果为：\n");
char temp2[20] = "";
char AllYM[100000] = "";
int Y = 0;
char thechar[18] = "";
for (int i = 0; AllBM[i] != '\0'; i++)
{
temp2[Y++] = AllBM[i];
temp2[Y] = '\0';
for (int num = 0; num < 26; num++)
{
if (strcmp(temp2, BMofchar[num])==0)
{
thechar[0] = char(num + 97);
strcat_s(AllYM, thechar);
Y = 0;
}
}
}
puts(AllYM);
}
注意：此哈夫曼树是以小写字符a~z出现的频率为权重，所以当出现字符权重相等时，编码会出现一定的问题，所以切勿使字符出现频率相等。
优先权队列.h:
#pragma once
#include "HFMBTNODE.h"
typedef struct priorityQueue
{
HFMTNode* elements;
int n;
int maxSize;
}PriorityQueue;
void AdjustUp(HFMTNode heap[], int current)
{
int p = current;
HFMTNode temp;
while (p > 0)
{
if (heap[p].w < heap[(p - 1) / 2].w)
{
temp = heap[p];
heap[p] = heap[(p - 1) / 2];
heap[(p - 1) / 2] = temp;
p = (p - 1) / 2; //将p向上移动至当前考查元素的双亲节点位置
}
else //若p指向的元素不小于其双亲节点，则调整完毕
break;
}
}
void AdjustDown(HFMTNode heap[], int current, int border)
{
int p = current;
int minChild;
HFMTNode temp;
while (2 * p + 1 <= border)
{
if ((2 * p + 2 <= border) && (heap[2 * p + 1].w > heap[2 * p + 2].w))
{
minChild = 2 * p + 2;
}
else
{
minChild = 2 * p + 1;
}
if (heap[p].w <= heap[minChild].w)
{
break;
}
else
{
temp = heap[p];
heap[p] = heap[minChild];
heap[minChild] = temp;
p = minChild;
}
}
}
//创建一个空的优先权队列
void CreatePQ(PriorityQueue* PQ, int mSize)
{
PQ->maxSize = mSize;
PQ->n = 0;
PQ->elements = (HFMTNode *)malloc(mSize * sizeof(HFMTNode));
}
// 销毁一个优先权队列，释放其占用的空间
void Destory(PriorityQueue* PQ)
{
free(PQ->elements);
PQ->n = 0;
PQ->maxSize = 0;
}
//判断优先权队列是否为空
BOOL IsEmpty(PriorityQueue* PQ)
{
if (PQ->n == 0)
return TRUE;
else
return FALSE;
}
//判断优先权队列是否已满
BOOL IsFull(PriorityQueue* PQ)
{
if (PQ->n == PQ->maxSize)
return TRUE;
else
return FALSE;
}
//获取当前优先权队列中的元素的数量
int Size(PriorityQueue* PQ)
{
return PQ->n;
}
//在优先权队列中增加一个新元素x
void Append(PriorityQueue* PQ, HFMTNode *x)
{
if (IsFull(PQ))
return;
PQ->elements[PQ->n] = *x;
PQ->n++;
AdjustUp(PQ->elements, PQ->n - 1);
}
//取出优先级最高的元素，利用参数x返回，并在优先权队列中删除该元素
void Serve(PriorityQueue* PQ, HFMTNode* x)
{
if (IsEmpty(PQ))
return;
*x = PQ->elements[0];
PQ->n--;
PQ->elements[0] = PQ->elements[PQ->n];
AdjustDown(PQ->elements, 0, PQ->n - 1);
}
哈夫曼的stack.h:
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include "HFMBTNODE.h"
#define STACKSIZE 100
typedef struct Stack
{
int top;
int maxSize;
HFMTNode* element;
}Stack;
void stackCreate(Stack* S, int mSize)
{
S->maxSize = mSize;
S->element = (HFMTNode*)malloc(sizeof(HFMTNode) * mSize);
S->top = -1;
}
void stackDestory(Stack* S)
{
S->maxSize = 0;
S->top = -1;
free(S->element);
}
BOOL stackIsEmpty(Stack* S)
{
return S->top == -1;
}
BOOL stackIsFULL(Stack* S)
{
return S->top == S->maxSize - 1;
}
BOOL stackTop(Stack* S, HFMTNode* x)
{
if (stackIsEmpty(S))
{
return FALSE;
}
*x = S->element[S->top];
return TRUE;
}
BOOL stackPush(Stack* S, HFMTNode *x)
{
if (stackIsFULL(S))
return FALSE;
S->top++;
S->element[S->top] = *x;
return TRUE;
}
BOOL stackPop(Stack* S)
{
if (stackIsEmpty(S))
return FALSE;
S->top--;
return TRUE;
}
void Clear(Stack* S)
{
S->top = 1;
}
HFMBTNODE.h:
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string>
typedef int ElemType;
typedef int BOOL;
#define TRUE 1
#define FALSE 0
typedef struct hfmTNode
{
int Element;
int w;
struct hfmTNode* lChild;
struct hfmTNode* rChild;
}HFMTNode;
typedef struct binarytree
{
HFMTNode* root;
}BinaryTree;
上半部分介绍了哈夫曼的中序遍历等
哈夫曼编码已完成，译码已完成，更新完毕，由此结束。
转载：https://blog.csdn.net/VAEaaaa/article/details/115605896
查看评论