数据结构&&哈弗曼树和哈弗曼编码

1.什么是哈夫曼树和哈弗曼编码

大家来看这样一道面试题(题目来自于<程序员面试宝典>)。用二进制来编码字符串"abcdabaa",需要能够根据编码，解码回原来的字符串，最少需要多长的二进制字符串？

A.12
B.14 C.18
D.24

解析：典型的哈弗曼编码问题：字符串"abcdabaa"有4个a、2个b、1个c、1个d。构造哈弗曼树如下图所示(图好丑)。a编码0(1位)，b编码10(2位)，d编码111(3位)。二进制字符串的总长度为1*4+2*2+3*1+3*1。

接下来让我们一同回顾哈弗曼树的理论知识吧。在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN)树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的
路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL= (W1*L1+W2*L2+W3*L3+...+Wn*Ln)，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,...n)。可以证明哈夫曼树的WPL是最小的。名字解释：

(1)路劲(Path):从树中的一个结点到另一个结点之间的分支构成两个结点间的路径。

(2)路径长度(Path Length):路径上的分支树。

(3)树的路径长度(Path Length of Tree):从树的根结点到每个结点的路径长度之和。在结点数目相同的二叉树中，完全二叉树的路径长度最短。

(4)结点的权(Weight of  Node):在一些应用中，赋予树中结点的一个有实际意义的树。

(5)结点的带权路径长度(Weight Path Length of Node):从该结点到树的根结点的路径长度与该结点的权的乘积。

(6)树的带权路径长度(WPL):树中所有叶子结点的带权路径长度之和，记为

在下图所示的2棵二叉树，都有4个叶子结点，其权值分别1、2、3、4,他们的带权路径长度分别为:

(a)WPL = 1 x 2 + 2 x 2 + 3 x 2 + 4 X 2 = 20

(b)WPL = 1 x 1 + 2 x 2 + 3 x 3 + 4 x 3 = 28

(c)WPL  = 1 x 3 + 2 x 3 + 3 x 2 + 4 x 1 = 19

其中，(c)图所示的二叉树的带权路径长度最小，这棵树就是哈夫曼树

2.哈夫曼树和编码步骤：

一、对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算 法，一般还要求以Ti的权值Wi的升序排列。）

二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。

三、从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。

四、重复二和三两步，直到集合F中只有一棵二叉树为止。

简易的理解就是，假如我有A,B,C,D,E五个字符，出现的频率（即权值）分别为5,4,3,2,1,那么我们第一步先取两个最小权值作为左右子树构造一个新树，即取1，2构成新树，其结点为1+2=3，如图：

虚线为新生成的结点，第二步再把新生成的权值为3的结点放到剩下的集合中，所以集合变成{5,4,3,3}，再根据第二步，取最小的两个权值构成新树，如图：

再依次建立哈夫曼树，如下图：

其中各个权值替换对应的字符即为下图：

所以各字符对应的编码为：A->11,B->10,C->00,D->011,E->010

哈弗曼编码是一种无前缀编码。解码时不会混淆。其主要应用在数据压缩，加密解密等场合。

哈弗曼树的C语言实现

<span style="font-size:18px;">#include <stdio.h>
#include <stdlib.h>

#define MAX 4

int input_weight(int *p)
{
    int i = 0;

    for(i = 0;i < MAX;i ++)
    {
        scanf("%d",p + i);
    }

    while(getchar()!= '\n');

    return 0;
}

int order_weight(int *p)
{
    int i = 0;
    int j = 0;
    int temp;

    for(i = 0;i < MAX;i ++)
    {
        for(j = 0;j < MAX - i - 1;j ++)
        {
            if(p[j] > p[j+1])
            {
                temp = p[j];
                p[j] = p[j+1];
                p[j+1] = temp;
            }
        }
    }

    return 0;
}

//哈夫曼树结点
typedef struct HuffNode
{
    int weight;
    struct HuffNode *rchild;
    struct HuffNode *lchild;

}HuffMan;

//队列设计
typedef struct _node_
{
    HuffMan *data;
    struct _node_ *next;
}ListNode;

typedef struct
{
    ListNode *front;
    ListNode *rear;
}Queue;

//create empty queue
Queue *create_empty_queue()
{
    ListNode *HList;
    Queue *Hqueue;

    HList = (ListNode *)malloc(sizeof(ListNode));
    HList->next = NULL;

    Hqueue = (Queue *)malloc(sizeof(Queue));
    Hqueue->front = Hqueue->rear = HList;

    return Hqueue;
}

//入队
int EnterQueue(Queue *head,HuffMan *data)
{
    ListNode *temp;

    temp = (ListNode *)malloc(sizeof(ListNode));
    temp->data = data;
    temp->next = NULL;

    head->rear->next = temp;
    head->rear = temp;

    return 0;
}

//有序插入结点
int OrderEnterQueue(Queue *head,HuffMan *p)
{
    ListNode *m = head->front->next;
    ListNode *n = head->front;
    ListNode *temp;
#if 0
    if(head->front->next == NULL)
    {
        printf("emty!\n");
        temp = (ListNode *)malloc(sizeof(ListNode));
        temp->data = p;
        temp->next = NULL;
        n->next = temp;
        head->rear = temp;
    }
#endif
    while(m)
    {
        if(m->data->weight < p->weight)
        {
            m = m->next;
            n = n->next;
        }
        else{

            break;
        }
    }

    //插到最后一个结点
    if(m == NULL)
    {
        temp = (ListNode *)malloc(sizeof(ListNode));
        temp->data = p;
        temp->next = NULL;
        n->next = temp;
        head->rear = temp;
    }

    //插入中间结点
    temp = (ListNode *)malloc(sizeof(ListNode));
    temp->data = p;
    n->next = temp;
    temp->next = m;

    return 0;
}

//判断队列是否为空(注意，我们认为队列含有一个结点为空，想想为什么
//这样做?
int is_empty_queue(Queue *head)
{
    if(head->front->next->next == NULL)
    {
        printf("is_empty_queue\n");
        return 1;
    }

    return 0;
}

//出队
HuffMan *DeleteQueue(Queue * head)
{
    ListNode *temp;

    temp = head->front;
    head->front = temp->next;
    free(temp);
    temp = NULL;

    return head->front->data;
}

//将结点按权值从小到大放入队列
int create_forest(Queue *head,int *p)
{
    int i = 0;
    HuffMan *temp;

    for(i = 0;i < MAX;i ++)
    {
        temp = (HuffMan *)malloc(sizeof(HuffMan));
        temp->weight = p[i];
        temp->rchild = temp->rchild = NULL;

        EnterQueue(head,temp);
    }

    return 0;
}

//创建哈夫曼树
HuffMan *create_huffman_tree(Queue *head)
{
    HuffMan *right,*left,*current;

    //循环结束时，队列只含有一个结点
    while(!is_empty_queue(head))
    {
        left = DeleteQueue(head);
        right = DeleteQueue(head);
        current = (HuffMan *)malloc(sizeof(HuffMan));
        current->weight = left->weight + right->weight;
        current->rchild = right;
        current->lchild = left;
#if 0
        printf("%d\n",left->weight);
        printf("%d\n",right->weight);
        printf("%d\n",current->weight);
#endif
        OrderEnterQueue(head,current);

    }

    return head->front->next->data;
}

//访问结点
int vist_node(HuffMan *p)
{
    printf("%d ",p->weight);

    return 0;
}

//树的中序遍历
int InOrder(HuffMan *p)
{
    if(p != NULL)
    {
        InOrder(p->lchild);//左
        vist_node(p);//根
        InOrder(p->rchild);//右
    }

    return 0;
}

int main()
{
    int Wbuf[MAX];
    Queue *head;
    HuffMan *root;

    //输入权值
    input_weight(Wbuf);
    //排序权值
    order_weight(Wbuf);
    //创建空队列
    head = create_empty_queue();
    //将结点按权值从小到大放入队列
    create_forest(head,Wbuf);
    //创建哈夫曼树
    root = create_huffman_tree(head);
    //中序遍历
    InOrder(root);
    printf("\n");

    return 0;
}</span>
<span style="font-size:18px;">结果显示：</span>

哈弗曼编码C语言实现

<span style="font-size:18px;">#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//哈夫曼树结点
typedef struct HuffNode
{
    int weight;
    char ch;
    char code[20];
    struct HuffNode *rchild;
    struct HuffNode *lchild;

}HuffMan;

//队列设计
typedef struct _node_
{
    HuffMan *data;
    struct _node_ *next;
}ListNode;

typedef struct
{
    ListNode *front;
    ListNode *rear;
}Queue;

//create empty queue
Queue *create_empty_queue()
{
    ListNode *HList;
    Queue *Hqueue;

    HList = (ListNode *)malloc(sizeof(ListNode));
    HList->next = NULL;

    Hqueue = (Queue *)malloc(sizeof(Queue));
    Hqueue->front = Hqueue->rear = HList;

    return Hqueue;
}

//入队
int EnterQueue(Queue *head,HuffMan *data)
{
    ListNode *temp;

    temp = (ListNode *)malloc(sizeof(ListNode));
    temp->data = data;
    temp->next = NULL;

    head->rear->next = temp;
    head->rear = temp;

    return 0;
}

//有序插入结点
int OrderEnterQueue(Queue *head,HuffMan *p)
{
    ListNode *m = head->front->next;
    ListNode *n = head->front;
    ListNode *temp;

    while(m)
    {
        if(m->data->weight < p->weight)
        {
            m = m->next;
            n = n->next;
        }
        else{

            break;
        }
    }

    //插到最后一个结点
    if(m == NULL)
    {
        temp = (ListNode *)malloc(sizeof(ListNode));
        temp->data = p;
        temp->next = NULL;
        n->next = temp;
        head->rear = temp;

        return 0;
    }

    //插入中间结点
    temp = (ListNode *)malloc(sizeof(ListNode));
    temp->data = p;
    n->next = temp;
    temp->next = m;

    return 0;
}

//判断队列是否为空(注意，我们认为队列含有一个结点为空，想想为什么
//这样做?
int _is_empty_queue(Queue *head)
{
    if(head->front->next->next == NULL)
    {
        printf("is_empty_queue\n");
        return 1;
    }

    return 0;
}

//判断队列是否为空
int is_empty_queue(Queue *head)
{
    if(head->front == head->rear)
        return 1;
    else
        return 0;
}

//出队
HuffMan *DeleteQueue(Queue * head)
{
    ListNode *temp;

    temp = head->front;
    head->front = temp->next;
    free(temp);
    temp = NULL;

    return head->front->data;
}

//创建哈夫曼树
HuffMan *create_huffman_tree(Queue *head)
{
    HuffMan *right,*left,*current;

    //循环结束时，队列只含有一个结点
    while(!_is_empty_queue(head))
    {
        left = DeleteQueue(head);
        right = DeleteQueue(head);
        current = (HuffMan *)malloc(sizeof(HuffMan));
        current->weight = left->weight + right->weight;
        current->rchild = right;
        current->lchild = left;
        OrderEnterQueue(head,current);
    }

    return head->front->next->data;
}

//哈夫曼编码
int HuffmanCode(HuffMan *root)
{
    HuffMan *current = NULL;
    Queue *queue = NULL;

    queue = create_empty_queue();

    EnterQueue(queue, root);

    while(!is_empty_queue(queue))
    {
        current = DeleteQueue(queue);

        if(current->rchild == NULL && current->lchild == NULL)
        {
            printf("%c:%d %s\n",current->ch,current->weight,current->code);
        }

        if(current->lchild)
        {
            strcpy(current->lchild->code,current->code);
            strcat(current->lchild->code,"0");
            EnterQueue(queue, current->lchild);
        }

        if(current->rchild)
        {
            strcpy(current->rchild->code,current->code);
            strcat(current->rchild->code,"1");
            EnterQueue(queue, current->rchild);
        }
    }

    return 0;
}</span>
<span style="font-size:18px;">结果显示：</span>

时间： 2024-10-09 19:35:32

数据结构&&哈弗曼树和哈弗曼编码的相关文章

赫夫曼树的构建、编码、译码解析

当你開始看这篇博文的时候.我相信你对树及二叉树的基本概念已有所了解.我在这里就不再赘述. 我们主要对赫 夫曼树的特点.构建.编码.译码做一个具体的介绍,并附有代码,全部函数代码都通过了測试.我不保证全部代码是最优的(毕竟是我一个人苦思冥想出来的,我相信在大家的集思广益之下还有优化的空间),但我保证全部代码是正确的. 一.赫夫曼树的特点 赫夫曼树又称作最优二叉树,是一类带权路径长度最短的树. 首先给出路径和路径长度的概念.从树中一个节点到 还有一个节点之间的分支构成这两个节点之间的路径.路径上的分

哈夫曼树+哈夫曼编码

前天acm实验课,老师教了几种排序,抓的一套题上有一个哈夫曼树的题,正好之前离散数学也讲过哈夫曼树,这里我就结合课本,写一篇关于哈夫曼树的博客. 哈夫曼树的介绍 Huffman Tree,中文名是哈夫曼树或霍夫曼树,它是最优二叉树. 定义:给定n个权值作为n个叶子结点,构造一棵二叉树,若树的带权路径长度达到最小,则这棵树被称为哈夫曼树. 这个定义里面涉及到了几个陌生的概念,下面就是一颗哈夫曼树,我们来看图解答. (01) 路径和路径长度 定义:在一棵树中,从一个结点往下可以达到的孩子或孙子结点之

5.2哈夫曼树——哈夫曼树与哈夫曼编码

#include <stdio.h> #include <stdlib.h> struct TreeNode{ int Weight; HuffmanTree Left, Right; }; HuffmanTree Huffman(MinHeap H) { int i; HuffmanTree T; for( i = 1; i < H->ESize; i++){ T = malloc(sizeof(struct TreeNode)); T->Left = Dele

java实现哈弗曼树

O(∩_∩)O~~ 概述 我想学过数据结构的小伙伴一定都认识哈弗曼,这位大神发明了大名鼎鼎的“最优二叉树”,为了纪念他呢,我们称之为“哈弗曼树”.哈弗曼树可以用于哈弗曼编码,编码的话学问可就大了,比如用于压缩,用于密码学等.今天一起来看看哈弗曼树到底是什么东东. 概念 当然,套路之一,首先我们要了解一些基本概念. 1.              路径长度:从树中的一个结点到另一个结点之间的分支构成这两个结点的路径,路径上的分支数目称为路径长度. 2.              树的路径长度:从树

看数据结构写代码（32) 赫夫曼树编码以及译码

杂谈:最近有点慵懒,不好不好.好几天都没写代码,原本准备上星期完结 树 这一章节的.现在 又耽误了.哎.要抓紧时间啊. 下面直接上代码: 可以到我的网盘下载源代码,或者 直接拷贝下面的源代码 运行 网盘地址:点击打开链接 // HuffmanTree.cpp : 定义控制台应用程序的入口点. //哈弗曼编码,译码 #include "stdafx.h" #include <stdlib.h> #include <cstring> enum E_State { E

【数据结构】哈夫曼树实现编码译码

根据一段字符串中字符的个数 作为该字符的权值生成哈夫曼树. 然后根据生成的哈夫曼编码,对任意字符串实现编码,对任意二进制串实现译码. 程序运行结果: 1.程序主界面: 2.根据字符串 创建哈夫曼树及编码: 3.生成的编码表如下: 4.根据生成的哈夫曼编码对字符串编码: 5.生成的编码保存在文件中: 6.对二进制串译码: 结果: 代码: 哈夫曼树的生成和编码的常见,以及编码和译码函数 //_HuffmanTree_H #ifndef _HuffmanTree_H #define _HuffmanT

数据结构：哈夫曼树和哈夫曼编码

哈夫曼树 哈夫曼树是一种最优二叉树,其定义是:给定n个权值作为n个叶子节点,构造一棵二叉树,若树的带权路径长度达到最小,这样的树就达到最优二叉树,也就是哈夫曼树,示例图如下: 基本概念 深入学习哈夫曼树前,先了解一下基本概念,并以上面的哈夫曼树图为例 路径:树中一个结点到另一个结点之间的分支序列构成两个结点间的路径. 路径长度:路径中分支的数目,从根结点到第L层结点的路径长度为L-1.例如100和80的路径长度为1,50和30的路径长度为2. 结点的权:树中结点的数值,例如100,50那些. 结

数据结构学习笔记04树(堆 哈夫曼树 并查集)

一.堆(heap) 优先队列(Priority Queue):特殊的“队列”,取出元素的顺序是依照元素的优先权(关键字)大小,而不是元素进入队列的先后顺序. 数组 : 插入 — 元素总是插入尾部 ~ O ( 1 ) 删除 — 查找最大(或最小)关键字 ~ O ( n ) 从数组中删去需要移动元素 ~ O( n ) 链表: 插入 — 元素总是插入链表的头部 ~ O ( 1 ) 删除 — 查找最大(或最小)关键字 ~ O ( n ) 删去结点 ~ O( 1 ) 有序数组: 插入 — 找到合适的位置

哈夫曼树与哈夫曼编码

哈夫曼树与哈夫曼编码 术语: i)路径和路径长度 在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径. 路径中分支的数目称为路径长度.若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1. ii)结点的权及带权路径长度 若对树中的每个结点赋给一个有着某种含义的数值,则这个数值称为该结点的权. 结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积. iii)树的带权路径长度 树的带权路径长度:所有叶子结点的带权路径长度之和,记为WPL. 先了解一下