精华内容
下载资源
问答
  • 哈夫曼编码C++

    2018-12-20 17:37:44
    哈夫曼编码与解码,从控制台读入文本输出编码或读入电文输出明码
  • 哈夫曼编码 C++

    2018-02-27 22:40:49
    哈夫曼编码DEMO 输入一段字符串以EOF(Ctrl + Z)结束 输出每个字符的频率 输出每个哈夫曼编码对应的字符 输出编码结果 输出解码结果 运行命令 huffman < in.txt > out.txt
  • 哈夫曼编码c++

    2020-08-30 21:47:05
    哈夫曼编码 #include<iostream> #include<string> #include<algorithm> using namespace std; ​ struct Node { int lchild, rchild, parent; int weight;//权值 string ch;//存储结点表示...

    洛谷 T133213 哈夫曼编码

    题目背景
    (限制:)这道题不能用map等STL类,允许使用string类

    题目描述
    给定一个字符串,其中只包含10个阿拉伯数字和52个英文字母。要求将其进行哈夫曼编码,并输出编码及编码之后的密文,且将该密文用编码进行译码并输出。

    输入格式
    一个字符串,只包含10个阿拉伯数字和52个英文字母。

    输出格式
    前面若干行输出编码,格式如

    A:001
    B:100
    

    接下来输出原串的哈夫曼编码后的密文,次行输出用哈夫曼编码的译码结果。

    需要注意的是:
    1、对于编码的输出,要求按照原字符ASCII码升序输出;2、对于编码和编码出来的密文,答案可能不唯一,你只需输出正确的一个即可,但必须是哈夫曼编码;
    3、译码出来的原串一定是唯一的

    输入输出样例
    输入 #1

    ABCACCDAEAE
    

    输出 #1

    A:11
    B:010
    C:10
    D:011
    E:00
    110101011101001111001100
    ABCACCDAEAE
    

    说明/提示

    1≤字符串长度≤3,000

    在这里插入图片描述

    参考解答:

    #include<iostream>  
    #include<string>  
    #include<algorithm>
    using namespace std;
    
    struct Node {
        int lchild, rchild, parent;
        int weight;//权值
        string ch;//存储结点表示的字符(对于叶子结点)
        string code;//存储结点的编码(对于叶子结点)
    };
    
    class HuffmanTree {
    public:
        void Select(Node huffTree[], int& min1, int& min2, int k);//找权值最小的两个字符合成“子树”
        void Huff_Tree(Node huffTree[], string str2, int n);//建树
        void Huff_Code(Node huffTree[], int n);//编码
        string Huff_Decode(Node huffTree[], int n, string s);//对字符串s解码
        string unique(string str);//对输入的str去重
    };
    
    void HuffmanTree::Select(Node huffTree[], int& min1, int& min2, int k) {//找权值最小的两个字符,min1和min2 
        int weight = 0; 
        for (int i = 0; i < k; i++) {//找最小的数min1
            if (huffTree[i].parent != -1)//判断节点是否已经选过
                continue;
            else {
                if (weight == 0) {
                    weight = huffTree[i].weight;//先让weight有一个初始值
                    min1 = i;
                }
                else {
                    if (huffTree[i].weight < weight) {
                        weight = huffTree[i].weight;//比较求较小
                        min1 = i;
                    }
                }
            }
        }
        weight = 0;
        for (int i = 0; i < k; i++) { //找“第二小”的数min2
            if (huffTree[i].parent != -1 || (i == min1))//排除已选过的数
                continue;
            else {
                if (weight == 0) {
                    weight = huffTree[i].weight;
                    min2 = i;
                }
                else {
                    if (huffTree[i].weight < weight) {
                        weight = huffTree[i].weight;
                        min2 = i;
                    }
                }
            }
        }
    }
    
    void HuffmanTree::Huff_Tree(Node huffTree[], string str2, int n) {//建树
        for (int i = 0; i < 2 * n - 1; i++) { //初始化(对于二叉哈夫曼树,若有n个叶子结点,则总共有2n-1个结点)
            huffTree[i].parent = -1;
            huffTree[i].lchild = -1;
            huffTree[i].rchild = -1;
            huffTree[i].code = "";
        }
        for (int i = 0; i < n; i++) {
            huffTree[i].ch = str2[i];
        }
        for (int k = n; k < 2 * n - 1; k++) {
            int i1 = 0, i2 = 0;
            Select(huffTree, i1, i2, k); //将i1,i2节点合成节点k
            huffTree[i1].parent = k;
            huffTree[i2].parent = k;
            huffTree[k].weight = huffTree[i1].weight + huffTree[i2].weight;
            huffTree[k].lchild = i1;
            huffTree[k].rchild = i2;
        }
    }
    
    void HuffmanTree::Huff_Code(Node huffTree[], int n) {//编码
        int i, j, k;
        string s = "";//初始化
        for (i = 0; i < n; i++) {
            s = "";
            j = i;
            while (huffTree[j].parent != -1) {//从叶子往上找到根节点  
                k = huffTree[j].parent;
                if (j == huffTree[k].lchild) {
                    s = s + "0";//如果是根的左孩子,则记为0
                }
                else {
                    s = s + "1";//如果是根的右孩子,则记为1
                }
                j = huffTree[j].parent;
            }
            cout << huffTree[i].ch << ":";
            for (int len = s.size() - 1; len >= 0; len--) { //s“从后往前”(反序)输出,即为编码
                cout << s[len];
                huffTree[i].code += s[len]; //保存编码
            }
            cout << endl;
        }
    }
    
    string HuffmanTree::Huff_Decode(Node huffTree[], int n, string s) {
        string temp = "", str = "";//str用来保存解码后的字符串
        for (int i = 0; i < s.size(); i++) {
            temp = temp + s[i];
            for (int j = 0; j < n; j++) {
                if (temp == huffTree[j].code) {
                    str = str + huffTree[j].ch;
                    temp = "";//赋为“空”
                    break;
                }
            }
        }
        return str;
    }
    
    string HuffmanTree::unique(string str) {//去重
        string temp;
        temp.append(str, 0, 1);//初始
        for (int i = 1, j = 0; i < str.length(); i++) {
            for (j = 0; j < temp.length(); j++) {
                if (temp[j] == str[i])//判断在temp中是否已有元素与str[i]相同
                    break;
            }
            if (j == temp.length())//若无重复,在temp尾处添加str[i]
                temp.append(str, i, 1);
        }
        return temp;
    }
    
    int main() {
        ios::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        string str, str2;
        cin >> str;
        HuffmanTree T;
        str2 = T.unique(str);
        sort(str2.begin(), str2.end());//对str2中的字符排序
        if (str2.size() == 1) { //如果str2只有一个元素(即str中所有元素都相同),则无法通过Select函数建树,单独考虑
            cout << str2 << ":" << 0 << endl;//编码为 0 ( 或 1)
            for (int i = 0; i < str.size(); ++i)  cout << 0;
            cout << endl;
            cout << str;//默认此时解码一定为本身,这里不经过 Huff_Decode解码函数,直接输出
        }
        else {
            int n = str2.size();
            Node* huffTree = new Node[2 * n - 1];
            for (int i = 0; i < str2.size(); ++i) {//计算权值(字符出现的频次)
                huffTree[i].weight = count(str.begin(), str.end(), str2[i]);
            }
            T.Huff_Tree(huffTree, str2, n);
            T.Huff_Code(huffTree, n);
            string s;
            for (int i = 0; i < str.size(); ++i) {
                for (int j = 0; j < str2.size(); ++j) {
                    if (str2[j] == str[i]) {
                        cout << huffTree[j].code;//输出编码出来的密文
                        s += huffTree[j].code;//s用来储存密文
                    }
                }
            }
            cout << endl;
            cout << T.Huff_Decode(huffTree, n, s);
        }
        return 0;
    }
    

    注:题目来源于洛谷平台,转载请注明文章出处https://blog.csdn.net/weixin_45912291/article/details/108311602


    欢迎关注微信公众号:自学编程ing
    在这里插入图片描述

    展开全文
  • 哈夫曼编码 c++源码

    2008-12-29 16:30:33
    哈夫曼编码 c++源码 哈夫曼编码 c++源码 哈夫曼编码 c++源码
  • cpp代码-哈夫曼编码C++实现
  • 数据结构哈夫曼编码C++1.将权值数据存放在数据文件(文件名为data.txt,位于执行程序的当前目录中) 分别采用动态和静态存储结构 2.初始化:键盘输入字符集大小n、n个字符和n个权值,建立哈夫曼树; 3. 编码:利用建好...
  • 自适应哈夫曼编码C++

    2018-12-20 17:34:42
    C++实现自适应(动态)哈夫曼编码,读入txt文本编码并将结果输出到指定txt文本中
  • 哈夫曼编码C++实现

    2018-03-25 21:23:39
    哈夫曼编码是广泛用于数据文件压缩的十分有效的编码方式,其压缩率通常在20%—90%之间。哈夫曼编码算法是通过使用字符在文件中出现的频率表来构造最优前缀码的贪心算法。所谓前缀码,即是任一字符的编码都不是其他...
  • /********************************* **中序遍历输出各节点及其哈夫曼编码 *********************************/ void inorder(tree *t,string s){ if(t != 0){ inorder(t->left,s+'0'); if(t->s != '!') cout in...

    #include

    #include

    #include

    #include

    using namespace std;

    int Max = 300;

    class tree{

    public:

    char s;

    int num;

    tree *left;

    tree *right;

    tree(){

    s= '!';

    num = 0;

    left = 0;

    right = 0;

    }

    tree(char a,int n,tree* p1,tree* p2){

    s = a;

    num = n;

    left = p1;

    right = p2;

    }

    };

    vector open;

    /*********************************

    **中序遍历输出各节点及其哈夫曼编码

    *********************************/

    void inorder(tree *t,string s){

    if(t != 0){

    inorder(t->left,s+'0');

    if(t->s != '!')

    cout<s<

    inorder(t->right,s+'1');

    }

    }

    int main(){

    int a[Max];

    for(int i = 0;i < Max;i++)

    a[i] = 0; //初始化数组

    string s;

    cout<

    cin>>s;

    vector v;

    vector::iterator vit;

    for(int i = 0;i < s.length();i ++){

    a[s[i]]++; //确定每个字符出现的次数(频率)

    vit = find(v.begin(),v.end(),s[i]);

    if(vit == v.end()) //相同的字符只保留一个

    v.push_back(s[i]);

    }

    for(int i = 0;i < v.size();i ++){

    tree *n = new tree();

    n->s = v[i];

    n->num = a[v[i]];

    open.push_back(n); //存入open表中

    }

    /************************

    **

    **构造哈夫曼树

    **

    *************************/

    tree *root;

    while(open.size() != 1){

    tree *min1,*min2; //min1,min2是当前open表中num值最小的节点

    int sit1,sit2;

    min1 = open.front();

    sit1 = 0;

    for(int i = 0;i < open.size();i++){

    if(open[i]->num < min1->num){

    min1 = open[i];

    sit1 = i;

    }

    }

    open.erase(open.begin()+sit1);

    min2 = open.front();

    sit2 = 0;

    for(int i = 0;i < open.size();i++){

    if(open[i]->num < min2->num){

    min2 = open[i];

    sit2 = i;

    }

    }

    open.erase(open.begin()+sit2);

    tree *t = new tree('!',min1->num + min2->num,min1,min2); //构造新节点,左右指针指min1和min2

    open.push_back(t); //存入open表中

    root = t;

    }

    cout<

    string s1 = "";

    inorder(root,s1);

    return 0;

    }```

    展开全文
  • 哈夫曼编码c++ 代码

    2018-10-04 21:17:26
    哈夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式,哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法,该方法完全依据字符出现概率来构造异字头的平均长度最短的码字,有时称之为...
  • 哈夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式,哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法,该方法完全依据字符出现概率来构造异字头的平均长度最短的码字,有时称之为...
  • 哈夫曼编码C++编码

    2013-05-17 22:40:14
    哈夫曼编码、译码。用C++编程 #include #include #include #include using namespace std; struct HuffmanNode { int parent; int weight; int lchild,rchild; }; class HuffmanTree { public: void ...
  • 本人写的哈夫曼编码c++程序实现算法。首先把英文句子转换为01编码,再把01编码转换为原来的英文句子
  • 哈夫曼编码 C++实现 这是以前写的一道题,题目记不清了,是PTA上的,所以题干应该都差不多,思路都在注释里了 #include <string> #include <iostream> using namespace std; typedef struct { int ...

    哈夫曼编码 C++实现

    这是以前写的一道题,题目记不清了,是PTA上的,所以题干应该都差不多,思路都在注释里了

    #include <string>
    #include <iostream>
    using namespace std;
    typedef struct {
    	int weight;
    	int parent, lchild, rchild;
    }HTNode, *HuffmanTree;  //赫夫曼树的节点结构
    typedef char * * HuffmanCode;
    void Select(HuffmanTree HT, int n, int &s1, int &s2)//在HT[1..n]选择parent为0且weight最小的两个结点,其序号分别为s1和s2
    {
    	HuffmanTree p;
    	int i, j, min;
    	for (i = 1;; i++)//先找一个没有双亲节点的结点,这个结点的位置给s1和p
    	{
    		if (HT[i].parent == 0)
    		{
    			s1 = i;
    			p = HT + i;
    			break;
    		}
    	}
    	min = p->weight;//先将这个结点的权值记为最小值
    	p++;
    	for (i = s1 + 1; i <= n; i++, p++)//从以找到的这个结点的下一个结点开始寻找双亲节点也为零且权值小于它的结点,从而找到目前序列中权值最小的结点
    	{
    		if (p->weight < min&&p->parent == 0)
    		{
    			s1 = i;
    			min = p->weight;
    		}
    	}
    	//寻找s2位置的操作同上
    	for (j = 1;; j++)
    	{
    		if (HT[j].parent == 0 && j != s1)
    		{
    			s2 = j;
    			p = HT + j;
    			break;
    		}
    	}
    	min = p->weight;
    	p++;
    	for (j = s2 + 1; j <= n; j++, p++)
    	{
    		if (p->weight < min&&p->parent == 0 && j != s1)
    		{
    			s2 = j;
    			min = p->weight;
    		}
    	}
    }
    void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n)
    //w存放n个字符的权值(均>0),构造哈夫曼树HT,并求出n个字符的哈夫曼编码HC
    {
    	HuffmanTree p;
    	int m, i, s1, s2;
    	char * cd;
    	if (n <= 1) return;
    	m = 2 * n - 1;
    	HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));//创建静态链表,0号单元未用
    	for (p = HT + 1, i = 1; i <= n; i++, p++, w++) *p = { *w,0,0,0 };//给每个结点的权值赋值,同时令双亲、左孩子、右孩子为空
    	for (; i <= m; i++, p++) *p = { 0,0,0,0 };//前n个结点肯定为叶节点,从第n+1个结点开始,每个结点都是一个中间结点,权值都不确定,所以先赋为0
    	for (i = n + 1; i <= m; i++)//建哈夫曼树。在哈夫曼树中,每个结点的都是以在数组HT中的位置来表示的,权值记录在weight中。比如一串字符为5,11,7。1代表权值为5的结点,2代表权值为11的结点,3代表权值为7的结点
    	{
    		Select(HT, i - 1, s1, s2);//s1,s2应为地址传递,因为下边的代码需要用到s1,s2的值
    		HT[s1].parent = i; HT[s2].parent = i;//表示HT中第i个数所在的结点是HT中第s1个数所在节点的双亲结点
    		HT[i].lchild = s1; HT[i].rchild = s2;//表示HT中第i个数所在的结点的左孩子是第s1个数所在的结点
    		HT[i].weight = HT[s1].weight + HT[s2].weight; //表示HT中第i个数所在节点的权值是HT中第s1个数所在节点的权值加HT中第s2个数所在节点的权值
    	}
    	//---从叶子到根逆向求每个字符的哈夫曼编码---
    	HC = (HuffmanCode)malloc((n + 1) * sizeof(char *));//分配n个字符编码的头指针向量
    	cd = (char *)malloc(n * sizeof(char));//分配求编码的工作空间
    	cd[n - 1] = '\0';//编码结束符
    	for (i = 1; i <= n; i++)//逐个字符求哈夫曼编码
    	{
    		int start, c, f;
    		start = n - 1;//编码结束符位置
    		for (c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent)//从叶子到根逆向求编码,HT[1..n]就是叶子
    		{
    			if (HT[f].lchild == c) cd[--start] = '0';
    			else cd[--start] = '1';
    		}
    		HC[i] = (char *)malloc((n - start) * sizeof(char));//为第i个字符编码分配空间
    		strcpy(HC[i], &cd[start]);//从cd复制编码到HC
    	}
    	free(cd);//释放工作空间
    }
    int main()
    {
    	int N;
    	int sum = 0;
    	char ch[10001];//字符
    	int w[10001];//权值
    	cin >> N;
    	for (int i = 0; i < N; i++)
    		cin >> ch[i] >> w[i];
    	HuffmanTree HT;
    	HuffmanCode HC;
    	HuffmanCoding(HT, HC, w, N);
    	for (int i = 1; i <= N; i++)
    		sum += w[i - 1] * strlen(HC[i]);   //统计最优长度
    	int M, flag[10001];
    	cin >> M;
    	string str[10001];
    	char c;
    	for (int i = 0; i < M; i++)
    	{
    		int n = 0;
    		for (int j = 0; j < N; j++)
    		{
    			cin >> c >> str[j];           //输入任意N个编码
    			n += str[j].length() * w[j];    //统计在该种编码的情况下所用的字节总数
    		}
    		if (n != sum)               //如果不等于最优长度
    			flag[i] = 0;
    		else
    		{
    			int flag2 = 1;
    			for (int k = 0; k < N - 1; k++) //从第一行编码开始判断其下面的每一行编码是否为该行编码的前缀
    			{
    				for (int l = k + 1; l < N; l++)
    				{
    					flag2 = str[k].find(str[l]);//find函数,若str[l]是str[k]的子串,则返回str[l]在str[k]中的下标位置,若位置是0,则说明该编码不是前缀编码
    					if (flag2 == 0)  //flag2=0说明str[l]是str[k]的子串,且str[l]在str[k]中的下标位置是0,则该编码不是前缀码
    					{
    						flag[i] = 0;
    						break;
    					}
    				}
    				if (flag2 == 0)
    					break;
    			}
    			if (flag2 != 0)
    				flag[i] = 1;
    		}
    	}
    	for (int i = 0; i < M - 1; i++)
    	{
    		if (flag[i] == 1)
    			cout << "Yes" << endl;
    		else
    			cout << "No" << endl;
    	}
    	if (flag[M - 1] == 1)//控制输出格式,最后一次输出不需要换行
    		cout << "Yes";
    	else
    		cout << "No";
    	getchar();
    	getchar();
    	return 0;
    }
    
    展开全文
  • 算法练习七--哈夫曼编码C++实现

    万次阅读 多人点赞 2016-03-18 20:11:07
    算法练习七–哈夫曼编码C++实现 好就没写博客了,今天在九度上遇到了个哈夫曼编码的oj题目,实现了下,发现自己大一时视之如恶魔的哈夫曼树的构造如今也能轻易实现了,哇哈哈,特此记一笔 一、哈夫曼树介绍在...

    算法练习七–哈夫曼编码C++实现

    • 好久没写博客了,今天在九度上遇到了个哈夫曼编码的oj题目,实现了下,发现自己大一时视之如恶魔的哈夫曼树的构造如今也能轻易实现了,哇哈哈,特此记一笔

    一、哈夫曼树介绍

    在一般的数据结构的书中,树的那章后面,著者一般都会介绍一下哈夫曼(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是最小的。

    二、算法步骤

    一、对给定的n个权值{W1,W2,W3,…,Wi,…,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,…,Ti,…,Tn},其中每棵二叉树Ti中只有一个权值为Wi的根结点,它的左右子树均为空。
    二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树,新二叉树的根结点的权值为其左右子树的根结点的权值之和。
    三、从F中删除这两棵树,并把这棵新的二叉树同样以降序排列(因为在末尾进行删除和增加更加方便)加入到集合F中。
    四、重复二和三两步,直到集合F中只有一棵二叉树为止。

    PS:网上有很多对哈夫曼树手动构造生动形象的图文描述,这里不再赘述,重点说明算法的实现

    三、talk is cheap show the code

    #include<iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    /**********************************************************
    // Method: 
    // Description: http://ac.jobdu.com/problem.php?pid=1172
    // Author:  
    // Date: 2016/03/18 19:47
    // Returns: 
    // Parameter: 
    // History:
    // G:\VisualStudio2013Projects\algorithmNew\algorithmNew\哈夫曼编码.h
    **********************************************************/
    
    class huffumanNode
    {
    public:
        int weight;
        huffumanNode *left;
        huffumanNode *right;
        //用来构造叶子节点
        huffumanNode(int setWeight)
        {
    
            this->weight = setWeight;
            this->left = NULL;
            this->right = NULL;
        }
        //用来构造中间的节点
        huffumanNode(int setWeight, huffumanNode *setLeft, huffumanNode *setRight)
        {
            this->weight = setWeight;
            this->left = setLeft;
            this->right = setRight;
        }
        //判断是否是叶子节点
        bool isLeaf()
        {
            return this->left == NULL && this->right == NULL;
        }
    
    };
    
    //降序排序比较函数,以wieght的大小降序排列
    bool myHuffumanComepare(huffumanNode *node1, huffumanNode *node2)
    {
        return node1->weight > node2->weight;
    }
    
    /*得到带权路径长度。所谓树的带权路径长度,就是树中所有的叶结点
    
    的权值乘上其到根结点的 路径长度(若根结点为0层,叶结点到根结点的路径长度
    
    为叶结点的层数)*/
    void getHuffmanSum(huffumanNode *root,int length,int &sum)
    {
        if (!root)
        {
            return;
        }
        if (root->isLeaf())
        {
            sum += root->weight*length;
        }
        length++;
        getHuffmanSum(root->left, length, sum);
        getHuffmanSum(root->right, length, sum);
    }
    //前序遍历打印,提交时不要调用这个哈,仅为调试
    void prePrint(huffumanNode *root)
    {
        if (!root)
        {
            return;
        }
        cout << root->weight << " ";
        prePrint(root->left);
        prePrint(root->right);
    }
    
    int buildHuffuman()
    {
        int n;
        while (cin >> n)
        {
            vector<huffumanNode*> weightArray;
            while (n--)
            {
                int tempWeight;
                cin >> tempWeight;
                huffumanNode *newNode = new huffumanNode(tempWeight);
                weightArray.push_back(newNode);
            }
            sort(weightArray.begin(), weightArray.end(), myHuffumanComepare);
            while ((int)weightArray.size() > 1)
            {
                huffumanNode *minNode1 = weightArray[weightArray.size() - 1];
                huffumanNode *minNode2 = weightArray[weightArray.size() - 2];
                int fatherWeight = minNode1->weight + minNode2->weight;
                /*根据最小的两个权重节点,构造新节点*/
                huffumanNode *fatherNode = new huffumanNode(fatherWeight, minNode1, minNode2);
    
                weightArray.pop_back();
                weightArray.pop_back();
                weightArray.push_back(fatherNode);
    
                sort(weightArray.begin(), weightArray.end(), myHuffumanComepare);
            }
            prePrint(weightArray[0]);
            cout << endl;
            int length = 0;
            int sum = 0;
            getHuffmanSum(weightArray[0], length, sum);
            cout << "weightSum: " << sum << endl;
        }
        return 0;
    }

    运行:
    这里写图片描述

    展开全文
  • 哈夫曼编码C++源代码

    2014-07-01 15:14:50
    哈夫曼编码的参考实现 代码只有不到200行
  • 哈夫曼编码 c++实现

    2011-06-16 10:08:28
    哈夫曼编码实现(c++)………………………………………………………………
  • 哈夫曼树及哈夫曼编码 C++

    万次阅读 2016-01-02 20:44:42
    C++实现哈夫曼树以及哈夫曼编码。 代码说明: 1.读取文件中需进行哈夫曼编码的数据信息 2.构造生成单节点二叉树组 -> 森林 3.构造哈夫曼树 4.进行哈夫曼编码 5.输出对应数据及其编码
  • 哈夫曼编码 要求: 给定报文中26个字母a-z及空格的出现频率{64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1, 168},构建哈夫曼树并为这27个字符编制哈夫曼...
  • 哈夫曼编码 C++实现

    千次阅读 2016-05-19 21:56:09
    首先,根据输入的字符串确定每个字母的频率,也就是权值,然后构造哈夫曼树,进行编码。解码就是从根节点不断往下查找,直到叶节点的过程。看哪个字符与从某序列匹配。 #include #include #include using ...
  • 哈夫曼编码C++实现(优先队列)(map映射) 哈夫曼树 哈夫曼树是带权路径最短的最优二叉树,即权值越小的结点里根节点越远反之则越近。 借助优先队列,初始时,将所有的结点压入优先队列,权值越小优先级越高,每次...
  • 哈夫曼树及哈夫曼编码 C++代码实现

    万次阅读 多人点赞 2010-11-15 21:36:00
    /*哈夫曼编码*/ #include <iostream> using namespace std; //******************************** //构造哈夫曼树 //******************************** /*哈夫曼树顺序表的定义*/ typedef struct { int...
  • 哈夫曼编码c++/qt实现

    千次阅读 2018-02-08 11:26:30
    接续上一篇文章《哈夫曼树与哈夫曼编码》:http://blog.csdn.net/superyang_/article/details/79276502--------main.cpp--------#include &lt;QCoreApplication&gt;#include "Huffman.h"#include &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,946
精华内容 1,578
关键字:

哈夫曼编码c++

c++ 订阅