文章目录
- 一.哈夫曼编码原理
- 哈夫曼二叉树构建
- 二.具体代码实现
一.哈夫曼编码原理
哈夫曼编码（Huffman Coding）是一种用于数据压缩的编码方法，它通过给出不同的数据符号分配不同长度的编码，使得出现频率高的符号具有较短的编码，而出现频率低的符号具有较长的编码，从而达到压缩数据的目的。
哈夫曼编码的原理可以通过以下步骤来解释：
统计频率：首先，需要统计待编码数据中每个符号的出现频率。符号可以是字符、字节或其他数据单元。统计频率可以通过遍历整个数据集来完成，并记录每个符号出现的次数。
构建编码树：根据符号的频率构建一个特殊的二叉树，称为哈夫曼树（Huffman Tree）或编码树。构建编码树的方法是将频率最低的两个符号合并为一个新节点，该节点的频率为两个节点频率之和。将新节点插入到已有节点的集合中，重复这个步骤，直到只剩下一个节点，即根节点为止。在构建过程中，可以使用优先队列或最小堆来维护频率最低的节点。
分配编码：从根节点开始，沿着左子树走为0，沿着右子树走为1，将0和1分别分配给左右子节点。重复这个过程，直到遍历到每个叶子节点为止。每个叶子节点的路径上的0和1的序列就是对应符号的哈夫曼编码。
生成编码表：将每个符号及其对应的哈夫曼编码存储在一个编码表中，以备后续的编码和解码使用。
进行编码：将原始数据中的每个符号替换为其对应的哈夫曼编码，生成压缩后的编码数据。由于频率高的符号具有较短的编码，而频率低的符号具有较长的编码，所以整个编码后的数据长度会相对减小。
哈夫曼编码的优点是没有冗余和歧义性，即每个编码都不是其他编码的前缀，这种性质被称为前缀码。这使得编码和解码过程都是非常高效的。然而，对于哈夫曼编码的最佳性能，符号的频率应该是根据数据集的统计特征进行调整的。
哈夫曼编码举例： 假设要对“we will we will r u”进行压缩
压缩前,使用 ASCII 码保存
共需： 19 个字节 - 152 个位保存
下面我们先来统计这句话中每个字符出现的频率。如下表，按频率高低已排序：
接下来，我们按照字符出现的频率，制定如下的编码表：
这样，“we will we will r u”就可以按如下的位来保存：
01 110 10 01 1111 00 00 10 01 110 10 01 1111 00 00 10 11101 10 11100
哈夫曼二叉树构建
1.按出现频率高低将其放入一个数组中，从左到右依次为频率逐渐增加
2. 从左到右进行合并，依次构建二叉树。第一步取前两个字符 u 和 r 来构造初始二叉树，第一个字符作为左节点，第二个元素作为右节点，然后两个元素相加作为新的空元素，并且两者权重相加作为新元素的权重。
3.新节点加入后，依据权重重新排序，按照权重从小到大排列，上图已有序。
4.红色区域的新增元素可以继续和 i 合并,如下图所示：
5. 合并节点后, 按照权重从小到大排列，如下图所示。
6. 排序后，继续合并最左边两个节点，构建二叉树，并且重新计算新节点的权重
7. 重新排序
8. 重复上面步骤 6 和 7,直到所有字符都变成二叉树的叶子节点
二.具体代码实现
Huff.h
#pragma once
#pragma once
#include <stdio.h>
#include <assert.h>
#include <Windows.h>
#include <iostream>
#include <iomanip>
using namespace std;
#define MaxSize 1024 //队列的最大容量
typedef struct _Bnode
{
char value;
int weight;
struct _Bnode* parent;
struct _Bnode* lchild;
struct _Bnode* rchild;
} Btree, Bnode; /* 结点结构体 */
typedef Bnode* DataType; //任务队列中元素类型
typedef struct _QNode { //结点结构
int priority; //每个节点的优先级,数值越大，优先级越高，优先级相同，取第一个节点
DataType data;
struct _QNode* next;
}QNode;
typedef QNode* QueuePtr;
typedef struct Queue
{
int length; //队列的长度
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
//队列初始化，将队列初始化为空队列897943840118979438401111
void InitQueue(LinkQueue* LQ)
{
if (!LQ) return;
LQ->length = 0;
LQ->front = LQ->rear = NULL; //把对头和队尾指针同时置 0
}
//判断队列为空
int IsEmpty(LinkQueue* LQ)
{
if (!LQ) return 0;
if (LQ->front == NULL)
{
return 1;
}
return 0;
}
//判断队列是否为满
int IsFull(LinkQueue* LQ)
{
if (!LQ) return 0;
if (LQ->length == MaxSize)
{
return 1;
}
return 0;
}
//入队,将元素 data 插入到队列 LQ 中
int EnterQueue(LinkQueue* LQ, DataType data, int priority) {
if (!LQ) return 0;
if (IsFull(LQ)) {
cout << "无法插入元素 " << data << ", 队列已满!" << endl;
return 0;
}
QNode* qNode = new QNode;
qNode->data = data;
qNode->priority = priority;
qNode->next = NULL;
if (IsEmpty(LQ)) {//空队列
LQ->front = LQ->rear = qNode;
}
else {
qNode->next = LQ->front;
LQ->front = qNode;
//LQ->rear->next =qNode;//在队尾插入节点 qNode
//LQ->rear = qNode; //队尾指向新插入的节点
}
LQ->length++;
return 1;
}
//出队，遍历队列，找到队列中优先级最高的元素 data 出队
int PopQueue(LinkQueue* LQ, DataType* data) {
QNode** prev = NULL, * prev_node = NULL;//保存当前已选举的最高优先级节点上一个节点的指针地址。
QNode* last = NULL, * tmp = NULL;
if (!LQ || IsEmpty(LQ)) {
cout << "队列为空！" << endl;
return 0;
}
if (!data) return 0;
//prev 指向队头 front 指针的地址
prev = &(LQ->front);
//printf("第一个节点的优先级: %d\n", (*prev)->priority);
last = LQ->front;
tmp = last->next;
while (tmp) {
if (tmp->priority < (*prev)->priority) {
//printf("抓到个更小优先级的节点[priority: %d]\n",tmp->priority);
prev = &(last->next);
prev_node = last;
}
last = tmp;
tmp = tmp->next;
}
*data = (*prev)->data;
tmp = *prev;
*prev = (*prev)->next;
delete tmp;
LQ->length--;
//接下来存在 2 种情况需要分别对待
//1.删除的是首节点,而且队列长度为零
if (LQ->length == 0) {
LQ->rear = NULL;
}
//2.删除的是尾部节点
if (prev_node && prev_node->next == NULL) {
LQ->rear = prev_node;
}
return 1;
}
//打印队列中的各元素
void PrintQueue(LinkQueue* LQ)
{
QueuePtr tmp;
if (!LQ) return;
if (LQ->front == NULL) {
cout << "队列为空！";
return;
}
tmp = LQ->front;
while (tmp)
{
cout << setw(4) << tmp->data->value << "[" << tmp->priority << "]";
tmp = tmp->next;
}
cout << endl;
}
//获取队首元素，不出队
int GetHead(LinkQueue* LQ, DataType* data)
{
if (!LQ || IsEmpty(LQ))
{
cout << "队列为空!" << endl;
return 0;
}
if (!data) return 0;
*data = LQ->front->data;
return 1;
}
//清空队列
void ClearQueue(LinkQueue* LQ)
{
if (!LQ) return;
while (LQ->front) {
QueuePtr tmp = LQ->front->next;
delete LQ->front;
LQ->front = tmp;
}
LQ->front = LQ->rear = NULL;
LQ->length = 0;
}
//获取队列中元素的个数
int getLength(LinkQueue* LQ) {
if (!LQ) return 0;
return LQ->length;
}
main.cpp
#include "Huff.h"
using namespace std;
void PreOrderRec(Btree* root);
/* 构造哈夫曼编码树 */
void HuffmanTree(Btree*& huff, int n)
{
LinkQueue* LQ = new LinkQueue;
int i = 0;
//初始化队列
InitQueue(LQ);
/* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */
for (i = 0; i < n; i++)
{
Bnode* node = new Bnode;
cout << "请输入第" << i + 1 << "个字符和出现频率: " << endl;
cin >> node->value; //输入字符
cin >> node->weight;//输入权值
node->parent = NULL;
node->lchild = NULL;
node->rchild = NULL;
EnterQueue(LQ, node, node->weight);
}
PrintQueue(LQ);
//system("pause");
//exit(0);
do {
Bnode* node1 = NULL;
Bnode* node2 = NULL;
if (!IsEmpty(LQ)) {
PopQueue(LQ, &node1);
printf("第一个出队列的数：%c, 优先级: %d\n", node1->value,
node1->weight);
}
else {
break;
}
if (!IsEmpty(LQ)) {
Bnode* node3 = new Bnode;
PopQueue(LQ, &node2);
printf("第二个出队列的数：%c, 优先级: %d\n", node2->value,
node2->weight);
node3->lchild = node1;
node1->parent = node3;
node3->rchild = node2;
node2->parent = node3;
node3->value = ' ';
node3->weight = node1->weight + node2->weight;
printf("合并进队列的数：%c, 优先级: %d\n", node3->value,
node3->weight);
EnterQueue(LQ, node3, node3->weight);
}
else {
huff = node1;
break;
}
} while (1);
}
/************************
* 采用递归方式实现前序遍历
*************************/
void PreOrderRec(Btree* root)
{
if (root == NULL)
{
return;
}
printf("- %c -", root->value);
PreOrderRec(root->lchild);
PreOrderRec(root->rchild);
}
int main(void) {
Btree* tree = NULL;
HuffmanTree(tree, 7);
PreOrderRec(tree);
system("pause");
return 0;
}
