哈夫曼树的实现

最新推荐文章于 2024-05-15 15:28:17 发布
最新推荐文章于 2024-05-15 15:28:17 发布
阅读量179 收藏 1
点赞数 1
文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/is_Jamie/article/details/129975232
版权

目录

引言

树节点的创建

HuffmanTree类

类的初始化-构造函数

有参构造 创建HuffmanTree

析构函数

类的方法

1.遍历

2.复制 WPL 释放内存

主程序

1.测试HuffmanTree是否成功创建

​编辑

2.测试拷贝构造函数

3.测试内存释放

引言

本人只是刚入门的萌新，记录一下自己的学习😊

树节点的创建

struct TreeNode
{
    int weight;//权重
    TreeNode* left, * right;//左右孩子
    TreeNode():weight(0),left(NULL),right(NULL){}
    TreeNode(int w) :weight(w), left(NULL), right(NULL) {}
    TreeNode(int w,TreeNode* l,TreeNode* r) :weight(w), left(l), right(r) {}
};

HuffmanTree类

类的成员属性和方法

class HuffmanTree
{
public:
    HuffmanTree();//空构造
    HuffmanTree(const vector<int>& nums);//创建HuffmanTree
    HuffmanTree(TreeNode* root);//拷贝构造
    ~HuffmanTree();//析构函数 释放内存
    void preOrder(TreeNode* root);//前序遍历
    void inOrder(TreeNode* root);//后序遍历
    void postOrder(TreeNode* root);//中序遍历
    void layerOrder();//层次遍历
    int calculateWPL();//计算带权路径和
    void deleteTree(TreeNode* root);//释放内存
    TreeNode* copyTree(TreeNode* root);//树的拷贝
public:
    TreeNode* root;
};

  1. 类的初始化-构造函数

空构造

HuffmanTree::HuffmanTree()
{
    this->root = NULL;
}

有参构造 创建HuffmanTree

class myCmp
{
public:
    bool operator()(TreeNode* left,TreeNode* right)
    {
        return left->weight > right->weight;
    }
};
HuffmanTree::HuffmanTree(const vector<int>& nums)
{
    //利用优先队列的特性 解决每次排序的时间浪费
    priority_queue<TreeNode*, vector<TreeNode*>,myCmp > q;
    for (int i = 0; i < nums.size(); i++)
    {
        TreeNode* node = new TreeNode(nums[i]);
        q.push(node);
    }
    TreeNode* left = NULL, * right = NULL, *root = NULL;
    while (q.size()!=1)
    {
        left = q.top();
        q.pop();
        right = q.top();
        q.pop();
        root = new TreeNode(left->weight + right->weight, left, right);
        q.push(root);
    }
    this->root = root;
}

拷贝构造

HuffmanTree::HuffmanTree(TreeNode* root)
{
    this->root = copyTree(root);
}

  1. 析构函数

HuffmanTree::~HuffmanTree()
{
    if (this->root == NULL) return;
    deleteTree(this->root);
}

  1. 类的方法

1.遍历

前序遍历

void HuffmanTree::preOrder(TreeNode* root)
{
    if (root == NULL) return;
    cout << root->weight << " ";
    preOrder(root->left);
    preOrder(root->right);
}

中序遍历

void HuffmanTree::inOrder(TreeNode* root)
{
    if (root == NULL) return;
    inOrder(root->left);
    cout << root->weight << " ";
    inOrder(root->right);
}

后序遍历

void HuffmanTree::postOrder(TreeNode* root)
{
    if (root == NULL) return;
    postOrder(root->left);
    postOrder(root->right);
    cout << root->weight << " ";
}

层次遍历

void HuffmanTree::layerOrder()
{
    if (this->root == NULL) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty())
    {
        int len = q.size();
        TreeNode* tmp;
        for (int i = 0; i < len; i++)
        {
            tmp = q.front();
            q.pop();
            cout << tmp->weight << " ";
            if (tmp->left != NULL) q.push(tmp->left);
            if (tmp->right != NULL) q.push(tmp->right);
        }
        cout << endl;
    }
}

2.复制 WPL 释放内存

  1. 树的复制

TreeNode* HuffmanTree::copyTree(TreeNode* root)
{
    if (root == NULL) return NULL;
    TreeNode* left = copyTree(root->left);
    TreeNode* right = copyTree(root->right);
    root = new TreeNode(root->weight, left, right);
    return root;
}

  1. 计算带权路径总和

广度优先搜索 与层次遍历的思想一致

int HuffmanTree::calculateWPL()
{
    if (this->root == NULL) return 0;
    int ans = 0,layer=0;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty())
    {
        int len = q.size();
        TreeNode* tmp;
        for (int i = 0; i < len; i++)
        {
            tmp = q.front();
            q.pop();
            if (tmp->left != NULL) q.push(tmp->left);
            if (tmp->right != NULL) q.push(tmp->right);
            if (tmp->left == NULL && tmp->right == NULL) ans += (tmp->weight * layer);
        }
        layer++;
    }
    return ans;
}

  1. 释放内存

void HuffmanTree::deleteTree(TreeNode* root)
{
    if (root == NULL) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
    this->root = NULL;//将成员root置空 防止野指针
}

主程序

#include<iostream>
using namespace std;
#include<vector>
#include<queue>
struct TreeNode
{
    int weight;
    TreeNode* left, * right;
    TreeNode():weight(0),left(NULL),right(NULL){}
    TreeNode(int w) :weight(w), left(NULL), right(NULL) {}
    TreeNode(int w,TreeNode* l,TreeNode* r) :weight(w), left(l), right(r) {}
};
class HuffmanTree
{
public:
    HuffmanTree();//空构造
    HuffmanTree(const vector<int>& nums);//创建HuffmanTree
    HuffmanTree(TreeNode* root);//拷贝构造
    ~HuffmanTree();//析构函数 释放内存
    void preOrder(TreeNode* root);//前序遍历
    void inOrder(TreeNode* root);//后序遍历
    void postOrder(TreeNode* root);//中序遍历
    void layerOrder();//层次遍历
    int calculateWPL();//计算带权路径和
    void deleteTree(TreeNode* root);//释放内存
    TreeNode* copyTree(TreeNode* root);//树的拷贝
public:
    TreeNode* root;
};
class myCmp
{
public:
    bool operator()(TreeNode* left,TreeNode* right)
    {
        return left->weight > right->weight;
    }
};
void test01(const vector<int>& nums)//测试HuffmanTree是否成功创建
{
    HuffmanTree t(nums);
    cout << "前序遍历: "; t.preOrder(t.root); cout << endl;
    cout << "中序遍历: "; t.inOrder(t.root);cout << endl;
    cout << "后序遍历: "; t.postOrder(t.root);cout << endl;
    cout << "层次遍历: " << endl; t.layerOrder(); 
    cout << "带权路径总和(WPL): " << t.calculateWPL() << endl;
}
void test02(const vector<int>& nums)//验证拷贝构造函数
{
    HuffmanTree t1(nums);
    cout << "层次遍历: " << endl; t1.layerOrder();
    HuffmanTree t2(t1.root);
    cout << "层次遍历: " << endl; t1.layerOrder();
}
void test03(const vector<int>& nums)//测试内存释放
{
    HuffmanTree t(nums);
    t.deleteTree(t.root);//提前释放内存，查看是否与析构时冲突
    cout << "层次遍历: " << endl; t.layerOrder();
}
int main()
{
    vector<int> nums{ 10,20,50,100 };
    //测试HuffmanTree是否成功创建
    //test01(nums);
    //验证拷贝构造函数
    //test02(nums);
    //测试内存释放
    test03(nums);
    return 0;
}

HuffmanTree::HuffmanTree()
{
    this->root = NULL;
}

HuffmanTree::HuffmanTree(const vector<int>& nums)
{
    //利用优先队列的特性 解决每次排序的时间浪费
    priority_queue<TreeNode*, vector<TreeNode*>,myCmp > q;
    for (int i = 0; i < nums.size(); i++)
    {
        TreeNode* node = new TreeNode(nums[i]);
        q.push(node);
    }
    TreeNode* left = NULL, * right = NULL, *root = NULL;
    while (q.size()!=1)
    {
        left = q.top();
        q.pop();
        right = q.top();
        q.pop();
        root = new TreeNode(left->weight + right->weight, left, right);
        q.push(root);
    }
    this->root = root;
}

HuffmanTree::HuffmanTree(TreeNode* root)
{
    this->root = copyTree(root);
}

HuffmanTree::~HuffmanTree()
{
    if (this->root == NULL) return;
    deleteTree(this->root);
}

void HuffmanTree::preOrder(TreeNode* root)
{
    if (root == NULL) return;
    cout << root->weight << " ";
    preOrder(root->left);
    preOrder(root->right);
}

void HuffmanTree::inOrder(TreeNode* root)
{
    if (root == NULL) return;
    inOrder(root->left);
    cout << root->weight << " ";
    inOrder(root->right);
}

void HuffmanTree::postOrder(TreeNode* root)
{
    if (root == NULL) return;
    postOrder(root->left);
    postOrder(root->right);
    cout << root->weight << " ";
}

void HuffmanTree::layerOrder()
{
    if (this->root == NULL) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty())
    {
        int len = q.size();
        TreeNode* tmp;
        for (int i = 0; i < len; i++)
        {
            tmp = q.front();
            q.pop();
            cout << tmp->weight << " ";
            if (tmp->left != NULL) q.push(tmp->left);
            if (tmp->right != NULL) q.push(tmp->right);
        }
        cout << endl;
    }
}

int HuffmanTree::calculateWPL()
{
    if (this->root == NULL) return 0;
    int ans = 0,layer=0;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty())
    {
        int len = q.size();
        TreeNode* tmp;
        for (int i = 0; i < len; i++)
        {
            tmp = q.front();
            q.pop();
            if (tmp->left != NULL) q.push(tmp->left);
            if (tmp->right != NULL) q.push(tmp->right);
            if (tmp->left == NULL && tmp->right == NULL) ans += (tmp->weight * layer);
        }
        layer++;
    }
    return ans;
}

void HuffmanTree::deleteTree(TreeNode* root)
{
    if (root == NULL) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
    this->root = NULL;//将成员root置空 防止野指针
}

TreeNode* HuffmanTree::copyTree(TreeNode* root)
{
    if (root == NULL) return NULL;
    TreeNode* left = copyTree(root->left);
    TreeNode* right = copyTree(root->right);
    root = new TreeNode(root->weight, left, right);
    return root;
}

1.测试HuffmanTree是否成功创建

void test01(const vector<int>& nums)//测试HuffmanTree是否成功创建
{
    HuffmanTree t(nums);
    cout << "前序遍历: "; t.preOrder(t.root); cout << endl;
    cout << "中序遍历: "; t.inOrder(t.root);cout << endl;
    cout << "后序遍历: "; t.postOrder(t.root);cout << endl;
    cout << "层次遍历: " << endl; t.layerOrder(); 
    cout << "带权路径总和(WPL): " << t.calculateWPL() << endl;
}

测试结果正确 实现树的创建

2.测试拷贝构造函数

void test02(const vector<int>& nums)//验证拷贝构造函数
{
    HuffmanTree t1(nums);
    cout << "层次遍历: " << endl; t1.layerOrder();
    HuffmanTree t2(t1.root);
    cout << "层次遍历: " << endl; t1.layerOrder();
}

两棵树的节点一致，并实现深拷贝（t1和t2析构时不发生冲突）

 

3.测试内存释放

void test03(const vector<int>& nums)//测试内存释放
{
    HuffmanTree t(nums);
    t.deleteTree(t.root);//提前释放内存，查看是否与析构时冲突
    cout << "层次遍历: " << endl; t.layerOrder();
}

树被清空且不与析构函数发生冲突

 

is_Jamie
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
哈夫曼树实现数据压缩
weixin_48065337的博客
12-11 1494
java实现哈夫曼树，利用哈夫曼编码进行数据压缩，解决压缩数据恢复不一致现象
哈夫曼树实现文件的压缩与解压
xiaomin_549的博客
06-20 2697
huffman_tree.h #include <iostream> #include <fstream> #include <bitset> #include "huffman_tree.h" void compress(){ store s[256]; int num=0; //记录文件中读取的不同的字符个数 int count = 0; for(int i=0;i<256;i++){ s[i].weight = 0; } ifstr
哈夫曼树（C语言实现）
热门推荐
2021dragon的博客
06-18 9万+
文章目录哈夫曼树的基本概念哈夫曼树的构建构建思路代码实现哈夫曼编码的生成编码生成思路代码实现完整代码展示以及代码测试 哈夫曼树的基本概念 在认识哈夫曼树之前，你必须知道以下几个基本术语： 1、什么是路径？  给定N个权值作为N个结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称该二叉树为哈夫曼树，也被称为最优二叉树。 哈夫曼树的构建 构建思路 代码实现 哈夫曼编码的生成 编码生成思路 代码实现 完整代码展示以及代码测试 ...
哈夫曼树应用：构建、编码和解码c++实现
yiyidedakeaiya的博客
05-06 734
哈夫曼树应用：构建、编码和解码c++实现
哈夫曼树实现
2301_80454865的博客
05-15 335
【代码】哈夫曼树实现。
使用哈夫曼树实现文本编码、解码
roc13718296531的博客
12-23 4031
使用二叉树存储结构的链表，进行构造二叉树，对指定字符串编码解码
哈夫曼树实现（数组实现）
LIWENXUAN88的博客
11-21 1004
哈夫曼编码节点 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.
哈夫曼树实现文件压缩
精致的灰的博客
09-11 3380
使用哈夫曼树实现文件的压缩和解压缩
利用哈夫曼树实现文件压缩与解压缩
weixin_43416586的博客
05-11 3321
Haffman树的一个重要应用就是通过哈夫曼编码进行文件的压缩 进行文件压缩时，通过文件内容创建一棵哈夫曼树，根据这个哈夫曼树为每个字符编码，然后将原文件的字符替换为哈夫曼编码，生成一个二进制文件。解压缩时，读取二进制文件，根据哈夫曼编码得到原来的字符 结点和树的创建 我的思路是将每个字符作为一个树结点，包含数据，权值，编码等信息，先读取文件创建好所有的节点，通过一个指针数组记录这些结点，最后根据这些节点创建一棵哈夫曼树。另外，在读取文件时，需要知道某个字符是否已经有结点了，需要创建另外一个数组来记录这个
【数据结构】哈夫曼树实现文件的压缩与解压缩
清风微醺的博客
06-06 1624
哈夫曼树实现文件的压缩与解压缩
基于C语言实现的利用哈夫曼树实现文本文件压缩解压.zip
05-10
总的来说，利用C语言和哈夫曼树实现文本文件的压缩和解压是一项涉及数据结构、算法和文件操作的综合任务。理解哈夫曼树的构造过程和编码原理，以及如何在C语言环境中有效地实现这些概念，对于提升程序设计能力...
C++实现哈夫曼树算法
08-19
C++实现哈夫曼树算法是对哈夫曼树数据结构的实现，哈夫曼树是一种特殊的二叉树，它的每个叶子节点都带有一个权值，所有叶子节点的权值之和为1，哈夫曼树的构建是基于哈夫曼编码的原理。下面是C++实现哈夫曼树算法的...
C语言实现哈夫曼树
12-20
下面将详细解释如何用C语言实现哈夫曼树，并结合给出的代码进行解析。 首先，我们定义`HuffmanNode`结构体，它表示哈夫曼树中的节点。结构体包含以下成员： - `char letter`：存储的字符，叶节点为实际的字母，非叶...
用哈夫曼树实现压缩解压.pdf
08-27
哈夫曼树实现压缩解压 哈夫曼树是一种基于Variable-Length Prefix Codes（变长前缀码）的压缩算法，通过构建哈夫曼树来实现压缩和解压缩。下面是该算法的详细知识点： 1. 哈夫曼树的构建： 哈夫曼树是一棵二叉树...
基于C++实现的使用哈夫曼树实现文本文件无损压缩.zip
05-10
在C++中实现哈夫曼树进行文本文件的无损压缩，涉及到以下几个核心概念和技术： 1. **哈夫曼树（Huffman Tree）**：哈夫曼树是一种特殊的二叉树，也称为最优二叉树，它的特点是每个叶子节点代表一个需要编码的字符，...
哈夫曼树C++实现
04-24
在C++中实现哈夫曼树，我们需要理解其基本原理并熟悉C++编程语言。 哈夫曼树的基本概念： 1. **叶子节点**：哈夫曼树中的叶子节点代表要编码的字符，每个叶子节点都包含一个字符及其频率。 2. **非叶子节点**：非...
基于C++哈夫曼树实现的简易版文件压缩【100012737】
06-12
基于C++的哈夫曼树实现简易版文件压缩是一个典型的课程设计项目，它涉及到计算机科学中的编码理论和数据结构。下面将详细介绍这个主题涉及的知识点。 首先，哈夫曼编码是一种高效的前缀编码方法，由哈夫曼在1952年...
构造哈夫曼树实现c++
最新发布
05-26
构造哈夫曼树是一种常用的数据压缩算法，下面是C++实现哈夫曼树的简单介绍： 1. 定义哈夫曼树的节点结构体，包括字符、权值、左右子节点等信息。 2. 定义一个哈夫曼树的节点比较器，用于按照权值从小到大排序。 3...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值