【数据结构】3-2哈夫曼树的实现（数组实现）以及哈夫曼编码

最新推荐文章于 2023-01-08 23:41:13 发布
最新推荐文章于 2023-01-08 23:41:13 发布
阅读量742 收藏 5
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/robotpaul/p/10009312.html
版权

哈夫曼树的性质：

  1. 哈夫曼树不唯一（即左孩子右孩子放的顺序可以是左大右小也可以是左小右大）
  2. 哈夫曼树的子树也是哈夫曼树
  3. 哈夫曼树中无度为1的结点
  4. 有n个叶子结点的哈夫曼树，其总结点数为2*n-1（非常重要！编程实现就要用这条性质）

总体思路：

  1. 对两个最小者的选择为双亲下标为0的结点
  2. 对选出的两个最小者，修改双亲下标为新结点的下标
  3. 新结点的左右孩子修改为所选的两个新结点的下标
  4. 新结点的权值为两个结点的权值之和

结构体定义：

struct element
{
    int weight;        // 权值域
    int lchild, rchild, parent;  // 该结点的左、右、双亲结点在数组中的下标
};

哈夫曼树类的定义：

class HTree
{
private:
    element *node;
    int n, m;//n是元素个数
    stack<int> code;
    int setcode(int weight);//返回的是编码的长度
public:
    HTree(int _n, int _weight[]);
    void select(int &s1, int &s2);
    void creatHT();
    void print();
    int search(int weight);
    void printHTcode();
};

构造函数的实现：

HTree::HTree(int _n,int _weight[])
{
    n = _n;
    m = 2 * n - 1;            //n个元素需要2*n-1空间
    node = new element[m];    //开辟m个大小的element空间
    for (int i = 0; i <n; i++)
    {
        node[i].weight = _weight[i];//为每一个元素赋初始权值
    }
    for (int i = 0; i < m; i++)
    {
        node[i].lchild = node[i].rchild = node[i].parent = 0;//初始化左孩子右孩子和双亲指针，都为0
    }
    creatHT();//构造哈夫曼树
}

选择函数，比较结点中双亲为0的较小的两个（在本文中s1最小）：

void HTree::select(int &s1, int &s2)
{
    //对两个最小者的选择为双亲下标为0的结点
    for (int i = 0; i < n; i++)
    {
        if (node[i].parent == 0)
        {
            s1=i;    //先找到一个临时比较元素进行最小值比较
            break;
        }
    }
    for (int i = 0; i <n; i++)        //该循环是找到一个最小的并赋值给s1
    {
        if ((node[s1].weight > node[i].weight) && (node[i].parent == 0))        //找双亲为0的
        {
            s1 = i;
        }
    }
    //同s1的比较方法，先找到一个双亲为0的临时值(排除s1)，然后再进行逐一比较找到第二小的值赋值给s2即可
    for (int i = 0; i <n; i++)
    {
        if ((node[i].parent == 0)&&i!=s1)        //排除s1
        {
            s2 = i;    //先找到一个临时比较元素进行最小值比较
            break;
        }
    }
    for (int i = 0; i <n; i++)        //找到除s1以外双亲为0中最小的并赋值给s2
    {
        if ((node[s2].weight > node[i].weight) && (node[i].parent == 0) && (i != s1))
        {
            s2 = i;
        }
    }
    
}

创建哈夫曼树：

  1. 循环2*n-1 - n-1次，即进行m-n-1次比较即可
  2. 对两个最小者的选择为双亲下标为0的结点（调用选择函数来实现）
  3. 对选出的两个最小者，修改双亲下标为新结点的下标
  4. 新结点的左右孩子修改为所选的两个新结点的下标
  5. 新结点的权值为两个结点的权值之和
void HTree::creatHT()
{
    for (int i = n; i < m; i++)//执行的是m-n次比较
    {
        int s1, s2;//左小右大
        select(s1, s2);//选择数组中最小且双亲为0的结点
        node[s1].parent = i;//找到后的s1,s2的双亲应该放在n-1后
        node[s2].parent = i;
        node[i].lchild = s1;    //左小
        node[i].rchild = s2;    //右大
        node[i].weight = node[s1].weight + node[s2].weight;
        n++;
    }
}

哈夫曼编码：

原理：

  1. 输入要编码的权值，调用search函数遍历查找到在数组中的地址并返回
  2. 从要编码的位置上溯遍历，并判断是左孩子还是右孩子，左孩子为0右孩子为1（也可以反过来）
  3. 编码是从上到下，而我们在遍历的时候是从下到上，因此可以使用栈或者链表的头插法进行存储操作（我在这里使用的是栈，有点不好，输出栈就被清空了，可能会影响时间效率）
  4. 判断如果该结点的parent为空（即为0）停止循环即可

setcode(私有函数)

int HTree::setcode(int weight)
{
    int location, parent, k;//location来定位权值所指向的位置，parent即Location的双亲，k是移动指针
    int cont = 0;
    location = search(weight);
    k = location;
    parent = node[location].parent;
    while (node[k].parent!= 0&&k!=-1)
    {
        if (node[parent].lchild == k)
        {
            code.push(0);
        }
        else
        {
            code.push(1);
        }
        k = node[k].parent;
        parent = node[k].parent;
        cont++;
    }
    if (k == -1)
    {
        cout << "未找到！错误！" << endl;
    }
    return cont;
}

search函数

int HTree::search(int weight)
{
    int result = -1;
    for (int i = 0; i < m; i++)
    {
        if (node[i].weight == weight)
        {
            result = i;
        }
    }
    return result;
}

完整代码：

/*
1.对两个最小者的选择为双亲下标为0的结点
2.对选出的两个最小者，修改双亲下标为新结点的下标
3.新结点的左右孩子修改为所选的两个新结点的下标
4.新结点的权值为两个结点的权值之和
*/
#include<iostream>
#include<iomanip>
#include<stack>
using namespace std;
struct element
{
    int weight;        // 权值域
    int lchild, rchild, parent;  // 该结点的左、右、双亲结点在数组中的下标
};
class HTree
{
private:
    element *node;
    int n, m;//n是元素个数
    stack<int> code;
    int setcode(int weight);//返回的是编码的长度哼哼
public:
    HTree(int _n, int _weight[]);
    void select(int &s1, int &s2);
    void creatHT();
    void print();
    int search(int weight);
    void printHTcode();
};
int HTree::search(int weight)
{
    int result = -1;
    for (int i = 0; i < m; i++)
    {
        if (node[i].weight == weight)
        {
            result = i;
        }
    }
    return result;
}
int HTree::setcode(int weight)
{
    int location, parent, k;//location来定位权值所指向的位置，parent即Location的双亲，k是移动指针
    int cont = 0;
    location = search(weight);
    k = location;
    parent = node[location].parent;
    while (node[k].parent!= 0&&k!=-1)
    {
        if (node[parent].lchild == k)
        {
            code.push(0);
        }
        else
        {
            code.push(1);
        }
        k = node[k].parent;
        parent = node[k].parent;
        cont++;
    }
    if (k == -1)
    {
        cout << "未找到！错误！" << endl;
    }
    return cont;
}
void HTree::printHTcode()
{
    cout << "请输入要查询的编码的权值并继续：" << endl;
    int weight, size;
    cin >> weight;
    size=setcode(weight);
    cout << "权值 " << weight << "编码长度: " << size << endl;
    cout << weight << " 编码结果为: ";
    for (int i = 0; i < size; i++)
    {
        cout << code.top() << " ";
        code.pop();
    }
    cout << endl;
}
HTree::HTree(int _n,int _weight[])
{
    n = _n;
    m = 2 * n - 1;            //n个元素需要2*n-1空间
    node = new element[m];    //开辟m个大小的element空间
    for (int i = 0; i <n; i++)
    {
        node[i].weight = _weight[i];//为每一个元素赋初始权值
    }
    for (int i = 0; i < m; i++)
    {
        node[i].lchild = node[i].rchild = node[i].parent = 0;//初始化左孩子右孩子和双亲指针，都为0
    }
    creatHT();//构造哈夫曼树
}
void HTree::select(int &s1, int &s2)
{
    //对两个最小者的选择为双亲下标为0的结点
    for (int i = 0; i < n; i++)
    {
        if (node[i].parent == 0)
        {
            s1=i;    //先找到一个临时比较元素进行最小值比较
            break;
        }
    }
    for (int i = 0; i <n; i++)        //该循环是找到一个最小的并赋值给s1
    {
        if ((node[s1].weight > node[i].weight) && (node[i].parent == 0))        //找双亲为0的
        {
            s1 = i;
        }
    }
    //同s1的比较方法，先找到一个双亲为0的临时值(排除s1)，然后再进行逐一比较找到第二小的值赋值给s2即可
    for (int i = 0; i <n; i++)
    {
        if ((node[i].parent == 0)&&i!=s1)        //排除s1
        {
            s2 = i;    //先找到一个临时比较元素进行最小值比较
            break;
        }
    }
    for (int i = 0; i <n; i++)        //找到除s1以外双亲为0中最小的并赋值给s2
    {
        if ((node[s2].weight > node[i].weight) && (node[i].parent == 0) && (i != s1))
        {
            s2 = i;
        }
    }
    
}
void HTree::creatHT()
{
    for (int i = n; i < m; i++)//执行的是m-n次比较
    {
        int s1, s2;//左小右大
        select(s1, s2);//选择数组中最小且双亲为0的结点
        node[s1].parent = i;//找到后的s1,s2的双亲应该放在n-1后
        node[s2].parent = i;
        node[i].lchild = s1;    //左小
        node[i].rchild = s2;    //右大
        node[i].weight = node[s1].weight + node[s2].weight;
        n++;
    }
}
void HTree::print()
{
    cout << "index weight parent lChild rChild" << endl;
    cout << left;    // 左对齐输出 
    for (int i = 0; i < m; ++i)
    {
        cout << setw(5) << i << " ";
        cout << setw(6) << node[i].weight << " ";
        cout << setw(6) << node[i].parent << " ";
        cout << setw(6) << node[i].lchild << " ";
        cout << setw(6) << node[i].rchild << endl;
    }
    cout << "哈夫曼树打印完毕！" << endl;
}
int main()
{
    cout << "请输入要构造哈夫曼树元素的个数: ";
    int n,*weight;
    cin >> n;
    weight = new int[n + 1];
    cout << "请输入这" << n << "个元素的权值:" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> weight[i];
    }
    HTree test(n, weight);
    test.print();
    test.printHTcode();
    system("pause");
    return 0;
}
点我查看完整代码

测试数据

4

5 2 4 7

4

 

结果：

请输入要构造哈夫曼树元素的个数: 4
请输入这4个元素的权值:
5 2 4 7
index weight parent lChild rChild
0     5      5      0      0
1     2      4      0      0
2     4      4      0      0
3     7      6      0      0
4     6      5      1      2
5     11     6      0      4
6     18     0      3      5
哈夫曼树打印完毕！
请输入要查询的编码的权值并继续：
4
权值 4编码长度: 3
4 编码结果为: 1 1 1
请按任意键继续. . .

特别说明：

这个代码绝对不是最优解:)

但是原理是对的，嘛毕竟自己能力有限~

只要原理懂了可以自己优化优化的~~

各位见笑了，还请多多包涵。

转载于:https://www.cnblogs.com/robotpaul/p/10009312.html

weixin_30343157
关注
霍夫曼树以及霍夫曼编码(动态数组实现方式)
weixin_42295110的博客
08-12 917
霍夫曼编码是用于数据压缩存储的。根据的原理是:任一个字符编码绝对不是另一个字符编码的前缀，并且出现次数最多的字符,所用编码的位数最小。以此来达到数据压缩的目的。 霍夫曼树有两种实现方式：一种是基于链表的实现方式,另一种是基于动态数组的实现方式。 本文是基于动态数组的实现方式: 代码及结果展示： #include<stdio.h> #include<stdlib.h> #include<string.h> #define null NULL /* 哈夫曼树的构建
赫夫曼树编码实现
Shayabean->MyBlog
07-23 1280
赫夫曼编码实现包括以下几个功能： (1) 初始化。从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree.txt中。 (2) 编码。利用已建好的哈夫曼树，对文件ToBeTra.txt中的正文进行编码，然后将结果存入文件CodeFil.txt中。 (3) 译码。利用已建好的哈夫曼树将文件CodeFile.txt中的代码进行译码，结果存入文件Textfile.
数组实现哈夫曼树及哈夫曼编码
hober的专栏
11-27 4408
百度百科介绍：http://baike.baidu.com/link?url=DDUm7qBwh4XVGlhskrXjpQZx6mu74iy-54mkIBMUIME8o22OKvbi61yHxOz0Ljm5YekqESS70n3rTKSHqPu3Z_ 简单的图示介绍： 用数组实现的哈夫曼树及哈夫曼编码： #include <cstdio> #define N 5 #def...
哈夫曼树实现（数组实现）
LIWENXUAN88的博客
11-21 1031
哈夫曼编码节点 public class HFMCodeNode{ int[] bit;//存储叶节点的编码0或1 int start;//标记bit数组为真正编码存储开始的位置。 HFMCodeNode(int n){//n为哈夫曼树的叶节点数目，节点数为n的哈夫曼树的长度最多为n-1个 bit=new int[n]; start=n; } } 哈夫曼树节点 public class HFMTreeNode { int weight; int parent,lc.
用Java数组实现【哈夫曼树】
淮南King的博客
04-22 601
一、基本概念 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L...
头歌数据结构构建哈夫曼树及编码
05-18
哈夫曼树是一种特殊的二叉树，用于解决数据压缩中的编码问题。它的构造原则是使得树中所有叶子节点（代表需要编码的字符）到...此外，哈夫曼树还被广泛应用于数据结构和算法的教学中，帮助学生理解二叉树的操作和应用。
四川大学计算机学院-数据结构与算法分析高分实验报告-改进哈夫曼树类模板.rar
08-18
《四川大学计算机学院数据结构与算法分析实验报告——改进哈夫曼树类模板》 本实验报告详尽探讨了数据结构中的一个重要主题——哈夫曼树及其类模板的改进。哈夫曼树，又称为最优二叉树，是用于数据编码的一种特殊...
【数据结构】哈夫曼树及哈夫曼编码实现（C语言）
热门推荐
weixin_51450101的博客
02-12 6万+
目录1. 哈夫曼树1.1 基本概念1.2 构造哈夫曼树1.3 哈夫曼树的类型定义1.4 哈夫曼树创建的算法实现2. 哈夫曼编码实现2.1 哈夫曼编码2.2 完整代码2.3 运行结果 1. 哈夫曼树 1.1 基本概念 路径：指从根结点到该结点的分支序列。 路径长度：指根结点到该结点所经过的分支数目。 结点的带权路径长度：从树根到某一结点的路径长度与该结点的权的乘积。 树的带权路径长度(WPL)：树中从根到所有叶子结点的各个带权路径长度之和。 哈夫曼树是由 n 个带权叶子结点构成的所有二叉树中带权路径长度最短的
C语言-基于哈夫曼树的数据压缩算法.zip
最新发布
11-15
综上所述，"C语言-基于哈夫曼树的数据压缩算法"是一个涉及数据结构、算法和文件操作的综合实践项目。通过这个项目，开发者不仅可以深入理解哈夫曼编码的工作原理，还能提高C语言编程和问题解决的能力。
数据结构与算法--哈夫曼树/赫夫曼树 Python实现哈夫曼树 Python实现赫夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
storyfull
01-02 3240
哈夫曼树/赫夫曼树 Python实现赫夫曼树 Python实现哈夫曼树 哈夫曼编码 哈夫曼压缩 哈夫曼解压 最简单的方式实现哈夫曼树
动态数组解决哈夫曼树问题
小开心的博客
02-01 487
优先队列实现小根堆解决哈夫曼树问题 北邮考研复试的一道真题，借助优先队列实现小根堆解决求解哈夫曼树的权值问题的方法。之前自己也没有接触过此类用法，整理下来，希望对各位有帮助。 题目描述 哈夫曼树，第一行输入一个数n，表示叶结点的个数。需要用这些叶结点生成哈夫曼树，根据哈夫曼树的概念，这些结点有权值，即weight，题目需要输出所有结点的值与权值的乘积之和的最小值。 输入描述: 输入有多组数据。 每组第一行输入一个数n，接着输入n个叶节点（叶节点权值不超过100，2<=n<=1000）
哈夫曼树建立、哈夫曼编码算法的实现
智慧源
06-25 2549
<br /> #include <stdio.h>/*2009.10.25白鹿原*/ #include <stdlib.h>/*哈夫曼树建立、哈夫曼编码算法的实现*/ #include <string.h> typedef char* HuffmanCode;/*动态分配数组，存储哈夫曼编码*/ typedef struct { unsigned int weight ; /* 用来存放各个结点的权值*/ unsigned int parent, LChild,RChild ; /*指向
数据结构课程设计（三）---Huffman编码
zhulinhao的博客
06-22 2426
1、任务简述： 对一篇英文文章，统计其中26个小写字母出现的频次，对这些小写字母进行Huffman编码。 要求： （1）从文件读入原始文本文件，并在屏幕上显示出文本； （2）按照字母顺序输出字母的出现次数，以及相应的编码。 （3）同时具备解码功能。即输入一串二进制编码，能够还原出文本 2、算法描述： 数据结构: 一颗有n个叶子（n个字符得文章）结点的Huffman树共有2n-1个结点，可以存储在一个大小为2n-1的一维数组中。译码需要从上往下走，编码需要从下往上走，所以对于每个节点都需要知道其双亲，同时也
【数据结构与算法】Huffman树
weixin_63697214的博客
01-08 1056
数据结构与算法
死磕数据结构与算法——哈夫曼树（java实现）。才疏学浅，如有错误，及时指正
qq_41497756的博客
10-24 500
哈夫曼树：给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
哈夫曼树
upHailin的个人专栏
09-04 7390
哈夫曼树 哈夫曼树的概念
哈夫曼树与哈夫曼编码的考点
YYMCR7的博客
07-06 5055
一、哈夫曼树 1.定义 带权路径长度WPL最小的二叉树成为哈夫曼树（最优二叉树） note：哈夫曼树并不唯一，但WPL一定是相同的 2.构造哈夫曼树 基本原则：权值越大的叶子结点越靠近根结点                   权值越小的叶子结点越远离根结点 构造过程： 特点： 栗子：设有7个叶子结点，它们的权集w
哈弗曼树与哈弗曼树编码
行而不辍，未来可期 - King
06-02 7204
哈弗曼（Huffman）树，也称最优树，是一类带全路径长度最短的树，在实际中有广泛的应用，也是二叉树的一个具体应用。 在哈夫曼树的定义中，涉及到了路径、路径长度、权等概念，下面先给出概念的定义。 一、概念与定义 路径：从树的一个结点到另一个结点的分支构成这两个结点之间的路径，对于哈夫曼树特指从根节点到某节点的路径。 路径长度：路径上的分支数目叫做路径长度。 树的路径长度：从树根到每一结点
哈夫曼树与哈夫曼编码
Howard的博客
09-22 1867
哈夫曼树 哈夫曼树又称最优二叉树, 是一种带权路径长度最短的二叉树。在这个二叉树中，只有叶子节点才是有效的数据节点,其他只是作为路径而构造的。 带权路径长度 又称WPL，树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度，即树中所有叶节点的带权路径长度之和。 WPL= (W1*L1+W2*L2+W3*L3+...+Wn*Ln)， N个权值Wi(i=1,2,...n)构成一
哈夫曼树编码及数据结构实现
本文将对哈夫曼树的编码、数据结构、树的遍历、排序等知识点进行详细的讲解。 **哈夫曼树** 哈夫曼树是一种特殊的二叉树，它的每个叶子节点都带有权值，而所有非叶子节点的权值均为其子节点权值的和。哈夫曼树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值