精华内容
下载资源
问答
  • 主要为大家详细介绍了C++实现哈夫曼树编码解码,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 哈夫曼树解码编码.zip

    2021-07-12 20:14:28
    哈夫曼树解码编码基于数据结构(清华大学出版社)一书,读取要编码的文件data,然后再编码到code文件,最后再用code文件来解码,解码到result文件。(注意要把cpp文件和data放到同一个文件夹下运行,每运行完一次...
  • 哈夫曼树的编码和解码 可直接运行 哈夫曼树的编码和解码 +英语文章 全代码
  • 哈夫曼树解码

    2020-12-23 18:28:35
    #include <stdio.h> #include <stdlib.h> #define leaf 1 struct Node; typedef struct Node *ptrtoNode; typedef ptrtoNode position; typedef ptrtoNode tree; struct Node ... tree .

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define leaf 1
    struct Node;
    typedef struct Node *ptrtoNode;
    typedef ptrtoNode position;
    typedef ptrtoNode tree;
    struct Node
    {
        char x;
        position left, right;
        int kind;
    };
    
    int main()
    {
        tree T = malloc(sizeof(struct Node));
        position p2 = malloc(sizeof(struct Node));
        position p3 = malloc(sizeof(struct Node));
        position p4 = malloc(sizeof(struct Node));
        position p5 = malloc(sizeof(struct Node));
        position p6 = malloc(sizeof(struct Node));
        position p7 = malloc(sizeof(struct Node));
        position p8 = malloc(sizeof(struct Node));
        position p9 = malloc(sizeof(struct Node));
        position p10 = malloc(sizeof(struct Node));
        position p11 = malloc(sizeof(struct Node));
        position p12 = malloc(sizeof(struct Node));
        position p13 = malloc(sizeof(struct Node));
        position p14 = malloc(sizeof(struct Node));
        position p15 = malloc(sizeof(struct Node));
    
        p4->kind = leaf;
        p4->x = 'b';
    
        p5->kind = leaf;
        p5->x = 'g';
    
        p7->kind = leaf;
        p7->x = 'e';
    
        p11->kind = leaf;
        p11->x = 'd';
    
        p12->kind = leaf;
        p12->x = 'a';
    
        p13->kind = leaf;
        p13->x = 'h';
    
        p14->kind = leaf;
        p14->x = 'c';
    
        p15->kind = leaf;
        p15->x = 'f';
    
        T->left = p2;
        T->right = p3;
    
        p2->left = p4;
        p2->right = p5;
    
        p3->left = p6;
        p3->right = p7;
    
        p6->left = p8;
        p6->right = p9;
    
        p8->left = p10;
        p8->right = p11;
    
        p9->left = p12;
        p9->right = p13;
    
        p10->left = p14;
        p10->right = p15;
    
        char a;
        position p = T;
        while ((a = getchar()) != '\n' && a != EOF)
        {
            if (a == '0')
            {
                p = p->left;
            }
            else if (a == '1')
            {
                p = p->right;
            }
            if (p->kind == leaf)
            {
                printf("%c", p->x);
                p = T;
            }
        }
    
        return 0;
    }
    
    
    展开全文
  • 数据结构课程 实验报告 实验名称 哈弗曼编码和译码 专业班级 电子信息科学与技术0904 姓 名 秦杰 学 号 1404090506 指导教师 胡志坤 2011年 11月 实验四哈夫曼编码和译码 实验目的和要求 掌握哈夫曼树的基本概念及其...
  • OJ2-3 C. 哈夫曼树解码

    2020-10-23 21:35:44
    #include <stdio.h> #include <stdlib.h> #define leaf 1 struct Node; typedef struct Node *ptrtoNode; typedef ptrtoNode position; typedef ptrtoNode tree; struct Node ... tree .

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define leaf 1
    struct Node;
    typedef struct Node *ptrtoNode;
    typedef ptrtoNode position;
    typedef ptrtoNode tree;
    struct Node
    {
        char x;
        position left, right;
        int kind;
    };
    
    int main()
    {
        tree T = malloc(sizeof(struct Node));
        position p2 = malloc(sizeof(struct Node));
        position p3 = malloc(sizeof(struct Node));
        position p4 = malloc(sizeof(struct Node));
        position p5 = malloc(sizeof(struct Node));
        position p6 = malloc(sizeof(struct Node));
        position p7 = malloc(sizeof(struct Node));
        position p8 = malloc(sizeof(struct Node));
        position p9 = malloc(sizeof(struct Node));
        position p10 = malloc(sizeof(struct Node));
        position p11 = malloc(sizeof(struct Node));
        position p12 = malloc(sizeof(struct Node));
        position p13 = malloc(sizeof(struct Node));
        position p14 = malloc(sizeof(struct Node));
        position p15 = malloc(sizeof(struct Node));
    
        p4->kind = leaf;
        p4->x = 'b';
    
        p5->kind = leaf;
        p5->x = 'g';
    
        p7->kind = leaf;
        p7->x = 'e';
    
        p11->kind = leaf;
        p11->x = 'd';
    
        p12->kind = leaf;
        p12->x = 'a';
    
        p13->kind = leaf;
        p13->x = 'h';
    
        p14->kind = leaf;
        p14->x = 'c';
    
        p15->kind = leaf;
        p15->x = 'f';
    
        T->left = p2;
        T->right = p3;
    
        p2->left = p4;
        p2->right = p5;
    
        p3->left = p6;
        p3->right = p7;
    
        p6->left = p8;
        p6->right = p9;
    
        p8->left = p10;
        p8->right = p11;
    
        p9->left = p12;
        p9->right = p13;
    
        p10->left = p14;
        p10->right = p15;
    
        char a;
        position p = T;
        while ((a = getchar()) != '\n' && a != EOF)
        {
            if (a == '0')
            {
                p = p->left;
            }
            else if (a == '1')
            {
                p = p->right;
            }
            if (p->kind == leaf)
            {
                printf("%c", p->x);
                p = T;
            }
        }
    
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 哈夫曼树解码

    千次阅读 2019-05-09 22:39:05
    哈夫曼树解码 题目: 思路: 代码: #include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> using namespace std; typedef struct Node{ ...

    哈夫曼树编解码

    题目:

    思路:

    代码:

    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    using namespace std;
    
    typedef struct Node{
        char data = '\0';
        int parent = 0;
        int leftChild = 0;
        int rightChild = 0;
        int weight = 0;
    }Node;
    
    typedef struct HaffmanTree{
        Node node[1000];
        int num;
    }Tree;
    
    void createTree(Tree *tree);
    int findTwoMin(Tree *tree, int *min1, int *min2, int *weight);
    int encode(Tree *tree, int *code, char *str, int length);
    void decode(Tree *tree, int *code, char *deStr, int length);
    
    int main()
    {
        Tree tree;
        createTree(&tree);
    
        char c;
        char str[1000];
        c = getchar();
        c = getchar();
        int index = 0;
    
        while(c != '\n'){
            str[index++] = c;
            c = getchar();
        }
    
        int code[1000];
        index = encode(&tree, code,  str, index);
        char deStr[100];
        decode(&tree, code, deStr, index);
    
    
    //    for(int i=0; i<index; i++){
    //        printf("%c ", str[i]);
    //    }
        return 0;
    }
    
    void createTree(Tree *tree){
        char c;
        scanf("%d", &(tree->num));
        scanf("%c", &c);
    //    printf("end num: %d\n", tree->num);
    
        for(int i=1; i<=tree->num; i++){
            scanf("%c",&(tree->node[i].data));
            scanf("%c", &c);
    //        printf("index: %d ", i);
        }
    //    printf("end char\n");
        for(int i=1; i<=tree->num; i++){
            scanf("%d",&(tree->node[i].weight));
        }
    //    printf("end weight\n");
        int min1, min2;
        int weight;
        while(findTwoMin(tree, &min1, &min2, &weight)){
            ++(tree->num);
            tree->node[tree->num].leftChild = min1;
            tree->node[tree->num].rightChild = min2;
            tree->node[tree->num].weight = weight;
            tree->node[min1].parent = tree->num;
            tree->node[min2].parent = tree->num;
        }
        /*
        printf("---------------------------------------------------\n");
        printf("the tree's profile is: \n");
        printf("the node in this tree is: %d\n", tree->num);
        for(int i=1; i<=tree->num; i++){
            printf("%d's parent is: %d\n", i, tree->node[i].parent);
        }
        */
    }
    
    int findTwoMin(Tree *tree, int *min1, int *min2, int *weight){
        int minWeight1 = 99999;
        int minWeight2 = 99999;
        int temp;
        for(int i=1; i<= tree->num; i++){
            if(0 == tree->node[i].parent){
                temp = tree->node[i].weight;
                if(temp < minWeight2){
                    if(temp > minWeight1){
                        minWeight2 = temp;
                        *min2 = i;
                    }else{
                        minWeight2 = minWeight1;
                        minWeight1 = temp;
                        *min2 = *min1;
                        *min1 = i;
                    }
                }
            }
        }
    
        if((minWeight1 != 99999) && (minWeight2 != 99999)){
            *weight = tree->node[*min1].weight + tree->node[*min2].weight;
            return 1;
        }else{
            return 0;
        }
    }
    
    int encode(Tree *tree, int *code, char *str, int length){
        int index = 0;
        int parent;
        for(int i=length-1; i>=0; i--){
            for(int j=1; j<=tree->num; j++){
                if(tree->node[j].data == str[i]){
                    parent = j;
    
                    //printf("the %d char is %c\n", i+1, str[i]);
                    //printf("the parent is: %d\n", parent);
    
                    break;
                }
            }
            while(tree->node[parent].parent){
                if(tree->node[tree->node[parent].parent].leftChild == parent){
                    code[index] = 0;
                }else{
                    code[index] = 1;
                }
                //printf("\tthe parent is: %d\n", parent);
                index++;
                parent = tree->node[parent].parent;
            }
        }
        for(int i=index-1; i>=0; i--){
            printf("%d",code[i]);
        }
        printf("\n");
        return index;
    }
    
    void decode(Tree *tree, int *code, char *deStr, int length){
        int head = tree->num;
        int cur = head;
        int index = 0;
        for(int i=length-1; i>=0; i--){
            if(code[i] == 0){
                cur = tree->node[cur].leftChild;
                if(tree->node[cur].leftChild == 0){
                    deStr[index] = tree->node[cur].data;
                    index++;
                    cur = head;
                    //printf("第%d次存储%c\n", index, deStr[index-1]);
                }
            }else{
                cur = tree->node[cur].rightChild;
                if(tree->node[cur].rightChild == 0){
                    deStr[index] = tree->node[cur].data;
                    index++;
                    cur = head;
                    //printf("第%d次存储%c\n", index, deStr[index-1]);
                }
            }
        }
    
        for(int i=0; i<index; i++){
            printf("%c", deStr[i]);
        }
        printf("\n");
    }
    

    运行结果:


    以上

    编解码就不说了,程序里有

    展开全文
  • /********************************************************************** * Description : create huffmanTree and huffmanCode by input string * and decode a 0、1 sequence by huffmanCode ...
  • Java实现哈夫曼树、哈夫曼编码解码

    千次阅读 2019-03-12 22:32:25
    获取字符串内的每个字符及其出现次数(权值),然后根据权值...解码过程输入哈夫曼树和压缩码,输出为字符。 package Tree; import java.util.ArrayList; import java.util.Collections; import java.util.Comparat...

    获取字符串内的每个字符及其出现次数(权值),然后根据权值大小进行排序,构建哈夫曼树;根据哈夫曼树进行对字符编码(从根节点出发,往左走为0,往右走为1进行编码);解码过程输入哈夫曼树和压缩码,输出为字符。

    package Tree;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    public class MyHaFuMann {
    	 static class Node
    		{
    			Character data;//数据域
    			int weight;//权值
    			Node left;//左节点
    			Node right;//右节点
    			public Node(Character data)
    			{
    				this.data=data;
    			}
    			public Node(Character data,int weight)
    			{
    				this.data=data;
    				this.weight=weight;
    			}
    			public Node()
    			{
    			}
    		}
    	 public Node CreateMyHaFuMannTree(String inputString)
    	 {
    		 //获取字符并排序
    		HashMap<Character, Integer>map=new HashMap<Character, Integer>();
    		for(int i=0;i<inputString.length();i++)
    		{
    			if(map.containsKey(inputString.charAt(i)))
    			{
    				map.put(inputString.charAt(i),map.get(inputString.charAt(i))+1);
    			}
    			else {
    				map.put(inputString.charAt(i), 1);
    			}
    		}
    		 List<Map.Entry<Character, Integer>>list=new ArrayList<Map.Entry<Character,Integer>>(map.entrySet());
    		 Collections.sort(list,new Comparator<Map.Entry<Character, Integer>>() {
    			 //升序排序
    			 public int  compare(Entry<Character, Integer>o1,Entry<Character, Integer>o2) {
    				 return o1.getValue().compareTo(o2.getValue());
    			}
    		});
    		 //已对字符排好序,下面将创建赫夫曼树
    		List<Node> nodelistList=new ArrayList<MyHaFuMann.Node>();
    	    for(int i=0;i<list.size();i++)
    	    {
    	    	Node nodetempNode=new Node(list.get(i).getKey(),list.get(i).getValue());
    	    	nodelistList.add(nodetempNode);
    	    }
    		while (nodelistList.size()>1) {
    			//排序
    			ListSort(nodelistList);
    			Node lefNode=nodelistList.get(0);
    			Node rightNode =nodelistList.get(1);
    			Node parentNode=new Node(null,lefNode.weight+rightNode.weight);
    			parentNode.left=lefNode;
    			parentNode.right=rightNode;
    			//移除前两个节点
    			nodelistList.remove(0);
    			nodelistList.remove(0);
    			//将parentnode加进去
    			nodelistList.add(parentNode);
    		}
    		//while循环结束后第一个元素就是根结点
    		return nodelistList.get(0);
    		
    	 }
    	 //对list<node>中的数据根据权重进行排序,从小到大
    	 public void ListSort(List<Node>nodes) {
    		//冒泡法
    		for(int i=0;i<nodes.size()-1;i++)
    		{
    			for(int j=nodes.size()-1;j>i;j--)
    			{
    				if(nodes.get(j-1).weight>nodes.get(j).weight)
    				{
    					Node tempNode=nodes.get(j);
    					nodes.set(j,nodes.get(j-1));
    					nodes.set(j-1,tempNode );
    					
    				}
    			}
    		}
    	}
    	//哈夫曼树编码,输出为hashmap,key为字符,value为压缩码,此处用到了递归
         public  HashMap<Character, String> MyHaFuMannEncode(Node nodeTree,String codeString, HashMap<Character, String>hfmmap) {
        	if(nodeTree!=null)
        	{
        		if(nodeTree.left==null&& nodeTree.right==null)
        		{
        			hfmmap.put(nodeTree.data, codeString);
        		}
        		MyHaFuMannEncode(nodeTree.left, codeString+"0",hfmmap);
        		MyHaFuMannEncode(nodeTree.right, codeString+"1",hfmmap);
        		
        	}
        	return hfmmap;
    	}
    	//哈夫曼解码,输入树和压缩码,输出为字符
         public Character MyHaFuMannDecode (Node nodeTree,String coding) {
        	 for(int i=0;i<coding.length();i++)
        	 {
        		 if(coding.charAt(i)=='0')
        		 {
        			 if (nodeTree.left!=null) {
        				 nodeTree=nodeTree.left;
    				}
        			 else {
        				 throw new RuntimeException("编码错误!");
    				}
        		 }
        		 if(coding.charAt(i)=='1')
        		 {
        			 if (nodeTree.right!=null) {
        				 nodeTree=nodeTree.right;
    				}
        			 else {
        				 throw new RuntimeException("编码错误!");
    				}
        		 }
        	 }
        	 return nodeTree.data;
    		
    	}
    }
    
    
    

    主函数测试

    package Tree;
    import java.util.HashMap;
    
    import Tree.ThreadBinaryTree.Node;
    public class program {
    
    	public static void main(String[] args) {
    		MyHaFuMann testFuMann=new MyHaFuMann();
    		Tree.MyHaFuMann.Node treeNode= testFuMann.CreateMyHaFuMannTree("abbbcccccddddddeeeeeeeee");
    		HashMap<Character, String>hfmmap=new HashMap<Character, String>();
    		Map<Character, String>map=testFuMann.MyHaFuMannEncode(treeNode, "", hfmmap) ;
    		//编码结果
    		for (Character keyString : map.keySet()) {
    			System.out.println(keyString+" "+map.get(keyString));
    		}
    		//解码
    		System.out.print(testFuMann.MyHaFuMannDecode(treeNode, "000"));
    		
    	}
    }
    
    

    测试结果
    在这里插入图片描述

    展开全文
  • 哈夫曼树及哈夫曼编码和解码

    千次阅读 2018-11-02 23:07:35
    哈夫曼树,又称最优树,是带权路径最小的树。 基本概念: 节点间的路径长度:两个节点间所包含的边的数目。 树的路径长度:从根到树中任意节点的路径长度之和。 权:将节点赋予一定的量值,该量值成为权。 树的带权...
  • 哈夫曼树的编码与解码

    千次阅读 2019-12-21 22:30:04
    哈夫曼树简介 给定N个权值作为N个叶子结点,构造一棵二叉树,若该树的带权路径长度达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树哈夫曼树是带权路径长度最短的树,权值较大的结点离根较近。 根据...
  • 哈夫曼编码解码

    2017-12-25 16:45:13
    通过二叉树构造哈夫曼树,并用哈夫曼树对读取的txt文件进行哈夫曼编码。编码完成后通过哈夫曼树进行解码
  • 自己花了好多精力写的,包括详细的注释还有代码
  • 首先对于赫夫曼编码有个大概的理解:赫夫曼编码(Huffman Coding),又称霍夫曼编码,是一种编码方式,可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法,该方法完全依据字符出现概率来构造异字头的平均长度...
  • 哈夫曼树与哈夫曼编码以及解码

    千次阅读 多人点赞 2020-07-22 16:23:13
    哈夫曼树即是带权路径最小的二叉树 可以看出,哈夫曼树的特点是 1.权值越大的叶子节点靠根节点越近,越小的越远; 2.只有度为0(叶子节点)和度为2(分支节点)的节点,不存在度为一的节点;(这一特点很重要) ...
  • C语言编码哈夫曼树

    2015-06-24 20:51:44
    void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int num)//w存放n个字符的权值(均>0),构造哈夫曼树HT,并求出n个字符的哈弗曼编码HC { int i,m,c,s1,s2,start,f; HuffmanTree p; char* cd; if...
  • 实例图解哈夫曼树编码-解码及实现(c++)

    千次阅读 多人点赞 2019-01-15 23:20:51
    你们机智大气的阿俊又回来了,最近事比较多,闲话少说,直接切入正题,聊聊如何给一篇全为英文字符的文章利用哈夫曼编码得到每个字符的最优编码,并完成解码功能,注意,这次也是用文件操作哟,今天可被二进制文件...
  • 哈夫曼树如果不清楚是什么概念的话可以看一下百度百科的介绍,这里的哈夫曼树节点存储的是char字符 Node节点数据结构: public class Node implements Comparable<Node>{ //需要改写compareTo方法,实现权重...
  • 哈夫曼树以其编码解码 本人大二学渣,写的不好的地方大神勿喷! 哈夫曼树以其编码解码要求: 1.从终端读入字符集大小为n(即字符的个数),逐一输入n个字符和相应的n个权值(即字符出现的频度),建立哈夫曼树,进行...
  • 哈夫曼编码、解码哈夫曼树

    千次阅读 2019-09-25 10:52:19
    哈夫曼树就是哈夫曼编码(在数据通信中,需要将传送的文字转换成二进制的字符串,用 0,1 码的不同排列来表示字符)的过程(一般都是 哈夫曼静态编码 ):   它对需要编码的数据进行 两遍扫描 : 第一遍统计...
  • void Encode() 哈夫曼树解码 void WPL() 计算带权路径长度 所选实例: 所选实例 创建哈夫曼树 步骤: 假设有n个权值,则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn,则哈夫曼树的...
  • 哈夫曼树编码解码.c

    2019-11-21 19:16:53
    该文件是关于用C语言构建哈夫曼树的代码,其中包括对字符的统计、对文档读取然后包括建树的过程,和对哈夫曼树解码的过程。
  • Java实现哈夫曼树及简易编码解码

    千次阅读 多人点赞 2017-11-17 17:09:56
    一、基本概念  首先了解哈夫曼树之前先要知道的知识点,这些也都是树(不是书)中的概念:1、路径和路径长度  在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为...
  • 要求哈夫曼树中所有左孩子编号小于右孩子编号(以结点的输入顺序做为其编号)。对所建的哈夫曼树,根据左0右1的原则,对各结点进行编码。设计一个算法,对给定的若干码串进行相应的解码,并输出解码结果。 Input: ...
  • 这里我用的实例为: ...哈夫曼树的结构定义 typedef struct { int weight; int parent, left, right; }Htnode, * Huffmantree; typedef char** Huffmancode; 建立哈夫曼树 void select(Huffmantree a
  • 输入一段英文原文,构造哈夫曼树,生成对应的编码表,输出原文对应的编码,或者是根据已经生成的编码表,输入一段二进制数编码,得到对应的字符原文。 #include<stdio.h> #include<iostream> #include...

空空如也

空空如也

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

哈夫曼树解码