精华内容
下载资源
问答
  • 哈夫曼算法

    2018-03-09 12:41:06
    使用哈夫曼算法对字符进行排序,通过字符出现的权值求出哈夫曼树,并给出哈夫曼编码
  • a.b.c.d.e 对应出现频率为4,6,11,13,15 用Python实现哈夫曼代码可参考:哈夫曼树的 Python 实现 或者:https://blog.csdn.net/qq_42098718/article/details/102809485

    a.b.c.d.e 对应出现频率为4,6,11,13,15

    用Python实现哈夫曼代码可参考:哈夫曼树的 Python 实现   或者:https://blog.csdn.net/qq_42098718/article/details/102809485

    .选择排序:不稳定,时间复杂度 O(n^2)

    插入排序:稳定,时间复杂度 O(n^2)

    冒泡排序:稳定,时间复杂度 O(n^2)

    堆排序:不稳定,时间复杂度 O(nlog n)

    归并排序:稳定,时间复杂度 O(nlog n)

    快速排序:不稳定,时间复杂度 最理想 O(nlogn) 最差时间O(n^2)

    展开全文
  • 时间复杂度用于度量算法的计算工作量,空间复杂度用于度量算法占用的内存空间。这篇文章主要介绍了Python算法中的时间复杂度,需要的朋友可以参考下
  • 时间复杂度和空间复杂度是用来评价算法效率高低的2个标准。 时间复杂度:就是说执行算法需要消耗的时间长短,越快越好。比如for循环次数。 空间复杂度:就是说执行当前算法需要消耗的存储空间大小,也是越少越好。...

    一、定义

    时间复杂度和空间复杂度是用来评价算法效率高低的2个标准。

    时间复杂度:就是说执行算法需要消耗的时间长短,越快越好。比如for循环次数。
    空间复杂度:就是说执行当前算法需要消耗的存储空间大小,也是越少越好。计算机的存储资源是有限的,算法耗费的存储空间不可超限。

    但这二者有时是冲突的,所以我们需要做权衡利弊。

    二、时间复杂度的计算

    表示方法
    我们一般用“大O符号表示法”来表示时间复杂度:T(n) = O(f(n))
    n是影响复杂度变化的因子,f(n)是复杂度具体的算法。

    常见的时间复杂度量级

    • 常数阶O(1)
    • 线性阶O(n)
    • 对数阶O(logN)
    • 线性对数阶O(nlogN)
    • 平方阶O(n²)
    • 立方阶O(n³)
    • K次方阶O(n^k)
    • 指数阶(2^n)

    三、空间复杂度计算

    • 空间复杂度 O(1)
      如果算法执行所需要的临时空间不随着某个变量n的大小而变化,即此算法空间复杂度为一个常量,可表示为 O(1)。
    • 空间复杂度 O(n)
    展开全文
  • 霍夫曼算法 霍夫曼编码 (Huffman coding) Huffman Algorithm was developed by David Huffman in 1951. Huffman算法由David Huffman在1951年开发。 This is a technique which is used in a data compression or it ...

    霍夫曼算法

    霍夫曼编码 (Huffman coding)

    • Huffman Algorithm was developed by David Huffman in 1951.

      Huffman算法由David Huffman在1951年开发。

    • This is a technique which is used in a data compression or it can be said that it is a coding technique which is used for encoding data.

      这是用于数据压缩的技术,或者可以说是用于编码数据的编码技术。

    • This technique is a mother of all data compression scheme.

      该技术是所有数据压缩方案的基础。

    • This idea is basically dependent upon the frequency, i.e. the frequency of the corresponding character which needs to be compressed, and by that frequency, only Huffman code will be generated.

      该思想基本上取决于频率,即,需要压缩的相应字符的频率,并且根据该频率,将仅生成霍夫曼码。

    • In case of Huffman coding, the most generated character will get the small code and least generated character will get the large code.

      对于霍夫曼编码,生成最多的字符将获得小代码,生成最少的字符将获得大代码。

    • Huffman tree is a specific method of representing each symbol.

      霍夫曼树是表示每个符号的一种特定方法。

    • This technique produces a code in such a manner that no codeword is a prefix of some other code word. These codes are called as prefix code.

      该技术以这样的方式产生代码:没有代码字是某个其他代码字的前缀。 这些代码称为前缀代码。

    霍夫曼编码算法 (Algorithm for Huffman code)

        1.	Input:-Number of message with frequency count.
        2.	Output: - Huffman merge tree.
        3.	Begin
        4.	Let Q be the priority queue,
        5.	Q= {initialize priority queue with frequencies of all symbol or message}
        6.	Repeat n-1 times 
        7.	Create a new node Z 
        8.	X=extract_min(Q)
        9.	Y=extract_min(Q)
        10.	Frequency(Z) =Frequency(X) +Frequency(y);
        11.	Insert (Z, Q)
        12.	End repeat 
        13.	Return (extract_min(Q))
        14.	End.
    
    
    

    Example:

    例:

    Let obtain a set of Huffman code for the message (m1.....m7) with relative frequencies (q1.....q7) = (4,5,7,8,10,12,20). Let us draw the Huffman tree for the given set of codes.

    让我们为消息(m1 ..... m7)获得一组霍夫曼代码,其相对频率(q1 ..... q7)=(4,5,7,8,10,12,20) 。 让我们为给定的代码集绘制霍夫曼树。

    Step 1) Arrange the data in ascending order in a table.

    步骤1)在表中按升序排列数据。

    4,5,7,8,10,12,20

    4,5,7,8,10,12,20

    Step 2) Combine first two entries of a table and by this create a parent node.

    步骤2)合并表的前两个条目,并由此创建一个父节点。

    Huffman coding algo 1

    Step 3)

    步骤3)

    A) Remove the entries 4 and 5 from the table and inert 9 at its appropriate position. 7,8,9,10,12,20

    A)从表中删除条目4和5,并在适当位置插入9。 7,8,9,10,12,20

    Combine minimum value of table and create a parent node.

    合并表的最小值并创建一个父节点。

    Huffman coding algo 2

    B) Now remove the entries 7 and 8 from the table and insert 15 at its appropriate position. 9,10,12,15,20

    B)现在从表中删除条目7和8,并在其适当位置插入15。 9,10,12,15,20

    Combine minimum value of two blocks and create a parent node.

    合并两个块的最小值并创建一个父节点。

    Huffman coding algo 3

    C) Remove the entries 9 and 10 from the table and insert 19 at its proper position. 12,15,19,20.

    C)从表中删除条目9和10,并在其适当位置插入19。 12,15,19,20。

    Combine minimum value of two blocks and create parent node.

    合并两个块的最小值并创建父节点。

    Huffman coding algo 4

    D) Remove the entries 15 and 12 from the table and insert 27 at its appropriate position. 19,20,27

    D)从桌子上取下入口15和12,并在其适当位置插入27。 19,20,27

    Combine minimum value of two blocks and create parent node.

    合并两个块的最小值并创建父节点。

    Huffman coding algo 5

    E) Remove the entries 19 and 20 from the table and insert 39 in the table. 27,39

    E)从表中删除条目19和20,然后在表中插入39。 27,39

    Combine minimum value of two blocks and create parent node.

    合并两个块的最小值并创建父节点。

    Huffman coding algo 6

    Step 4) Now assign left child as 0 and right child as 1 to encode the frequencies.

    步骤4)现在将左子级分配为0,右子级分配为1以对频率进行编码。

    Huffman coding algo 7

    Now, codes for the given frequencies are given below:

    现在,给定频率的代码如下:

    Huffman coding algo 8

    时间复杂度: (Time complexity:)

    O(nlogn) is the overall time complexity. Where n is the number of characters.

    O(nlogn)是整体时间复杂度。 其中n是字符数。

    翻译自: https://www.includehelp.com/algorithms/huffman-coding-algorithm-example-and-time-complexity.aspx

    霍夫曼算法

    展开全文
  • 实现Huffman编码

    2011-09-01 23:33:18
    HUFFMAN编码又称哈夫曼编码,是一种可变长编码方式,是由美国数学家David Huffman创立的,是二叉树的一种特殊转化形式。编码的原理是:将使用次数多的代码转换成长度较短的代码,而使用次数少的可以使用较长的编码,...
  • 贪心算法-哈夫曼编码

    2011-12-07 11:44:22
    本程序是VS2010下的源程序,可直接运行。...本程序实现了通过读取文件中关于字符的相关说明数据来初始化相关变量,最后采用贪心算法的思想编程实现哈夫曼编码的求解。最终输出各个字符的哈弗曼编码值。
  • 哈夫曼编码 一、【问题描述】 设要编码的字符集为{d1,d2,…,dn},它们出现的频率为{w1,w2,…,wn},应用哈夫曼树构造最优的不等长的由0,1构成的编码方案。 二、【问题求解】 先构建以这个n个结点为叶子结点的哈夫曼...

    哈夫曼编码

    一、【问题描述】
    设要编码的字符集为{d1,d2,…,dn},它们出现的频率为{w1,w2,…,wn},应用哈夫曼树构造最优的不等长的由0,1构成的编码方案。

    二、【问题求解】
    先构建以这个n个结点为叶子结点的哈夫曼树,然后由哈夫曼树产生各叶子结点对应字符的哈夫曼编码。

    (0)哈夫曼树:给定n个权值作为n个叶子结点,构造一棵二叉树,若树的带权路径长度达到最小,则这棵树被称为哈夫曼树。

    (1) 路径和路径长度:在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1。

    (2) 结点的权及带权路径长度:若将树中结点赋给一个有着某种含义的数值,则这个数值称为该结点的权。结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积。

    (3) 树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和,记为WPL。

    ⭐对于一些基本概念,此处不进行更多赘述
    如果还有疑惑可以参考这篇博文:
    传送门→_→ 哈夫曼树+哈夫曼编码

    构造一棵哈夫曼树的方法如下:
    ①由给定的n个权值, n个权值分别设为 w1、w2、…、wn,构造n棵只有1个叶子结点的二叉树,从而得到一个二叉树的集合F={T1,T2,…Tn}。

    ②在F中选取根节点的权值最小和次小的两颗二叉树作为左、右子树构造一棵新的二叉树,这颗新的二叉树根节点的权值为其左、右子树根节点权值之和。即合并两棵二叉树为一棵二叉树。

    ③重复步骤②,当F中只剩下一棵二叉树时,这棵二叉树便是所要建立的哈夫曼树。

    例如给定a~d四个字符,它们的权值集合为w={100,10,50,20}

    首先构造出哈夫曼树,过程如下图:
    在这里插入图片描述
    在这里插入图片描述
    接下来对字符进行编码并求出WPL
    在这里插入图片描述

    三、【代码实现】
    如下:

    #pragma warning(disable:4786) //用于屏蔽标识符过长导致的warning 
    #include <iostream>
    #include <queue>
    #include <vector>
    #include <string>
    #include <map>
    using namespace std; 
    #define MAX 101
    int n;
    struct HTreeNode				//哈夫曼树结点类型
    {
    	char data;					//字符
    	int weight;					//权值
    	int parent;					//双亲的位置
    	int lchild;					//左孩子的位置
    	int rchild;					//右孩子的位置
    };
    HTreeNode ht[MAX];				//哈夫曼树
    map<char,string> htcode;			//哈夫曼编码
    
    struct NodeType		//优先队列结点类型
    {
    	int no;				//对应哈夫曼树ht中的位置
    	char data;			//字符
    	int  weight;		//权值
    	bool operator<(const NodeType &s) const
    	{					//运算符重载进行从小到大的递增排序 
    		return s.weight<weight;
    	}
    };
    void CreateHTree()						//构造哈夫曼树
    {
    	NodeType e,e1,e2;
    	priority_queue<NodeType> qu;
    	for (int k=0;k<2*n-1;k++)	//设置所有结点的指针域
    		ht[k].lchild=ht[k].rchild=ht[k].parent=-1;
    	for (int i=0;i<n;i++)				//将n个结点进队qu
    	{
    		e.no=i;
    		e.data=ht[i].data;
    		e.weight=ht[i].weight;
    		qu.push(e);
    	}
    	for (int j=n;j<2*n-1;j++)			//构造哈夫曼树的n-1个非叶结点
    	{
    		e1=qu.top();  qu.pop();		//出队权值最小的结点e1
    		e2=qu.top();  qu.pop();		//出队权值次小的结点e2
    		ht[j].weight=e1.weight+e2.weight; //构造哈夫曼树的非叶结点j	
    		ht[j].lchild=e1.no;
    		ht[j].rchild=e2.no;
    		ht[e1.no].parent=j;			//修改e1.no的双亲为结点j
    		ht[e2.no].parent=j;			//修改e2.no的双亲为结点j
    		e.no=j;						//构造队列结点e
    		e.weight=e1.weight+e2.weight;
    		qu.push(e);
    	}
    }
    void CreateHCode()			//构造哈夫曼编码
    {
    	string code;
    	code.reserve(MAX);
    	for (int i=0;i<n;i++)	//构造叶结点i的哈夫曼编码
    	{
    		code="";
    		int curno=i;
    		int f=ht[curno].parent;
    		while (f!=-1)				//循环到根结点
    		{
    			if (ht[f].lchild==curno)	//curno为双亲f的左孩子
    				code='0'+code;
    			else					//curno为双亲f的右孩子
    				code='1'+code;
    			curno=f; f=ht[curno].parent;
    		}
    		htcode[ht[i].data]=code;	//得到ht[i].data字符的哈夫曼编码
    	}
    }
    void DispHCode()					//输出哈夫曼编码
    {
    	map<char,string>::iterator it;
    	for (it=htcode.begin();it!=htcode.end();++it)
    		cout << "    " << it->first << ": " << it->second <<	endl;
    }
    void DispHTree()					//输出哈夫曼树
    {
    	for (int i=0;i<2*n-1;i++)
    	{
    		printf("    data=%c, weight=%d, lchild=%d, rchild=%d, parent=%d\n",
    			ht[i].data,ht[i].weight,ht[i].lchild,ht[i].rchild,ht[i].parent);
    	}
    }
    int WPL()				//求WPL
    {
    	int wps=0;
    	for (int i=0;i<n;i++)
    		wps+=ht[i].weight*htcode[ht[i].data].size();
    	return wps;
    }
    
    int main()
    {
    	n=4;
    	ht[0].data='a'; ht[0].weight=100;		//置初值即n个叶子结点
    	ht[1].data='b'; ht[1].weight=10;  
    	ht[2].data='c'; ht[2].weight=50;  
    	ht[3].data='d'; ht[3].weight=20;  
    	CreateHTree();					//建立哈夫曼树
    	printf("构造的哈夫曼树:\n");
    	DispHTree();
    	CreateHCode();					//求哈夫曼编码
    	printf("产生的哈夫曼编码如下:\n");
    	DispHCode();					//输出哈夫曼编码
    	printf("WPL=%d\n",WPL());
    	return 0;
    }
    

    代码运行截图:
    在这里插入图片描述
    本文参考自《算法设计与分析》李春葆第二版

    展开全文
  • Huffman编码(哈夫曼编码),

    千次阅读 2015-12-13 16:27:22
    整个算法时间复杂度可以达到nlg(n),这里为了简单,没有实现最小堆,而使用的是STL中的set,通过实现正确的比较函数对象,每次可以取得优先级(字符出现频度最低)最大的值。但是这里的时间复杂度却提高了,因为...
  • 时间复杂度(一)

    2018-08-25 16:15:41
    二叉查找树——时间复杂度logN(N总数) 高度初值1 深度初值0   AVL高度平衡树 红黑树插入N个——时间复杂度NlogN 哈夫曼树,权值大的靠近根。应用于变长编码表中...
  • 举例理解哈夫曼树与哈夫曼编码

    万次阅读 2020-07-02 08:52:56
    举例理解哈夫曼树,C语言实现哈夫曼
  • 多元哈夫曼编码问题

    2020-04-30 23:29:16
    重要提示 接下来的算法步骤我写的有错误 错误原因是因为将选择的数组未进行重新排序 与能力的可以尝试修改完善此代码 这里附上正确的**代码** 请点击跳转 正确代码的博客地址 算法步骤 1、 获取n(石子堆数),k...
  • 贪心算法哈夫曼编码问题

    万次阅读 2018-03-04 03:09:45
    1、问题通常的编码方法有固定长度编码和不等长度编码两种。这是一个设计最优编码方案的问题,目的是使总码长度最短。这个问题利用字符的使用频率来编码,是不等长编码方法,使得经常使用的字符编码较短,不常使用的字符...
  • 这篇文章我们开始看看贪心算法和它的实际应用,贪心算法有很多经典的应用:哈夫曼编码、Prim和Kruskal最小生成树算法、Dijkstra单源最短路径算法 1、如何理解贪心算法 贪心算法的思想是:每次都做出当前最优的选择,...
  • 哈夫曼编码-贪心算法

    千次阅读 2019-03-30 18:50:48
    哈夫曼编码的基本思想时以字符的使用频率作为权构建一颗哈夫曼树,然后利用哈夫曼树对字符进行编码。构造一颗哈夫曼树,是将所有的编码的字符作为叶子结点,该字符在文件中的使用频率作为叶子结点的权值,以自底向上...
  • 构造最优前缀码的贪心算法就是哈夫曼算法 pop:pop:pop: 每次从队列中取出两个权值最小的节点当作孩子节点 push:push:push: 根据 poppoppop 操作取出的两个子结点,构成一个带有新的权值(两个子结
  • 作为开发人员,我们都希望在完成...执行时间和占用空间是代码性能的2个评判标准,我们分别用时间复杂度和空间复杂度去描述这2个标准,二者统称复杂度复杂度描述的是算法执行时间(或占用空间)随数据规模的增...
  • 介绍贪心算法的一般步骤: 1.建立数学模型来描述问题。 2.把求解的问题分成若干个子问题。 3.对每一子问题求解,得到子问题的局部最优解。 4.把子问题的解局部最优解合成原来解问题的一个解。 二. 贪心算法适合解决...
  • 这是根据算法设计与分析的课程实验而编写的代码,完全可以使用,欢迎大家下载。
  • 最小堆建哈夫曼树 测试用例: 5 1 2 3 4 5 #include<stdio.h> #include<stdlib.h> #define MinData -10001 typedef struct Heap *MinHeap; typedef struct HTNode *HuffmanTree; struct Heap{ ...
  • 贪心算法详解:哈夫曼编码

    千次阅读 2019-01-17 16:34:35
    贪心算法是一种算法思想,并不是一个具体的算法,因此我们用两个例子来理解什么样的问题适合用贪心算法解决。 例一 现在有一个能装100g物品的背包,和一些可拆分的物品(见表格),怎么装才能使背包中物品价值最大...
  • 为此提出一种新的自适应哈夫曼编码算法,它利用符号到达前后构造哈夫曼树的相似性,仅更新少量节点即可完成编码过程 。与原有的 V算法相比,有效降低了编码复杂度,占用存储资源较少,易于硬件实现 。
  • 淮海工学院计算机工程学院 实验报告书 课程名 算法分析与设计 题 目 实验3 贪心算法 哈夫曼编码 班 级 软件102班 学 号 11003215 姓 名 鹿迅 评语: 成绩 指导教师 批阅时间: 实验 3 贪心算法 实验目的和要求 1了解...
  • } } 哈夫曼编码: 如何编码: 哈夫曼编码代码实现(编码和解码): import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import...
  • 【贪心算法哈夫曼编码问题

    千次阅读 多人点赞 2020-05-09 21:47:11
    哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0,1串表示各字符的最优表示方式。一个包含100,000个字符的文件,各字符出现频率不同,设某信源产生a,b,c,d和f 6种符号,其频率见下表,单位为千次。 从表...
  • 注:实现Huffman编码是用贪心算法来实现的,证明Huffman的贪心选择和最...整个算法时间复杂度可以达到nlg(n),这里为了简单,没有实现最小堆,而使用的是STL中的set,通过实现正确的比较函数对象,每次可以取得优先级

空空如也

空空如也

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

哈夫曼编码算法时间复杂度