数据结构学习——哈夫曼树

最新推荐文章于 2024-09-13 15:58:12 发布

YiHeboy

最新推荐文章于 2024-09-13 15:58:12 发布

阅读量3.9k

点赞数 22

CC 4.0 BY-SA版权

文章标签：数据结构学习算法

本文链接：https://blog.csdn.net/YiHeboy/article/details/125771457

本文介绍了哈夫曼树的概念、构建原理及其在数据结构学习中的应用。讲解了哈夫曼树的特性，强调其在最优二叉树中的地位，并讨论了哈夫曼编码的前缀编码性质和避免歧义的重要性。还提到了哈夫曼编码在文件压缩和解压中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数据结构学习记录DAY13 :哈夫曼树（上）

哈(赫)夫曼树和哈(赫)夫曼编码

路径一个结点到另外一个结点的通路，称为路径（祖先结点到子孙结点）
路径长度：每经过一个结点，路径长度就增加1，不包括起始结点的
结点权值：对于结点赋予一个数值，表示结点的权值比较：结点元素出现的次数
带权路径长度：从根点出发到该结点的路径长度乘以该结点的权值
树的带权路径长度 (WPL)：树中所有叶子结点的带权路径长度之和
哈夫曼树：最优二叉树，由n个叶结点组成的二叉树的带权路径长度最短
- 结点相同，构成的哈夫曼树可能不唯一，但树的带权路径长度相等
- 把n个结点构成哈夫曼树，这n个结点必然作为叶子结点，需要添加n-1个分支结点

构建哈夫曼树

遵循的原则：权重越大离根结点越近
算法描述过程
- 1. 把n个叶结点看作n棵独立的树，构成森林F
- 1. 创建一个新的结点，然后从森林F中选取两棵根结点权值最小的树作为新结点的左右子树，并且把新的结点的权值设置为这两棵树根结点权值之和
- 1. 从森林F中把刚才选取两棵树删除，并且把新的结点作为树的根结点加入到森林中
- 1. 重复2和3的步骤，直到森林中只剩下一棵树为止

A:3   B:4     C:1    D:5    E:10     F:6    G:2

E:10   F:6    D:5    B:4   A:3    G:2   C:1

   3
 /   \
G     C
E:10   F:6    D:5    B:4  A:3    GC:3
   6
 /  \ 
A    3
    / \
   G   C
E:10   F:6   A GC:6  D:5    B:4
  9
 / \
D   B

Fx:12  E:10  DB:9  
   12
   / \
  F   6
     /  \ 
    A    3
        / \
       G   C
哈夫曼树:
       31
      /  \
   19      12
  /  \    /  \
 E    9  F    6
     / \     / \
    D   B   A   3
               /  \
              G    C
A:3   B:4     C:1    D:5    E:10     F:6    G:2
E:00   D:010  B:011  F:10   A:110  G:1110  C:1111

3x3 + 4x3 + 1x4 + 5x3 + 10x2 + 6x2 + 2x4  
= 9 + 12 + 4 + 15 + 20 + 12 + 8

哈夫曼树特性

每个初始结点最终都成为叶结点，且权值越小的结点到根结点的路径长度越大
哈夫曼树的结点总数为2n − 1
哈夫曼树中不存在度为1的结点
哈夫曼树并不唯一，但WPL必然相同且为最优

哈夫曼编码

编码
- 定义编码
- ASCII 定长编码每个字符都是8个二进制位
  - A 65 0100 0001
  - B 66 0100 0010
  - C 67 0100 0011
  - D 68 0100 0100
- unicode 万国码 4byte
- 变长编码 utt-8 中文汉字2-4byte gbk 2byte
- 哈夫曼编码就是变长编码
- 哈夫曼编码是前缀编码任意一个字符的编码都不会是另外一个字符编码的前缀
- 前缀编码不会有歧义非前缀编码会产生歧义

100道选择题: 按照ascii发送：传输100byte

A: 00 B: 01 C: 10 D: 11 100*2bit/8 byte = 25byte

A:50 B:20 C:15 D:15

A:0 B:10 C:110 D:111 50x1+20x2+30x3bit/8 = 180/8 = 22.5byte

A:0 B:00 C:010 D:011 非前缀编码

由哈夫曼树获取哈夫曼编码

从根结点出发，左子树为0，右子树为1，到所有叶子结点所经过的路径就构成了哈夫曼编码

有了以上的知识点就可以准备着手创建哈夫曼树和生成哈夫曼编码了
多文件编程如下：
main.c

#include "Huffman.h"
void printEWC(unsigned char elem, size_t weight, char *code)
{
  	printf("%c   %u    %s\n",elem, weight, code);
}

int main()
{
	unsigned char elm[] = "ABCDEFGHIJ";
	size_t weight[] = {5,7,4,3,1,2,6,9,0,8};
	HUFF tree = create_HuffmanTree(elm, weight, 10);
	get_HuffCode(tree);
	foreach_HuffmanTree(tree, printEWC);
 	destroy_HuffmanTree(tree);
}

Huffman.h

	#ifndef _HUFFMAN_H_
#define _HUFFMAN_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>

#define SUCCESS 0
#define FAILURE -1
#define CODE_LEN 256

typedef unsigned char ElemType;

struct HuffTree{
    ElemType data;//
    size_t weight;//权重
    char code[CODE_LEN];//存储时转化为而精致
    struct HuffTree *lchild;
    struct HuffTree *rchild;
};

typedef struct HuffTree *HUFF;

HUFF create_HuffmanTree(ElemType elems[], size_t weight[], size_t n);//elems为元素， weight为权重
//获得哈夫曼编码
void get_HuffCode(HUFF tree);
//输出哈夫曼编码
void foreach_HuffmanTree(HUFF tree, void (*visit)(ElemType, size_t, char*));
//
void destroy_HuffmanTree(HUFF tree);



#endif// _HUFFMAN_H_

Huffman.c

#include "Huffman.h"

int compareWeight(const void *v1, const void *v2)
{
 HUFF *h1 = (HUFF*) v1;
 HUFF *h2 = (HUFF*) v2;
 //return ((*h2)->weight - (*h1)->weight);
 if((*h1)->weight < (*h2)->weight){
     return 1;
 }
 else if((*h2)->weight < (*h1)->weight){
     return -1;
 }
 else{
     return 0;
 }
}

//elems为元素， weight为权重
HUFF create_HuffmanTree(ElemType elems[], size_t weight[], size_t n)
{
 //HUFF *tree = (HUFF*)malloc(sizeof(HUFF*) * n);
 HUFF tree[n];
 if(NULL == tree){
     return NULL;
 }
 for(int i = 0; i < n; ++i){
     tree[i] = (HUFF)malloc(sizeof(struct HuffTree));
     tree[i]->data = elems[i];
     tree[i]->weight = weight[i];
     tree[i]->lchild = tree[i]->rchild = NULL;
     memset(tree[i]->code, 0, CODE_LEN);
 }
 qsort(tree, n, sizeof(HUFF), compareWeight);
 for(int i = 0; i < n; ++i){
     //此时i为最后一个结点
     printf("%c(%u)", tree[i]->data,tree[i]->weight);
 }
 printf("\n");
 HUFF root = NULL;
 for(int i = n-1; i > 0; i--){
     root = (HUFF)malloc(sizeof(struct HuffTree));
     root->lchild = tree[i-1];
     root->rchild = tree[i];
     root->weight = tree[i-1]->weight + tree[i]->weight;
     //memset(root->code, 0, CODE_LEN);
     int j;
     for(j = i - 2; j >= 0 && tree[j]->weight < root->weight; --j){
         tree[j+1] = tree[j];
     }
     tree[j + 1] = root;
 }
 root = tree[0];
 return root;

}
//获得哈夫曼编码
void get_HuffCode(HUFF tree)
{
 if(NULL != tree){
     if(tree->lchild != NULL){
         strcpy(tree->lchild->code,tree->code);
         strcat(tree->lchild->code, "0");
         get_HuffCode(tree->lchild);
     }
     if(tree->rchild != NULL){
         strcpy(tree->rchild->code,tree->code);
         strcat(tree->rchild->code, "1");
         get_HuffCode(tree->rchild);
     }
 }
}
//输出哈夫曼编码
void foreach_HuffmanTree(HUFF tree, void (*visit)(ElemType, size_t, char*))
{
 if(tree != NULL){
     if(tree->lchild == NULL && NULL == tree->rchild){
         visit(tree->data, tree->weight, tree->code);
     }
     else{
         foreach_HuffmanTree(tree->lchild, visit);
         foreach_HuffmanTree(tree->rchild, visit);
     }
 }
}
//
void destroy_HuffmanTree(HUFF tree)
{
 if(tree != NULL){
     destroy_HuffmanTree(tree->lchild);
     destroy_HuffmanTree(tree->rchild);
     free(tree);
 }
}