精华内容
下载资源
问答
  • 哈夫曼树java代码实现

    2019-10-22 19:06:28
    哈夫曼树哈夫曼树是一种带权路径长度最短的二叉树,也称为最优二叉树。下面用一幅图来说明。 package com.sun.hafumanTree; import java.security.PublicKey; import java.util.ArrayList; import java.util....

    哈夫曼树?
    哈夫曼树是一种带权路径长度最短的二叉树,也称为最优二叉树。下面用一幅图来说明。
    在这里插入图片描述
    在这里插入图片描述

    package com.sun.hafumanTree;
    
    import java.security.PublicKey;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.List;
    
    public class hafumantree {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int arr[]={13,7,8,3,29,6,1};
    		Node root=create(arr);
    		preOrder(root);
    	
    	}
    	public static void preOrder(Node root){
    		if(root !=null){
    			root.preOrder();
    		}
    	}
    	//创建哈夫曼树
    	public static Node create(int[] arr){
    		
    		//1.遍历数组
    		//2.数组元素构成node
    		//3.将node放入ArrayList
    		List<Node> nodes=new ArrayList<Node>();
    		for (int value : arr) {
    			Node node=new Node(value);
    			nodes.add(node);
    		}
    		while(nodes.size()>1){
    		//排序从小到大
    		Collections.sort(nodes);
    		
    		//取出根节点权值最小的二叉树
    		Node leftnode=nodes.get(0);
    		
    		//取出根节点权值第二小的二叉树
    		Node rightnode=nodes.get(1);
    		
    		///构建新的二叉树
    		Node parent=new Node(leftnode.value+rightnode.value);
    		
    		parent.left=leftnode;
    		parent.right=rightnode;
    		
    		//删除掉用过的节点
    		nodes.remove(leftnode);
    		nodes.remove(rightnode);
    		
    		//将新构建的parent加入到nodes
    		nodes.add(parent);
    		}
    		return nodes.get(0);
    		
    	}  
    //创建节点
    //让节点实现Comparable接口
    	static class Node implements Comparable<Node>{
    		int value;//节点权值
    		Node left;//指向左子节点
    		Node right;//指向右子节点
    		public Node(int value) {
    			
    			this.value = value;
    		}
    		@Override
    		public String toString() {
    			return "Node [value=" + value + ", left=" + left + ", right="
    					+ right + "]";
    		}
    		@Override
    		public int compareTo(Node o) {
    		// TODO Auto-generated method stub
    		//表示从小到大排序
    		return this.value - o.value;
    		
    		}
    		//前序遍历
    		public void preOrder(){
    			System.out.println(this);
    			if(this.left != null){
    				this.left.preOrder();
    			}
    			if(this.right != null){
    				this.right.preOrder();
    			}	
    		}
    	}
    }
    
    
    展开全文
  • 本文主要是对哈夫曼树代码进行介绍,感性趣的朋友可以参考下。
  • 哈夫曼树实现

    2013-11-27 20:28:44
    哈夫曼树实现代码,包括建立哈夫曼树,遍历哈夫曼树,搜索哈夫曼树等。
  • 哈夫曼树代码实现

    2014-03-15 15:50:34
    哈夫曼树的c语言实现 实现过程:着先通过 HuffmanTree() 函数构造哈夫曼树,然后在主函数 main()中 * 自底向上开始(也就是从数组序号为零的结点开始)向上层层判断,若在 * 父结点左侧,则置码为 0,若在右侧,则置...
  • 哈夫曼树代码实现 请看代码: 例子用的上一节,请自行对比 #include<iostream> #include<deque> #include<vector> #include<algorithm> using namespace std; typedef struct _...

    哈夫曼树用代码实现

    请看代码:
    例子用的上一节,请自行对比

    #include<iostream>
    #include<deque>
    #include<vector>
    #include<algorithm>
    using namespace std;
    
    typedef struct _HuffumanTree
    {
    	int weight;//权值
    	_HuffumanTree *left;//左儿子节点
    	_HuffumanTree *right;//右儿子节点
    }HuffumanTree;
    
    //构造哈夫曼树
    HuffumanTree * CreateHuffumanTree(vector<int> &m_vc)
    {
    	deque<HuffumanTree *>m_HfVc;
    	//1.根据权值先创建树节点
    	for (auto p :m_vc)
    	{
    		
    		HuffumanTree *m_hf = (HuffumanTree *)malloc(sizeof(HuffumanTree));
    		m_hf->weight = p;
    		m_hf->left = nullptr;
    		m_hf->right = nullptr;
    
    		m_HfVc.push_back(m_hf);
    	}
    
    	//2.将装有树节点的队列按照从小到大的顺序排列,并且取出最小的两个
    	int nsize = m_HfVc.size();
    	int a = 0;
    	int b = 0;
    	HuffumanTree *m_leftChild{ nullptr };//左
    	HuffumanTree *m_rightChild{ nullptr };//右
    	HuffumanTree* newtree{ nullptr };
    	for (int i = 0; i < nsize-1;i++)
    	{
    
    		sort(m_HfVc.begin(), m_HfVc.end(), [](HuffumanTree *t1, HuffumanTree *t2){return t1->weight < t2->weight; });
    		
    		m_leftChild = m_HfVc.front();
    		m_HfVc.pop_front();
    
    		m_rightChild = m_HfVc.front();
    		m_HfVc.pop_front();
    
    		newtree = (HuffumanTree *)malloc(sizeof(HuffumanTree));
    		newtree->weight = m_leftChild->weight + m_rightChild->weight;
    		newtree->left = m_leftChild;
    		newtree->right = m_rightChild;
    		
    		m_HfVc.push_back(newtree);
    	}
    
    	return  m_HfVc.front();
    }
    
    //打印哈夫曼树
    void printHfTree(HuffumanTree *root)
    {
    	if (root)
    	{
    		cout << root->weight << endl;
    		if (root->left)
    		{
    			cout << root->left->weight << "    ";
    		}
    		else{
    			cout << "没有左孩子\n";
    		}
    
    		if (root->right)
    		{
    			cout << root->right->weight << "    ";
    		}
    		else{
    			cout << "没有右孩子\n";
    		}
    		cout << endl;
    		printHfTree(root->left);
    		printHfTree(root->right);
    
    	}
    
    
    }
    void main()
    {
    	vector<int> m_vc{ 19, 21, 2, 3, 6,7,10,32 };
    	
    	HuffumanTree *m_hf = CreateHuffumanTree(m_vc);
    
    	printHfTree(m_hf);
    
    	system("pause");
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • 哈夫曼树及哈夫曼编码 C++代码实现

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

     

    /*哈夫曼编码*/
    
    #include <iostream>
    using namespace std;
     
    //********************************
    //构造哈夫曼树
    //********************************
     
    /*哈夫曼树顺序表的定义*/
    typedef struct
    {
           intweight;
           intparent,lchild,rchild;
    }HTNode;
     
    typedef HTNode * HuffmanTree;
     
     
    /*初始化一个哈夫曼树*/
    void InitHuffmanTree(HuffmanTree&HT,int m)
    {
           inti;
           HT=newHTNode[m];
           for(i=0;i<m;i++)
           {
                  HT[i].weight=0;
                  HT[i].parent=-1;
                  HT[i].lchild=-1;
                  HT[i].rchild=-1;
           }
    }
    //****************************************
    //从n个结点中选取最小的两个结点
    //****************************************
    void SelectMin(HuffmanTree &HT,intn,int &min1,int &min2)
    {
           typedefstruct
           {
                  intNewWeight;//存储权
                  intp;//存储该结点所在的位置
           }TempNode,*TempTree;
     
           TempTreeTT=new TempNode[n];
     
           inti,j;
     
           j=0;
           for(i=0;i<n;i++)
           {
                  if(HT[i].parent==-1&& HT[i].weight!=0)
                  {
                         TT[j].NewWeight=HT[i].weight;
                         TT[j].p=i;
                         j++;
                  }
           }//将HT中没有双亲的结点存储到TT中
     
           intm1,m2;
           m1=m2=0;
           for(i=0;i<j;i++)
           {
                  if(TT[i].NewWeight<TT[m1].NewWeight)//此处不让取到相等,是因为结点中有相同权值的时候,m1取最前的
    那个。
                         m1=i;
           }
           for(i=0;i<j;i++)
           {
                  if(m1==m2)
                         m2++;//当m1在第一个位置的时候,m2向后移一位
                  if(TT[i].NewWeight<=TT[m2].NewWeight&& i!=m1)//此处取到相等,是让在结点中有相同的权值的时候,
                                                                                                            
                                       //m2取最后的那个。
                         m2=i;
           }
     
           min1=TT[m1].p;
           min2=TT[m2].p;
     
    }
     
    /*创建哈夫曼树*/
    void CreateHaffmanTree(HuffmanTree&HT,int n)
    {
           inti;
           intm;
           intmin1,min2;
           if(n<=1)
                  cout<<"ParameterError!";
           m=2*n-1;//哈夫曼树中结点的个数
          
           InitHuffmanTree(HT,m);
     
           for(i=0;i<n;i++)
           {
                  cin>>HT[i].weight;
           }
     
           for(i=n;i<m;i++)
           {
                  SelectMin(HT,i,min1,min2);
                  HT[min1].parent=i;
                  HT[min2].parent=i;
                  HT[i].lchild=min1;
                  HT[i].rchild=min2;
                  HT[i].weight=HT[min1].weight+HT[min2].weight;
                 
                  cout<<min1<<""<<min2<<endl;
           }
    }
     
    //***********************************
    //构造哈夫曼编码
    //***********************************
     
    /*哈夫曼编码的定义*/
    typedef struct
    {
           charch;
           charbits[10];
    }CodeNode;
     
    typedef CodeNode * HuffmanCode;
     
    /*哈夫曼编码的构造*/
    void CreateHuffmanCode(HuffmanTree&HT,HuffmanCode &HC,int n)
    {
           inti;
           intstart;
           intc;
           intp;
           char*cd;
           charq;
           HC=newCodeNode[n];
           cd=newchar[n];
           cd[n-1]='/0';
     
           for(i=0;i<n;i++)
           {
                  cin>>q;
                  HC[i].ch=q;
                  start=n-1;
                 
                  c=i;
                  while((p=HT[c].parent)>=0)
                  {
                         --start;
                         cd[start]=(HT[p].lchild==c)?'0':'1';
                         c=p;
                  }
                  strcpy(HC[i].bits,&cd[start]);
           }
          
           deletecd;
    }
     
    /*哈夫曼编码的输出*/
    void OutputHuffmanCode(HuffmanCode&HC,int n)
    {
           inti;
           for(i=0;i<n;i++)
           {
                  cout<<HC[i].ch<<""<<HC[i].bits<<endl;
           }
    }
     
    void main()
    {
           inti;
           cout<<"输入字符个数:";
           cin>>i;
           HuffmanTreeHT;
           HuffmanCodeHC;
     
           CreateHaffmanTree(HT,i);
           CreateHuffmanCode(HT,HC,i);
           OutputHuffmanCode(HC,i);
    }

     

    唉,这个程序,用了我两天的时间,主要在一个地方,就是SelectMin()函数,其他的都简单,就是这里是一个瓶颈,突破它,就出来了。我参考了很多人写的这个函数,但是我测试了几组数据,都不符合,虽然是一个很简单的事情,可是用程序写出来,就不那么容易了。我自己写的我觉得比较繁杂,不是很简练,也许是算法不好,希望有谁有好的算法的,请指点一下!

     

    展开全文
  • 哈夫曼树代码实现

    万次阅读 多人点赞 2013-05-13 10:20:28
    哈夫曼树,又称最优树,是一类带权路径长度最短的树。 树的带权路径长度,是树中所有叶子 节点的带权路径长度之和。通常记做WPL=W1*L1+W2*L2+...+Wn*Ln。 例如: 节点ABCDE的权值分别为:1,2,4,5,6。对于图...

    定义

    哈夫曼树,又称最优树,是一类带权路径长度最短的树。

    树的带权路径长度,是树中所有叶子 节点的带权路径长度之和。通常记做WPL=W1*L1+W2*L2+...+Wn*Ln。

    例如:

    节点ABCDE的权值分别为:1,2,4,5,6。对于图1,WPL=4*3+2*3+1*3+5*3+6*1=42。对于图2,WPL=1*3+2*3+4*2+5*2+6*2=39。以上节点还可以列出其他的树,并计算WPL,可以看出,图2的WPL值是最小的,这颗树即称为最优二叉树或哈夫曼树。

    如何建立二叉树呢?

    1、将所有节点看成独立的树,且左右子树都为空,没有父节点;

    2、挑选两棵根节点权值最小的没有父节点的树,生成一个节点作为它们的父节点,父节点的权值等于他们的权值之和;

    3、重复第2步,直到最后变成一棵树。

    比如以上ABCDE节点,首先选择A和B形成的父节点(且记为A‘)权值为3,接下来从权值为3,4,5,6中选取,当然就是选3,4,也即A‘和C节点,形成父节点(且记为C’)权值为7,接下来从权值5,6,7中选取最小的两个,当然是5,6.也即是D和E,形成父节点(且记为D‘)的权值为11,最后将D’和C‘形成父节点即为最后的根节点。哈夫曼树就建成了。

    如何构建哈夫曼编码?

    从叶节点往根扫描,若为左子树则标记为0,为右子树则标记为1。如图2,A的编码即为:000,B的编码100,等等。

    具体代码实现如下:

    //huffmanCoding.c
    #include <stdio.h>
    #include <limits.h>
    #include <string.h>
    #include <stdlib.h>
    #define N 6
    
    typedef struct huffNode
    {
        unsigned int weight;   //权重
        unsigned int lchild,rchild,parent;  //左右子节点和父节点
    }HTNode,*HuffTree;
    typedef char **HuffCode;
    
    //找出数组中无父节点且权值最小的两个节点下标,分别用s1和s2保存
    void select(const HuffTree &HT,int n,int &s1,int &s2);
    //HT:哈夫曼树,HC:哈夫曼编码,w:构造哈夫曼树节点的权值,n:构造哈夫曼树节点的个数
    void HuffmanCode(HuffTree &HT,HuffCode &HC,int *w,int n);
    
    
    int main()
    {
        int i;
        char key[N] = {'0','A','B','C','D','E'};//第0个元素保留不用
        int w[N] = {0,1,2,4,5,6}; //第0个元素保留不用
        HuffTree HT;
        HuffCode HC;
        HuffmanCode(HT,HC,w,N - 1);
        for ( i = 1; i < N; i++ )
    	printf("%c:%s\n",key[i],HC[i]);  
      
        printf("\n");    
        return 0;
    }
    
    
    
    
    //找出数组中权值最小的两个节点下标,分别用s1和s2保存
    void select(const HuffTree &HT,int n,int &s1,int &s2)
    {
        int i;
        s1 = s2 = 0; 
        int min1 = INT_MAX;//最小值,INT_MAX在<limits.h>中定义的
        int min2 = INT_MAX;//次小值
    
        for ( i = 1; i <= n; ++i )
        {
    	if ( HT[i].parent == 0 )
    	{//筛选没有父节点的最小和次小权值下标
    	    if ( HT[i].weight < min1 )
    	    {//如果比最小值小
    		min2 = min1;
     		s2 = s1;
    		min1 = HT[i].weight;
    		s1 = i;
    	    }
    	    else if ( (HT[i].weight >= min1) && (HT[i].weight < min2) )
       	    {//如果大于等于最小值,且小于次小值
    		min2 = HT[i].weight;
     		s2 = i;
    	    }
    	    else
    	    {//如果大于次小值,则什么都不做
    		;
    	    }
    	}
        }
    }
    
    //HT:哈夫曼树,HC:哈夫曼编码,w:构造哈夫曼树节点的权值,n:构造哈夫曼树节点的个数
    void HuffmanCode(HuffTree &HT,HuffCode &HC,int *w,int n)
    {
        int s1;
        int s2;
        int m = 2 * n - 1;       //容易知道n个节点构造的哈夫曼树是2n-1个节点
        int i,c,f,j;
        char *code;  //暂存编码的
        HT = (HuffTree)malloc((m+1)*sizeof(HTNode));  //0单元未使用
        
    
        for ( i = 1; i <= n; i++ )
            HT[i] = {w[i],0,0,0};//初始化前n个节点(构造哈夫曼树的原始节点)
        
        for ( i = n + 1; i <= m; i++ )
    	HT[i] = {0,0,0,0};  //初始化后n-1个节点
    
        //构建哈夫曼树
        for ( i = n + 1; i <= m; i++)
        {
    	select(HT,i-1,s1,s2);//找出前i-1个节点中权值最小的节点下标
    	HT[s1].parent = i;
    	HT[s2].parent = i;
    	HT[i].lchild = s1;
    	HT[i].rchild = s2;
    	HT[i].weight = HT[s1].weight + HT[s2].weight;
        }
        //哈夫曼编码
        HC = (char **)malloc((n)*sizeof(char *));
        //暂存编码
        code = (char *)malloc(n*sizeof(char));//使用了第0单元
        for ( i = 1; i <= n; i++ )
        {
    	for ( c = i, f = HT[c].parent, j = 0; f != 0; c = HT[c].parent, f = HT[c].parent,  j++ )
    	{//从叶子扫描到根
    	    if ( HT[f].lchild == c ) 
    	    {
    		code[j] = '0';
    	    }
    	    else if(HT[f].rchild == c)
    	    {
    		code[j] = '1';
    	    }
     	    else
    	    {//否则什么也不做
    		;
    	    }
    	}
    	code[j] = '\0';
       	HC[i] = (char *)malloc(strlen(code)*sizeof(char));
    	strcpy(HC[i],code);
        }
        
    }
    
    
    
    
    

    运行结果:



    展开全文
  • 哈夫曼树 代码实现

    千次阅读 2017-10-09 15:23:13
    什么是哈夫曼树哈夫曼树又称最优二叉树, 是一种带权路径最短的二叉树。所谓树的路径长度,就是树中所有的叶结点 的权值乘上其到根结点的 路径长度(若根结点为0层,叶结点到根结点的路径长度 为叶结点的层数)...
  • 博主就很掘的一个人,最近学哈夫曼树,想着用指针去实现,觉得用指针实现,内存消耗会更少,写到后面发现越来与麻烦,且内存开销并没有减少,于是还是使用结构体数组中规中矩的去实现哈夫曼树,博主不爱看别人的代码,...
  • 哈夫曼树与哈夫曼编码的理解 数据压缩 含义 通过对数据重新的编码,减少数据占用的空间存储;使用的时候再进行解压缩,恢复数据的原有特性。 类别 无损压缩——压缩过程没有数据丢失,解压得到原有数据特性。 有损...
  • 哈夫曼树程序源代码,能够实现初始化,编码,译码,显示编码表,绝对能够正确运行!
  • 其实基本是基于C的代码实现的,时间复杂度还可以,变量比较多,但思路很清晰。
  • 哈夫曼树实现的压缩工具源代码,用netbeans导入可以看见源代码,仅供学习参考
  • package huffman;import java.io.FileInputStream;import java.io.FileOutputStream;import java.util.Arrays;.../*** 利用哈夫曼编码实现文件解压缩的类** @author dongyunqi* @date 2018年7月...
  • C++实现哈夫曼树的生成已经解码。绝对好用!
  • 建议先学习哈夫曼树原理再来看该博客的代码实现 相关概念 叶子结点的权值:叶子结点的数值量,如某个字符出现的频率,修路的费用等 二叉树的带权路径长度:设二叉树有n个带权值的叶子结点,从根结点到各个叶子结点的...
  • 输入的一串电文字符实现哈夫曼编码,再对哈夫曼编码生成的 代码串进行译码,输出电文字符串。即以字符串字母出现次数为权值,生成哈夫曼树。 #include<stdio.h> #include<string.h> #include<stdlib....
  • 前言哈夫曼树是数据压缩编码算法的基础,本文使用JavaScript语言实现了该算法。算法流程:输入待编码的字符串,算法去构造哈夫曼树,从而实现对字符串的二进制压缩编码。对于哈夫曼树理论的学习,可去参见其他文章。...
  • 节点定义 import java.util.Comparator; public class Node{ private Node left; // private Integer data;//数据域 private Node right; public Node() { } public Node(Integer data) { this.data = ...
  • 这是数据结构课设 哈夫曼树的c语言实现 大家可以借鉴一下
  • 哈夫曼树代码

    2012-12-19 11:33:22
    哈夫曼树源代码,可以实现解码和译码,在文件中输入大写字母即可
  • //根据给定的哈夫曼树,从每个叶子结点出发追溯到根,逆向找出最优二叉树中叶子结点的编码 //n个叶子结点在哈夫曼HT中的下标为1~n,第i(1)个叶子的编码存放在HC[i]中 void HuffmanCoding(HuffmanTree HT,HuffmanCode...
  • 哈夫曼树与哈夫曼编码(C语言代码实现

    万次阅读 多人点赞 2015-01-26 14:52:24
    哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛,如 JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树哈夫曼树又称最优二叉树,是一种带权路径长度最短的二叉树。所谓树的带权路径长度,就是树中所有...
  • 哈夫曼树是带权路径最短的树,权值加大的节点离根节点较近. 示例代码如下: public class HuffmanTreeCode { public static void main(String[] args) { HuffmanTreeDemo huffmanTree = new HuffmanTreeDemo(); // ...
  • 参考文章:Java实现哈夫曼树 import java.util.ArrayList; import java.util.Comparator; public class huffmanTree { private TreeNode root; private ArrayList<TreeNode> array = new ArrayList<>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 593
精华内容 237
关键字:

哈夫曼树实现代码