[实例]利用霍夫曼树获得霍夫曼编码并进行加密和解密

最新推荐文章于 2023-05-15 17:12:01 发布
最新推荐文章于 2023-05-15 17:12:01 发布
阅读量521 收藏 1
点赞数
分类专栏： C++ 数据结构和算法 文章标签： 数据结构与算法 php
[align=center][img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14671735779402431&size=800_600&devtype=web&v=1.0.1&rtick=14671736103546&share_qid=108635719&sign=954b8f2ce796ba5572c7812499ac61f8&[/img] [/align]

[align=center][img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14671798239497213&size=800_600&devtype=web&v=1.0.1&rtick=14671798308044&share_qid=108635719&sign=dc6e95501416aeaa4c6e13b685de7e89&[/img][/align]

奋战一个晚上把基本功能实现了 

//HuffmanTree.h

#ifndef HUFFMAN_TREE_H
#define HUFFMAN_TREE_H

#include <Windows.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

namespace HuffmanTreeSpace
{
    struct HuffmanTreeNode
    {
        int nData;
        string strData;
        string strHuffmanCodeing;
        HuffmanTreeNode* pRoot;
        HuffmanTreeNode* pLeftChild;
        HuffmanTreeNode* pRightChild;

        HuffmanTreeNode()
        {
            nData = 0;

            pRoot = NULL;
            pLeftChild = NULL;
            pRightChild = NULL;
        }

//         bool operator < (const HuffmanTreeNode& rhs) const // 升序排序时必须写的函数
//         {
//             return nData < rhs.nData;
//         }
//         bool operator > (const HuffmanTreeNode& rhs) const // 降序排序时必须写的函数
//         {
//             return nData > rhs.nData;
//         }
    };

    typedef struct tag_SingleCode
    {
        int nData;
        string strData;
        string strCoding;
    }SingleCode, *PSingleCode;

    typedef vector<HuffmanTreeNode*> TreeNodeArray;
    typedef vector<SingleCode> HuffmanCodingTable;

    enum  EM_HUFFMAN_ORDER
    {
        EM_HUFFMAN_DLR = 0,
        EM_HUFFMAN_LDR = 1,
        EM_HUFFMAN_LRD = 2
    };

    class HuffmanTree
    {
    public:
        HuffmanTree();

        void AddRawDataToNode(string strData);
        void AddNode(int nData, string strData);
        void MySort();

        void Gnenerate();
        void PrintTreeNode();

        void PrintNode(EM_HUFFMAN_ORDER emType, const HuffmanTreeNode* pNode);
        void GetHuffmanNode(const HuffmanTreeNode* pNode, int nData, string strData);
        string PrintHuffmanCode(int nData, string strData);

        HuffmanTreeNode* GetRoot()
        {
            return m_pRootNode;
        }

        void GenerateCodingTable();
        string HuffmanEncoding(const string& strRaw);
        string HuffmanDecoding(const string& strEncoded);

    public:
        string m_strTemp;
        const HuffmanTreeNode* m_pTemp;

        HuffmanCodingTable m_CodingTable;

    private:
        TreeNodeArray m_TreeNodes; //本示例没有考虑内存的释放，后续可以改进
        HuffmanTreeNode* m_pRootNode;
        string strHuffCode;
    };

    //
    void HuffmanTree_Test1();
    void HuffmanTree_Test2();
    void HuffmanTree_Test3();
}

#endif



#include "HuffmanTree.h"

namespace HuffmanTreeSpace
{
    HuffmanTree::HuffmanTree()
        :m_pRootNode(NULL)
    {
    }

    bool less_second(char char1, char char2)
    {
        return char1 < char2;
    }

    void HuffmanTree::AddRawDataToNode(string strData)
    {
        m_CodingTable.clear();

        //统计字符出现的频率
        string strTemp = strData;
        sort(strTemp.begin(), strTemp.end()/*, less_second*/);

        while (strTemp.size() > 0)
        {
            string strData;
            const char* ptr = strTemp.c_str();
            int nSize = count(strTemp.begin(), strTemp.end(), *ptr);
            strData = *ptr;

            AddNode(nSize, strData);

            strTemp = strTemp.substr(nSize, strTemp.size()-nSize);
        }
    }

    void HuffmanTree::AddNode(int nData, string strData)
    {
        HuffmanTreeNode* pNode = new HuffmanTreeNode();
        pNode->nData = nData;
        pNode->strData = strData;
        m_TreeNodes.push_back(pNode);

        SingleCode singleCode;
        singleCode.nData = nData;
        singleCode.strData = strData;
        m_CodingTable.push_back(singleCode);
    }

    //升序排序
    bool lessmark(const HuffmanTreeNode* treeNode1, const HuffmanTreeNode* treeNode2)
    {
        return (treeNode1->nData < treeNode2->nData);
    }

    //降序排序
    bool greatermark(const HuffmanTreeNode* treeNode1, const HuffmanTreeNode* treeNode2)
    {
        return treeNode1->nData > treeNode2->nData;
    }


    void HuffmanTree::MySort()
    {
        sort(m_TreeNodes.begin(), m_TreeNodes.end(), lessmark);
    }

    void HuffmanTree::Gnenerate()
    {
        MySort();

        while (m_TreeNodes.size() > 1)
        {
            //PrintTreeNode();

            int nsize = m_TreeNodes.size();
            TreeNodeArray::iterator iter = m_TreeNodes.begin();
            TreeNodeArray::iterator iter2 = m_TreeNodes.begin();
            ++iter2;

            HuffmanTreeNode* pNode = new HuffmanTreeNode();

            pNode->nData = (*iter)->nData + (*iter2)->nData;
            pNode->strData = (*iter)->strData + (*iter2)->strData;
            (*iter)->strHuffmanCodeing = "0";
            (*iter2)->strHuffmanCodeing = "1";

            (*iter)->pRoot = pNode;
            (*iter2)->pRoot = pNode;

            pNode->pLeftChild = *iter;
            pNode->pRightChild = *iter2;

            m_TreeNodes.erase(iter2);
            m_TreeNodes.erase(iter);

            m_TreeNodes.push_back(pNode);

            MySort();
        }

        m_pRootNode = *m_TreeNodes.begin();

        GenerateCodingTable();
    }

    void HuffmanTree::PrintTreeNode()
    {
        TreeNodeArray::iterator iter = m_TreeNodes.begin();
        TreeNodeArray::iterator end = m_TreeNodes.end();

        for(; iter != end; ++iter)
        {
            cout << "Val = " << (*iter)->nData << "str = " << (*iter)->strData << " address = "  <<(*iter)->pLeftChild << ", " <<(*iter)->pRightChild << endl;
        }
    }

    void HuffmanTree::PrintNode(EM_HUFFMAN_ORDER emType, const HuffmanTreeNode* pNode)
    {
        if (pNode != NULL)
        {
            if (EM_HUFFMAN_DLR == emType)
            {
                cout << " " << pNode->nData << "(" << pNode->strData << "," << pNode->strHuffmanCodeing << ")";
            }

            //Get Left Leaf
            if (pNode->pLeftChild != NULL)
            {
                PrintNode(emType, pNode->pLeftChild);
            }

            if (EM_HUFFMAN_LDR == emType)
            {
                cout << " " << pNode->nData << "(" << pNode->strData << "," << pNode->strHuffmanCodeing << ")";
            }

            //Get Right Leaf
            if (pNode->pRightChild != NULL)
            {
                PrintNode(emType, pNode->pRightChild);
            }

            if (EM_HUFFMAN_LRD == emType)
            {
                cout << " " << pNode->nData << "(" << pNode->strData << "," << pNode->strHuffmanCodeing << ")";
            }
        }
    }

    void HuffmanTree::GetHuffmanNode(const HuffmanTreeNode* pNode, int nData, string strData)
    {
        if (pNode != NULL)
        {
            if (pNode->nData==nData
             && pNode->strData==strData)
            {
                if (NULL == m_pTemp)
                {
                    m_pTemp = pNode;
                }
                return;
            }
            else
            {
                m_strTemp = m_strTemp.substr(0, m_strTemp.length()-1);
            }

            //Get Left Leaf
            if (pNode->pLeftChild != NULL)
            {
                if (pNode->pLeftChild->nData==nData
                 && pNode->pLeftChild->strData==strData)
                {
                    if (NULL == m_pTemp)
                    {
                        m_pTemp = pNode->pLeftChild;
                    }

                    m_strTemp = m_strTemp.substr(0, m_strTemp.length()-1);
                    return;
                }
                else
                {
                    GetHuffmanNode(pNode->pLeftChild, nData, strData);
                    //cout << "0";
                    //m_strTemp = "0" + m_strTemp;
                }
            }
            else
            {
                m_strTemp = m_strTemp.substr(0, m_strTemp.length()-1);
            }

            //Get Right Leaf
            if (pNode->pRightChild != NULL)
            {
                if (pNode->pRightChild->nData==nData
                    && pNode->pRightChild->strData==strData)
                {
                    if (NULL == m_pTemp)
                    {
                        m_pTemp = pNode->pRightChild;
                    }

                    m_strTemp = m_strTemp.substr(0, m_strTemp.length()-1);
                    return;
                }
                else
                {
                    GetHuffmanNode(pNode->pRightChild, nData, strData);
                    //cout << "1";
                    //m_strTemp = "1" + m_strTemp;
                }
            }
            else
            {
                m_strTemp = m_strTemp.substr(0, m_strTemp.length()-1);
            }
        }
    }

    string HuffmanTree::PrintHuffmanCode(int nData, string strData)
    {
        string strHuffmanCode;

        m_strTemp = "";
        m_pTemp = NULL;

        //cout << "---------------------------------------------------" << endl;
        GetHuffmanNode(m_pRootNode, nData, strData);
        //cout << "Temp=" << m_strTemp  << "\n" << strData << "(" << nData << ") = ";

        const HuffmanTreeNode* ptr = m_pTemp;
        while (ptr != NULL)
        {
            strHuffmanCode = ptr->strHuffmanCodeing + strHuffmanCode;
            //cout << " " << ptr->nData << "(" << ptr->strHuffmanCodeing << ")";
            ptr = ptr->pRoot;
        }
        cout << strData << " = " << strHuffmanCode << endl;
        //cout << "---------------------------------------------------" << endl;

        return strHuffmanCode;
    }

    void HuffmanTree::GenerateCodingTable()
    {
        HuffmanCodingTable::iterator iter= m_CodingTable.begin();
        HuffmanCodingTable::iterator end= m_CodingTable.end();

        for ( ; iter != end; ++iter)
        {
            iter->strCoding = PrintHuffmanCode(iter->nData, iter->strData);
        }
    }

    string& replace_all_distinct(string& str,const   string&   old_value,const   string&   new_value)
    {
        for(string::size_type   pos(0);   pos!=string::npos;   pos+=new_value.length())
        {
            if ((pos=str.find(old_value,pos))!=string::npos)
            {
                str.replace(pos,old_value.length(),new_value);
            }
            else
            {
                break;
            }
        }

        return str;
    }

    string HuffmanTree::HuffmanEncoding(const string& strRaw)
    {
        HuffmanCodingTable::const_iterator iter= m_CodingTable.begin();
        HuffmanCodingTable::const_iterator end= m_CodingTable.end();
        string strTemp = strRaw;

        for ( ; iter != end; ++iter)
        {
            replace_all_distinct(strTemp, iter->strData, iter->strCoding);
        }

        return strTemp;
    }

    string HuffmanTree::HuffmanDecoding(const string& strEncoded)
    {
        string strTemp = strEncoded;
        string strNew;

        while (strTemp.length() > 0)
        {
            HuffmanCodingTable::const_iterator iter= m_CodingTable.begin();
            HuffmanCodingTable::const_iterator end= m_CodingTable.end();
            for ( ; iter != end; ++iter)
            {
                //replace_all_distinct(strTemp, iter->strData, iter->strCoding);
                size_t nPos = strTemp.find(iter->strCoding);

                if (0 == nPos)
                {
                    //cout << "\n" << strTemp << " ==> \n";
                    strTemp = strTemp.substr(iter->strCoding.length(), strTemp.size()-iter->strCoding.length());
                    //cout << strTemp << endl;
                    strNew += iter->strData;
                    //cout << "\n" << strNew << endl;
                    break;
                }
            }
        }

        return strNew;
    }

    //
    void HuffmanTree_Test1()
    {
        string strRawData = "abdacdcdBAdCCCCdCDdDD";
        string strEncoding;
        string strDecoding;
        HuffmanTree huffmanTree;

        cout << "------------------HuffmanTree_Test1-----------------------\n";
        cout << "Pliantext = "  << strRawData << endl;

        huffmanTree.AddNode(2, "a");
        huffmanTree.AddNode(1, "b");
        huffmanTree.AddNode(2, "c");
        huffmanTree.AddNode(6, "d");
        huffmanTree.AddNode(1, "A");
        huffmanTree.AddNode(1, "B");
        huffmanTree.AddNode(5, "C");
        huffmanTree.AddNode(3, "D");

        huffmanTree.Gnenerate();

        strEncoding = huffmanTree.HuffmanEncoding(strRawData);
        cout << "Encoding = "  << strEncoding << endl;

        strDecoding = huffmanTree.HuffmanDecoding(strEncoding); //
        cout << "Decoding = "  << strDecoding << endl;
        cout << "----------------------------------------------------------\n";

    }

    void HuffmanTree_Test2()
    {
        string strRawData = "abdacdcdBAdCCCCdCDdDD";
        string strEncoding;
        string strDecoding;
        HuffmanTree huffmanTree;

        cout << "------------------HuffmanTree_Test2-----------------------\n";
        cout << "Pliantext = "  << strRawData << endl;

        huffmanTree.AddRawDataToNode(strRawData);
        huffmanTree.Gnenerate();

        strEncoding = huffmanTree.HuffmanEncoding(strRawData);
        cout << "Encoding = "  << strEncoding << endl;

        strDecoding = huffmanTree.HuffmanDecoding(strEncoding); //
        cout << "Decoding = "  << strDecoding << endl;
        cout << "----------------------------------------------------------\n";
    }

    void HuffmanTree_Test3()
    {
        string strRawData = "abdacdcdBAdCCCCdCDdDD";
        string strEncoding;
        string strDecoding;
        HuffmanTree huffmanTree;

        cout << "------------------HuffmanTree_Test3-----------------------\n";
        cout << "Pliantext = "  << strRawData << endl;

        huffmanTree.AddNode(1, "A");
        huffmanTree.AddNode(1, "B");
        huffmanTree.AddNode(5, "C");
        huffmanTree.AddNode(3, "D");
        huffmanTree.AddNode(2, "a");
        huffmanTree.AddNode(1, "b");
        huffmanTree.AddNode(2, "c");
        huffmanTree.AddNode(6, "d");

        huffmanTree.Gnenerate();

        strEncoding = huffmanTree.HuffmanEncoding(strRawData);
        cout << "Encoding = "  << strEncoding << endl;

        strDecoding = huffmanTree.HuffmanDecoding(strEncoding); //
        cout << "Decoding = "  << strDecoding << endl;
        cout << "----------------------------------------------------------\n";
    }
}


[align=center][img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14671735789406227&size=800_600&devtype=web&v=1.0.1&rtick=14671736108716&share_qid=108635719&sign=f9b614324624a36f7c013bf10acad51b&[/img][/align]
[align=center][img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14671735789410839&size=800_600&devtype=web&v=1.0.1&rtick=14671736109530&share_qid=108635719&sign=3faaeea3a846bc8220039b195cafa811&[/img][/align]
[align=center][img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14671735799417092&size=800_600&devtype=web&v=1.0.1&rtick=14671736108316&share_qid=108635719&sign=4d07d228dcad16ae37be0eefb456c274&[/img][/align]
Jacky_Dai
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++利用哈夫曼编码实现文件的压缩加密和解压缩解密
weixin_73548574的博客
05-25 2848
c++利用哈夫曼编码实现文件的压缩加密和解压缩解密，哈夫曼树
【课程设计】 哈夫曼树的应用：字符串的加密与解密
Minnie_wa的专栏
01-13 6903
一．实验任务 在一个加密应用中，要处理的信息来自下面的字符集，各个字符的相关使用频度如下： 字符空格 A  B  C D   E F  G   H  I  J  K  L M 频度 180 64 13 23  32103 2215   47 57  1 5 31  20 字符 N O  P   Q R  S T   U  V  W X Y Z 频度 55 63  15 1 48  56
（C++）Huffman编码 加密压缩并解码文件
谁取了我的ID：gz007的博客
05-13 2174
Huffman编码 加密压缩并解码文件Huffman编码实验目的实验内容实验说明主要数据类型与变量插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Huffman编码 实验目的 掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 实验内容 实现文件中数据的加解密与压缩：将硬盘上的一个文本
数据结构（哈夫曼树+KMP）之 数据加密+解密
qq_43552933的博客
09-06 1958
数据结构（哈夫曼树+KMP）之 数据加密+解密 原理：参考趣学数据结构 代码： #include<stdio.h> #include<stdlib.h> #define N 100 #define INF 2^31-1 int next[N]; int Sum = 0;//权重总和 typedef struct fNode {//哈夫曼树中每个节点的信息 int c;//字符 int parent;//父节点，左右孩子，权重 int lchild, rchild; int w
哈夫曼编码和解码
最新发布
m0_69251699的博客
05-15 2089
哈夫曼编码方法： 1、统计字符集中每个字符在电文中出现的平均概率（概率越大，要求编码越短)。 2、利用哈夫曼树的特点:权越大的叶子离根越近;将每个字符的概率值作为权值，构造哈夫曼树。则概率越大的结点，路径越短。 3、在哈夫曼树的每个分支上标上0或1，结点的左分支标0，右分支标1，把从根到每个叶子的路径上的标号连接起来，作为该叶子代表的字符的编码。
VB6压缩解压缩、加密解密源码大全
06-10
总之，"VB6压缩解压缩、加密解密源码大全"是一个宝贵的资源，它提供了大量实际应用的实例，可以帮助开发者深入理解并实践加密与压缩技术，从而提升软件的安全性和效率。无论是初学者还是经验丰富的程序员，都能从中...
数据结构与算法-C语言版本
11-05
- **贪心算法**：每次做出局部最优选择，期望达到全局最优，如霍夫曼编码、Prim最小生成树算法、Dijkstra最短路径算法。 - **回溯法**：尝试所有可能的解决方案，一旦发现不满足条件则退回一步重新选择，如八皇后...
信息与编码，学习信息论与编码技术的很好的课件
06-12
例如，霍夫曼编码利用频率统计进行变字长编码，使得频繁出现的符号占据较少的位数。 2. 信道编码：旨在增加数据的冗余度，以对抗信道噪声和错误。常见的信道编码有奇偶校验码、循环冗余校验（CRC）、汉明码以及更...
【Java 通过Huffman实现用户密码加密】
weixin_42176639的博客
04-01 150
Java 通过Huffman实现用户密码加密
哈夫曼树算法文件全加密解密
07-01
文本文件的加密和解密。某公司有一份机密文件，是由英文字母（大小写）、英文逗号、英文句点、空格和回车等符号组成的文件名为Jimi.txt的文本文件。公司为了保证文件不被泄密，要求技术人员将文件中的每个字符都用一个二进制位串进行加密，需要时能进行解密，但必须保证加密后的文件不能过大，且对加密的文件进行解密后与原文件必须完全一致。菜单包括： 1. 显示原文本文件 2.文本文件加密 3.显示字符编码 4.显示加密文件 5.文本文件解密 6.显示解密文件 7.退出系统
哈夫曼树加解密算法C语言
06-25
实现哈夫曼树加解密算法 可对文件进行加解密
对文本进行哈弗曼加密解密
07-09
对txt文本中的数据进行提取，并创建哈夫曼树，并进行编码。 给予哈夫曼树和编码，将其翻译成字符，并存入txt文本中。
C++ 哈夫曼树对文件压缩、加密实现代码
08-29
主要介绍了C++ 哈夫曼树对文件压缩、加密实现代码,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
哈夫曼树--链表实现编码，解码
07-07
1. 将提供的字符串（自定义字符串）进行排序，获取各个字符的权重； 2. 将字符及对应的权重放入树节点（node）中，用链表将各个节点有序的（按权重升序）链接； 3. 实现链表的增、删功能； 4. 遍历链表，将链表的前两个节点中权重相加，生成新节点，然后将新节点插入到有序链表中； 5. 直到链表中只剩一个节点时，将此节点赋给哈夫曼树头； 6. 利用创建的哈夫曼树得到编码； 用递归得到叶子节点，由叶子节点追溯到根节点，得到编码后反转顺序；
数据结构（36）哈夫曼树和哈夫曼编码
李白
06-21 2611
目录 1、哈夫曼树的定义 2、哈夫曼树的构造 3、哈夫曼编码 1、哈夫曼树的定义 在许多应用中，树中结点常常被赋予一个表示某种意义的数值，称为该结点的权。从树的根到任意结点的路径长度（经过的边数）与该结点上权值的乘积，称为该结点的带权路径长度。树中所有叶结点的带权路径长度之和称为该树的带权路径长度，记为 式中，Wi是第i个叶结点所带的权值，Li是该叶结点到根节点的路径长度。 在含有n个带权叶结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。例如，图36-1
加密与压缩，霍夫曼编码解码
miangangzhen的博客
06-22 2561
简介：通过统计一篇文章（或一本书）中每个字符出现的频率（比如字母a出现了100次），对文中出现的每个字符进行编码。这种编码的特点是出现频率越高的字符，其编码长度越短。有了这样的字符、编码对照表，就可以发“密文”啦！举个栗子：早上看到一篇新闻，blablabla内容不重要。如下： Apple Inc. plans to break with its recent pattern of overha
【赫夫曼编码】实现文件中数据的加解密与压缩
weixin_43232564的博客
05-14 3966
背景知识：二叉树的应用、赫夫曼树。 目的要求：掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 实验内容：实现文件中数据的加解密与压缩：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别；对加密文件进行解密，比较原始文件和解码文件的内容是否一致。
数据结构之哈弗曼编码的（Huffman Coding）加密解密压缩
King来写代码的专栏
07-03 5161
Huffman树又叫最优二叉树，它的特点是带权路径最短。 　　Huffman树的一个重要应用是Huffman编码，Huffman编码是长度最短的前缀编码。即给定要传送的字符的权值，根据权值求出Huffman编码，它一定是前缀编码（指任意字符的编码都不是另一个字符编码的前缀），并且在传送过程由字符组成的文字时，编码长度最小。 　　因此Huffman编码可以对文字进行加密解密还有压缩。加密的工作就是

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值