精华内容
下载资源
问答
  • 根据字符对应的前缀编码将一串编码进行反解码处理 前言: 最近在学习哈夫曼编码时碰到了许多好玩且精妙的算法,不由自主的想把它提取出来。今天提取出如何在知道字符对应的前缀编码表后将目标编码反解码为字符串。 ...

    根据字符对应的前缀编码将一串编码进行反解码处理

    前言:
    最近在学习哈夫曼编码时碰到了许多好玩且精妙的算法,不由自主的想把它提取出来。今天提取出如何在知道字符对应的前缀编码表后将目标编码反解码为字符串

    前缀编码
    如果在一个编码方案中,任何一个编码都不是其他任何编码的前缀(最左子串),则称该编码是前缀编码。

    比如给出以下编码表:
    i:11, k:100, e:101 ,l:00 ,a:011 ,j:0100 ,v:0101
    我们不难发现每个字符对应的编码都不是其他字符对应编码的前缀。前缀编码可用于无损压缩。

    那么题目来了
    给出以下一串编码:
    1100111001010011100101001110010101000110101011
    再根据下面的编码表:
    i:11, k:100, e:101 ,l:00 ,a:011 ,j:0100 ,v:0101
    将此串编码反编成对应的字符串。

    解题思路:
    1.将编码表以“编码–>字符"形式存入到map集合中
    2.用字符串分割将编码串从第一个开始分割,比如首先分割第一位,得到”1“,尝试从map中以key为”1“取value,当取出为空,则说明map没有对应编码表,继续向后切割,取”11“,再次从map中以key取值,于是发现取到了字符 “i”,放入到list集合中去,那么取出部分便不再切割,接着取”0“,取”00“…直到编码取完。
    3.根据取完后的list字符集拼成字符串即可。

    参考代码如下:

    在这里插入代码片public class Main3 {
    	public static void main(String[] args) {
    		//首先根据上面的编码表将编码对应字符分别存入到key,value中
    		Map<String,Character> map=new HashMap<String,Character>();
    		map.put("11",'i');
    		map.put("100",'k');
    		map.put("101",'e');
    		map.put("00",'l');
    		map.put("011",'a');
    		map.put("0100",'j');
    		map.put("0101",'v');
    		String pwd="1100111001010011100101001110010101000110101011";
    		//创建一个集合类,存放字符
    		List<Character> list=new ArrayList<>();
    		for(int i=0;i<pwd.length();) {
    			int count=1;
    			boolean flag=true;//判断是否拿到了字符
    			Character b=null;
    			while(flag) {
    				//递增取出key1
    				//i不动,让count移动,指定匹配下一个字符
    				String key=pwd.substring(i,i+count);
    				b=map.get(key);
    				if(b==null) {//说明没有匹配到
    					count++;
    				}else {//说明匹配到了
    					flag=false;
    				}
    			}
    			list.add(b);
    			i+=count;
    		}
    		for(char c:list) {
    			System.out.print(c);
    		}
    		
    	}
    }
    
    

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

    展开全文
  • python字符前缀编码

    千次阅读 2018-02-10 22:10:40
    字符前缀 普通字符字符串前面加r 字符串前面加b 字符编码 字符串格式化 小结 字符前缀 1. 普通字符串 一般字符串都是默认用Unicode编码的,可以用\来转义,例如: a = u'test\ntest' # 等同...

    字符串前缀

    1. 普通字符串

    一般字符串都是默认用Unicode编码的,可以用\来转义,例如:

    a = u'test\ntest'  # 等同于a = 'test\ntest'
    print(a)
    # 输出
    test
    test

    2. 字符串前面加r

    在字符串前面加上一个 r 表示该字符串为raw string,不识别转义。

    a = r'test\ntest'  # 等同于a = 'test\\ntest'
    print(a)
    # 输出
    test\ntest

    3. 字符串前面加b

    生成字节序列对象bytearray。这在需要按字节序列发送数据时有用,比如网络发送.

    message = b"GET / HTTP/1.1\r\n\r\n"
    s.sendall(message)

    message的类型不再是str,而是bytes了。

    字符编码

    因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295。

    最早只有127个字符被编码到计算机里,也就是大小写英文字母、数字和一些符号,这个编码表被称为ASCII编码,比如大写字母A的编码是65,小写字母z的编码是122。

    但是要处理中文显然一个字节是不够的,至少需要两个字节,而且还不能和ASCII编码冲突,所以,中国制定了GB2312编码,用来把中文编进去。

    你可以想得到的是,全世界有上百种语言,日本把日文编到Shift_JIS里,韩国把韩文编到Euc-kr里,各国有各国的标准,就会不可避免地出现冲突,结果就是,在多语言混合的文本中,显示出来会有乱码。

    因此,Unicode应运而生。Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

    你可以猜测,如果把ASCII编码的A用Unicode编码,只需要在前面补0就可以,因此,A的Unicode编码是00000000 01000001。

    新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。

    所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:

    字符 ASCII Unicode UTF-8
    A 01000001 00000000 01000001 01000001
    中 x 01001110 00101101 11100100 10111000 10101101
    从上面的表格还可以发现,UTF-8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF-8编码的一部分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

    搞清楚了ASCII、Unicode和UTF-8的关系,我们就可以总结一下现在计算机系统通用的字符编码工作方式:

    在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

    用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件:
    这里写图片描述
    浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器:
    这里写图片描述
    所以你看到很多网页的源码上会有类似的信息,表示该网页正是用的UTF-8编码。

    Python的字符串

    搞清楚了令人头疼的字符编码问题后,我们再来研究Python的字符串。

    在最新的Python 3版本中,字符串是以Unicode编码的,也就是说,Python的字符串支持多语言,例如:

    print('包含中文的str')
    # 输出
    包含中文的str

    对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码转换为对应的字符:

    ord('A')
    # 输出
    65
    ord('中')
    # 输出
    20013
    chr(66)
    # 输出
    'B'
    chr(25991)
    # 输出
    '文'

    如果知道字符的整数编码,还可以用十六进制这么写str:

    '\u4e2d\u6587'
    # 输出
    '中文'

    两种写法完全是等价的。

    由于Python的字符串类型是str,在内存中以Unicode表示,一个字符对应若干个字节。如果要在网络上传输,或者保存到磁盘上,就需要把str变为以字节为单位的bytes。

    Python对bytes类型的数据用带b前缀的单引号或双引号表示:

    x = b’ABC’

    要注意区分’ABC’和b’ABC’,前者是str,后者虽然内容显示得和前者一样,但bytes的每个字符都只占用一个字节。

    以Unicode表示的str通过encode()方法可以编码为指定的bytes,例如:

    'ABC'.encode('ascii')
    # 输出
    b'ABC'
    '中文'.encode('utf-8')
    # 输出
    b'\xe4\xb8\xad\xe6\x96\x87'
    '中文'.encode('ascii')
    # 输出
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

    纯英文的str可以用ASCII编码为bytes,内容是一样的,含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码,因为中文编码的范围超过了ASCII编码的范围,Python会报错。

    在bytes中,无法显示为ASCII字符的字节,用\x##显示。

    反过来,如果我们从网络或磁盘上读取了字节流,那么读到的数据就是bytes。要把bytes变为str,就需要用decode()方法:

    b'ABC'.decode('ascii')
    # 输出
    'ABC'
    b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    # 输出
    '中文'

    要计算str包含多少个字符,可以用len()函数:

    len('ABC')
    # 输出
    3
    len('中文')
    # 输出
    2

    len()函数计算的是str的字符数,如果换成bytes,len()函数就计算字节数:

    len(b'ABC')
    # 输出
    3
    len(b'\xe4\xb8\xad\xe6\x96\x87')
    # 输出
    6
    len('中文'.encode('utf-8'))
    # 输出
    6

    可见,1个中文字符经过UTF-8编码后通常会占用3个字节,而1个英文字符只占用1个字节。

    在操作字符串时,我们经常遇到str和bytes的互相转换。为了避免乱码问题,应当始终坚持使用UTF-8编码对str和bytes进行转换。

    由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-

    第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;

    第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

    申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的,必须并且要确保文本编辑器正在使用UTF-8 without BOM编码:
    这里写图片描述
    如果.py文件本身使用UTF-8编码,并且也申明了# -- coding: utf-8 --,打开命令提示符测试就可以正常显示中文:
    这里写图片描述

    字符串格式化

    最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似’亲爱的xxx你好!你xx月的话费是xx,余额是xx’之类的字符串,而xxx的内容都是根据变量变化的,所以,需要一种简便的格式化字符串的方式。
    这里写图片描述
    在Python中,采用的格式化方式和C语言是一致的,用%实现,举例如下:

    'Hello, %s' % 'world'
    # 输出
    'Hello, world'
    'Hi, %s, you have $%d.' % ('Michael', 1000000)
    # 输出
    'Hi, Michael, you have $1000000.'

    %运算符就是用来格式化字符串的。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%?占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个%?,括号可以省略。

    常见的占位符有:

    %d 整数
    %f 浮点数
    %s 字符串
    %x 十六进制整数
    其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数:

    '%2d-%02d' % (3, 1)
    # 输出
    ' 3-01'
    '%.2f' % 3.1415926
    # 输出
    '3.14'

    如果你不太确定应该用什么,%s永远起作用,它会把任何数据类型转换为字符串:

    'Age: %s. Gender: %s' % (25, True)
    # 输出
    'Age: 25. Gender: True'

    有些时候,字符串里面的%是一个普通字符怎么办?这个时候就需要转义,用%%来表示一个%:

    'growth rate: %d %%' % 7
    # 输出
    'growth rate: 7 %'

    小结

    Python 3的字符串使用Unicode,直接支持多语言。

    str和bytes互相转换时,需要指定编码。最常用的编码是UTF-8。Python当然也支持其他编码方式,比如把Unicode编码成GB2312:

    '中文'.encode('gb2312')
    # 输出
    b'\xd6\xd0\xce\xc4'

    但这种方式纯属自找麻烦,如果没有特殊业务要求,请牢记仅使用UTF-8编码。

    部分转自:Python基础(字符串和编码)

    展开全文
  • 霍夫曼前缀编码

    千次阅读 2016-11-07 13:04:25
     每叶子表示的字符编码,就是 从根到叶子的路径上的标号依次相连所形成的编码,显然这就是该字符的最优前缀码。 所谓 前缀码 是指,对字符集进行编码时,要求字符集中任一字符编码都不是其它字符编码的...

    作为哈夫曼树的一个重要应用,我们来介绍哈夫曼编码。在我的上一篇博文《树之哈夫曼树》中已经介绍了建立哈夫曼树的过程,而由哈夫曼树求得的编码为最优前缀码。 每个叶子表示的字符的编码,就是 从根到叶子的路径上的标号依次相连所形成的编码,显然这就是该字符的最优前缀码。 所谓 前缀码 是指,对字符集进行编码时,要求字符集中任一字符的编码都不是其它字符的编码的前缀,比如常见的等长编码就是前缀码。所谓 最优前缀码 是指,平均码长或文件总长最小的前缀编码称为最优的前缀码(这里的平均码长相当于码长的期望值)。

    我们知道,变长编码可能使解码产生二义性,而前缀码的出现很好地解决了这个问题。而平均码长相当于二叉树的加权路径长度,从这个意义上说,由哈夫曼树生成的编码一定是最优前缀码,故通常不加区分的将哈夫曼编码也称作最优前缀码。

    需要注意的是,由于哈夫曼树建立过程的不唯一性可知,生成的哈夫曼编码也是不唯一的,并且在本文中,将树中左分支和右分支分别标记为0和1也造成了哈夫曼编码的不唯一性(当然也可以反过来,将左分支记为1,右分支记为0)。

    在实际应用中,我们通常采用下列做法:根据各个字符的权值建立一颗哈夫曼树,求得每个字符的哈夫曼编码,有了每个字符的哈夫曼编码,我们就可以制作一个该字符集的哈夫曼编码表。有了字符集的哈夫曼编码表之后,对数据文件的 编码过程 是:依次读人文件中的字符c,在哈夫曼编码表H中找到此字符,将字符c转换为对应的哈夫曼编码串。对压缩后的数据文件进行 解码 则必须借助于哈夫曼树,其过程是:依次读人文件的二进制码,从哈夫曼树的根结点出发,若当前读入0,则走向左孩子,否则走向右孩子。一旦到达某一叶子时便译出相应的字符。然后重新从根出发继续译码,直至文件结束。下面给出制作哈夫曼编码表的过程的代码,通过以上的分析,读者不难写出文件编码过程和解码过程的代码。

    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    
    #define n 6		   //叶子数目
    #define m 2*n-1	   //树中结点总数
    typedef struct{	   //结点类型
    	double weight;	//结点的权值
    	int parent,lchild,rchild;//双亲指针及左右孩子
    }HTNode;
    typedef HTNode HuffmanTree[m];//HuffmanTree是向量类型
    
    typedef struct{	   //用于SelectMin函数中排序的结点类型
    	int id;		   //保存根结点在向量中的序号
    	double weight;	//保存根结点的权值
    }temp;
    
    typedef struct{	   //编码结点
    	char ch;		  //存储字符
    	char bits[n+1];   //存放编码位串
    }CodeNode;
    typedef CodeNode HuffmanCode[n];
    
    void InitHuffmanTree(HuffmanTree T){
    	//初始化哈夫曼树
    	//将2n-1个结点里的三个指针均置为空(即置为-1),权值置为0
    	for(int i=0;i<m;i++){
    		T[i].lchild=-1;
    		T[i].rchild=-1;
    		T[i].parent=-1;
    		T[i].weight=0;
    	}
    }
    
    void InputWeight(HuffmanTree T){
    	//输入叶子权值
    	//读人n个叶子的权值存于向量的前n个分量中
    	for(int i=0;i<n;i++){
    		double x;
    		scanf("%lf",&x);
    		T[i].weight=x;
    	}
    }
    
    bool cmp(temp a,temp b){
    	//用于排序的比较函数
    	return a.weight<b.weight;
    }
    
    void SelectMin(HuffmanTree T,int k,int *p1,int *p2){
    	//在前k个结点中选择权值最小和次小的根结点,其序号分别为p1和p2
    	temp x[m];			  //x向量为temp类型的向量
    	int i,j;
    	for(i=0,j=0;i<=k;i++){  //寻找最小和次小根节点的过程
    		if(T[i].parent==-1){//如果是根节点,则进行如下操作
    			x[j].id=i;	  //将该根节点的序号赋值给x
    			x[j].weight=T[i].weight;//将该根节点的权值赋值给x
    			j++;			//x向量的指针后移一位
    		}
    	}
    	sort(x,x+j,cmp);		//对x按照权值从小到大排序
    	//排序后的x向量的第一和第二个位置中存储的id是所找的根节点的序号值
    	*p1=x[0].id;
    	*p2=x[1].id;
    }
    
    void CreateHuffmanTree(HuffmanTree T){
    	//构造哈夫曼树,T[m-1]为其根结点
    	int i,p1,p2;
    	InitHuffmanTree(T);	//将T初始化
    	InputWeight(T);		//输入叶子权值
    	for(i=n;i<m;i++){
    		//在当前森林T[0..i-1]的所有结点中,选取权最小和次小的
    		//两个根结点T[p1]和T[p2]作为合并对象
    		//共进行n-1次合并,新结点依次存于T[i]中
    
    		SelectMin(T,i-1,&p1,&p2);//选择权值最小和次小的根结点,其序号分别为p1和p2
    
    		//将根为T[p1]和T[p2]的两棵树作为左右子树合并为一棵新的树
    		//新树的根是新结点T[i]
    		T[p1].parent=T[p2].parent=i;//T[p1]和T[p2]的两棵树的根结点指向i
    		T[i].lchild=p1;			 //最小权的根结点是新结点的左孩子
    		T[i].rchild=p2;			 //次小权的根结点是新结点的右孩子
    		T[i].weight=T[p1].weight+T[p2].weight;//新结点的权值是左右子树的权值之和
    	}
    }
    
    void CharSetHuffmanEncoding(HuffmanTree T,HuffmanCode H){
    	//根据哈夫曼树T求哈夫曼编码表H
    	int c,p;//c和p分别指示T中孩子和双亲的位置
    	char cd[n+1];//临时存放编码
    	int start;//指示编码在cd中的起始位置
    	cd[n]='\0';//编码结束符
    	getchar();
    	for(int i=0;i<n;i++){//依次求叶子T[i]的编码
    		H[i].ch=getchar();//读入叶子T[i]对应的字符
    		start=n;//编码起始位置的初值
    		c=i;//从叶子T[i]开始上溯
    		while((p=T[c].parent)>=0){//直至上溯到T[c]是树根为止
    			//若T[c]是T[p]的左孩子,则生成代码0;否则生成代码1
    			if(T[p].lchild==c)
    				cd[--start]='0';
    			else
    				cd[--start]='1';
    			c=p;//继续上溯
    		}
    		strcpy(H[i].bits,&cd[start]);//复制编码位串
    	}
    }
    
    //*************************测试函数**********************************
    int main(){
    	HuffmanTree T;
    	HuffmanCode H;
    	printf("请输入%d个叶子结点的权值来建立哈夫曼树:\n",n);
    	CreateHuffmanTree(T);
    	printf("请输入%d个叶子结点所代表的字符:\n",n);
    	CharSetHuffmanEncoding(T,H);
    	printf("哈夫曼树已经建好,哈夫曼编码已经完成,输出如下:\n");
    	printf("哈夫曼树:\n");
    	for(int i=0;i<m;i++){
    		printf("id:%d  weight:%.1lf   parent:%d",i,T[i].weight,T[i].parent);
    		printf("  lchild:%d rchild:%d\n",T[i].lchild,T[i].rchild);
    	}
    	printf("哈夫曼编码:\n");
    	double wpl=0.0;
    	for(int i=0;i<n;i++){
    		printf("id:%d   ch:%c  code:%s\n",i,H[i].ch,H[i].bits);
    		wpl+=strlen(H[i].bits)*T[i].weight;
    	}
    	printf("平均码长为:%.2lf\n",wpl);
    	return 0;
    }
    测试样例及预测运行结果:(表中和图中的权重数值weight均需要乘以0.01)

    运行结果:

    展开全文
  • 最优前缀编码

    2020-05-18 22:04:07
    所谓最优前缀码是指,平均码长或文件总长最小的前缀编码称为最优的前缀码(这里的平均码长相当于码长的期望值)。 1.每叶子字符ci的码长恰为从根到该叶子的路径长度li,平均码长(或文件总长)又是二叉树的带权路径...

    1、问题

    给定字符集C={x1,x2,…,xn}和每个字符的频率f(xi),求关于C的一个最优前缀码。

    2、解析

    由哈夫曼树求得的编码为最优前缀码。每个叶子表示的字符的编码,就是从根到叶子的路径上的标号依次相连所形成的编码,显然这就是该字符的最优前缀码。所谓前缀码是指,对字符集进行编码时,要求字符集中任一字符的编码都不是其它字符的编码的前缀,比如常见的等长编码就是前缀码。所谓最优前缀码是指,平均码长或文件总长最小的前缀编码称为最优的前缀码(这里的平均码长相当于码长的期望值)。

    1.每个叶子字符ci的码长恰为从根到该叶子的路径长度li,平均码长(或文件总长)又是二叉树的带权路径长度WPL.而哈夫曼树是WPL最小的二叉树,因此编码的平均码长亦最小。
    2.树中没有一片叶子是另一个叶子的祖先,每片叶子对应的编码就不可能是其它叶子编码的前缀。

    构造方法:用被编码的字符作为叶子,构造二叉树,然后在二叉树的左分支上标“0”,右分支标“1”(或反过来),每个字符的编码就是从根到该字符叶子所经路径上的0,1序列.
    例如:有a、b、c、d、e 5个字符。
    在这里插入图片描述
    二叉树结构存储:
    例如:
    前缀码及其频率:00000:5%,00001:5%,0001:10%,001:15%,01:25%,100:10%,101:10%,11:10%。
    二叉树如下:
    在这里插入图片描述

    3、设计

    void CreateHuffmanTree(HuffmanTree T){
        //构造哈夫曼树,T[m-1]为其根结点
        int i,p1,p2;
        InitHuffmanTree(T);    //将T初始化
        InputWeight(T);        //输入叶子权值
        for(i=n;i<m;i++){
            //在当前森林T[0..i-1]的所有结点中,选取权最小和次小的
            //两个根结点T[p1]和T[p2]作为合并对象
            //共进行n-1次合并,新结点依次存于T[i]中
     
            SelectMin(T,i-1,&p1,&p2);//选择权值最小和次小的根结点,其序号分别为p1和p2
     
            //将根为T[p1]和T[p2]的两棵树作为左右子树合并为一棵新的树
            //新树的根是新结点T[i]
            T[p1].parent=T[p2].parent=i;//T[p1]和T[p2]的两棵树的根结点指向i
            T[i].lchild=p1;             //最小权的根结点是新结点的左孩子
            T[i].rchild=p2;             //次小权的根结点是新结点的右孩子
            T[i].weight=T[p1].weight+T[p2].weight;//新结点的权值是左右子树的权值之和
        }
    }
    
    void CharSetHuffmanEncoding(HuffmanTree T,HuffmanCode H){
        //根据哈夫曼树T求哈夫曼编码表H
        int c,p;//c和p分别指示T中孩子和双亲的位置
        char cd[n+1];//临时存放编码
        int start;//指示编码在cd中的起始位置
        cd[n]='\0';//编码结束符
        getchar();
        for(int i=0;i<n;i++){//依次求叶子T[i]的编码
            H[i].ch=getchar();//读入叶子T[i]对应的字符
            start=n;//编码起始位置的初值
            c=i;//从叶子T[i]开始上溯
            while((p=T[c].parent)>=0){//直至上溯到T[c]是树根为止
                //若T[c]是T[p]的左孩子,则生成代码0;否则生成代码1
                if(T[p].lchild==c)
                    cd[--start]='0';
                else
                    cd[--start]='1';
                c=p;//继续上溯
            }
            strcpy(H[i].bits,&cd[start]);//复制编码位串
        }
    }
    

    4、分析

    在这里插入图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,356
精华内容 44,142
关键字:

五个字符前缀编码