数据结构与算法——树的应用(哈夫曼编码)

1. 哈夫曼编码概括

/*********************************************

*  本文图片较多，多刷新一下才能显示  *

**********************************************/

 

哈夫曼（Huffman）编码算法是基于二叉树构建编码压缩结构的，它是数据压缩中经典的一种算 法。算法根据文本字符出现的频率，重新对字符进行编码。 

首先以下这段文字举例：

今天天气晴朗，我和乔伊·亚历山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔 尼·梅尔斯·帕特森·汤普森·华莱士·普雷斯顿出去玩！乔伊·亚历山大·比基·卡利斯勒·达夫·埃利奥 特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱士·普雷斯顿贪玩，不小心摔了一跤，乔伊·亚 历山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱士·普 雷斯顿被摔得哇哇哭了，乔伊·亚历山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅 尔斯·帕特森·汤普森·华莱士·普雷斯顿的爸爸闻声赶来，又把乔伊·亚历山大·比基·卡利斯勒·达夫·埃 利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱士·普雷斯顿痛扁了一阵。乔伊·亚历 山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅尔斯·帕特森·汤普森·华莱士·普 雷斯顿的屁股都被揍扁了，因为乔伊·亚历山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马 尔尼·梅尔斯·帕特森·汤普森·华莱士·普雷斯顿把妈妈刚买给他的裤子弄破了！

 

这段文字中由于名字较长，整体篇幅增加了很多倍，如何将它们压缩呢？比如我们在文章的开头先声明一个缩写：

名字	缩写
乔伊·亚历山大·比基·卡利斯勒·达夫·埃利奥特·福克斯·伊维鲁莫·马尔尼·梅 尔斯·帕特森·汤普森·华莱士·普雷斯顿	乔顿

 

 

 

那么，上面这段文字就可以缩成很小的一段：

今天天气晴朗，我和乔顿出去玩！乔顿贪玩，不小心摔了一跤，乔顿被摔得哇哇哭了，乔顿的爸爸闻声赶来， 又把小明痛扁了一阵。乔顿的屁股都被揍扁了，因为乔顿把妈妈刚买给他的裤子弄破了！

 

哈夫曼编码就是这样一个原理！按照文本字符出现的频率，出现次数越多的字符用越简短的编码 替代，因为为了缩短编码的长度，我们自然希望频率越高的词，编码越短，这样最终才能最大化 压缩存储文本数据的空间。

 

哈夫曼编码举例： 假设要对 “we will we will r u” 进行压缩。

压缩前,使用 ASCII 码保存：

119

101

32

119

105

108

108

32

119

101

 

 

32

119

105

108

108

32

114

32

117

 

 

共需： 19 个字节 - 152 个位保存

 

下面统计这句话中每个字符出现的频率。如下表，按频率高低已排序：

字符	空格	w	l	e	i	r	u
频率	5	4	4	2	2	1	1

 

 

 

再按照字符出现的频率,定制入戏下的编码表：（该编码表会用二叉树生成，后边会说明）

字符	l	w	空格	e	i	u	r
编码	00	01	10	110	1111	11100	11101

 

 

 

这样，“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

 

 

2. 哈夫曼二叉树构建

2.1 按出现频率高低将其放入一个数组中，从左到右依次为频率逐渐增加

    

 

 

 

2.2 从左到右进行合并，依次构建二叉树。第一步取前两个字符 u 和 r 来构造初始二叉树，第一个 字符作为左节点，第二个元素作为右节点，然后两个元素相加作为新的空元素，并且两者权重相 加作为新元素的权重。

 

2.3 新节点加入后，依据权重重新排序，按照权重从小到大排列，上图已有序。

2.4 红色区域的新增元素可以继续和 i 合并,如下图所示：

 

2.5 合并节点后, 按照权重从小到大排列，如下图所示。

 

2.6 排序后，继续合并最左边两个节点，构建二叉树，并且重新计算新节点的权重

 

2.7 重新排序

 

2.8 重复上面步骤 6 和 7,直到所有字符都变成二叉树的叶子节点

 

 

 

 

 

3. 源码实现：

Huff.h

#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;

//队列初始化，将队列初始化为空队列
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;
}

 

 

哈夫曼编码实现.cpp

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#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;
}

 

 

 

 

 

 

 

 

====================================================================================================================