Huffman编码算法之Java实现

最新推荐文章于 2022-08-12 08:58:45 发布
最新推荐文章于 2022-08-12 08:58:45 发布
阅读量77 收藏 1
点赞数
文章标签： java 数据结构与算法

目录(?)[+]

Huffman编码介绍

Huffman编码处理的是字符以及字符对应的二进制的编码配对问题，分为编码和解码，目的是压缩字符对应的二进制数据长度。我们知道字符存贮和传输的时候都是二进制的(计算机只认识0/1)，那么就有字符与二进制之间的mapping关系。字符属于字符集(Charset), 字符需要通过编码(encode)为二进制进行存贮和传输，显示的时候需要解码(decode)回字符，字符集与编码方法是一对多关系(Unicode可以用UTF-8,UTF-16等编码)。理解了字符集，编码以及解码，满天飞的乱码问题也就游刃而解了。以英文字母小写a为例, ASCII编码中，十进制为97，二进制为01100001。ASCII的每一个字符都用8个Bit(1Byte)编码，假如有1000个字符要传输，那么就要传输8000个Bit。问题来了，英文中字母e的使用频率为12.702%，而z为0.074%，前者是后者的100多倍，但是确使用相同位数的二进制。可以做得更好，方法就是可变长度编码，指导原则就是频率高的用较短的位数编码，频率低的用较长位数编码。Huffman编码算法就是处理这样的问题。

Huffman编码Java实现

Huffman编码算法主要用到的数据结构是完全二叉树(full binary tree)和优先级队列。后者用的是java.util.PriorityQueue，前者自己实现(都为内部类)，代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. staticclassTree{
  2. privateNoderoot;
  4. publicNodegetRoot(){
  5. returnroot;
  6. }
  8. publicvoidsetRoot(Noderoot){
  9. this.root=root;
  10. }
  11. }
  13. staticclassNodeimplementsComparable<Node>{
  14. privateStringchars="";
  15. privateintfrequence=0;
  16. privateNodeparent;
  17. privateNodeleftNode;
  18. privateNoderightNode;
  20. @Override
  21. publicintcompareTo(Noden){
  22. returnfrequence-n.frequence;
  23. }
  25. publicbooleanisLeaf(){
  26. returnchars.length()==1;
  27. }
  29. publicbooleanisRoot(){
  30. returnparent==null;
  31. }
  33. publicbooleanisLeftChild(){
  34. returnparent!=null&&this==parent.leftNode;
  35. }
  37. publicintgetFrequence(){
  38. returnfrequence;
  39. }
  41. publicvoidsetFrequence(intfrequence){
  42. this.frequence=frequence;
  43. }
  45. publicStringgetChars(){
  46. returnchars;
  47. }
  49. publicvoidsetChars(Stringchars){
  50. this.chars=chars;
  51. }
  53. publicNodegetParent(){
  54. returnparent;
  55. }
  57. publicvoidsetParent(Nodeparent){
  58. this.parent=parent;
  59. }
  61. publicNodegetLeftNode(){
  62. returnleftNode;
  63. }
  65. publicvoidsetLeftNode(NodeleftNode){
  66. this.leftNode=leftNode;
  67. }
  69. publicNodegetRightNode(){
  70. returnrightNode;
  71. }
  73. publicvoidsetRightNode(NoderightNode){
  74. this.rightNode=rightNode;
  75. }
  76. }

统计数据

既然要按频率来安排编码表，那么首先当然得获得频率的统计信息。我实现了一个方法处理这样的问题。如果已经有统计信息，那么转为Map<Character,Integer>即可。如果你得到的信息是百分比，乘以100或1000，或10000。总是可以转为整数。比如12.702%乘以1000为12702，Huffman编码只关心大小问题。统计方法实现如下：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticMap<Character,Integer>statistics(char[]charArray){
  2. Map<Character,Integer>map=newHashMap<Character,Integer>();
  3. for(charc:charArray){
  4. Charactercharacter=newCharacter(c);
  5. if(map.containsKey(character)){
  6. map.put(character,map.get(character)+1);
  7. }else{
  8. map.put(character,1);
  9. }
  10. }
  12. returnmap;
  13. }

构建树

构建树是Huffman编码算法的核心步骤。思想是把所有的字符挂到一颗完全二叉树的叶子节点，任何一个非页子节点的左节点出现频率不大于右节点。算法为把统计信息转为Node存放到一个优先级队列里面，每一次从队列里面弹出两个最小频率的节点，构建一个新的父Node(非叶子节点), 字符内容刚弹出来的两个节点字符内容之和，频率也是它们的和，最开始的弹出来的作为左子节点，后面一个作为右子节点，并且把刚构建的父节点放到队列里面。重复以上的动作N-1次，N为不同字符的个数(每一次队列里面个数减1)。结束以上步骤，队列里面剩一个节点，弹出作为树的根节点。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. privatestaticTreebuildTree(Map<Character,Integer>statistics,
  2. List<Node>leafs){
  3. Character[]keys=statistics.keySet().toArray(newCharacter[0]);
  5. PriorityQueue<Node>priorityQueue=newPriorityQueue<Node>();
  6. for(Charactercharacter:keys){
  7. Nodenode=newNode();
  8. node.chars=character.toString();
  9. node.frequence=statistics.get(character);
  10. priorityQueue.add(node);
  11. leafs.add(node);
  12. }
  14. intsize=priorityQueue.size();
  15. for(inti=1;i<=size-1;i++){
  16. Nodenode1=priorityQueue.poll();
  17. Nodenode2=priorityQueue.poll();
  19. NodesumNode=newNode();
  20. sumNode.chars=node1.chars+node2.chars;
  21. sumNode.frequence=node1.frequence+node2.frequence;
  23. sumNode.leftNode=node1;
  24. sumNode.rightNode=node2;
  26. node1.parent=sumNode;
  27. node2.parent=sumNode;
  29. priorityQueue.add(sumNode);
  30. }
  32. Treetree=newTree();
  33. tree.root=priorityQueue.poll();
  34. returntree;
  35. }

编码

某个字符对应的编码为，从该字符所在的叶子节点向上搜索，如果该字符节点是父节点的左节点，编码字符之前加0，反之如果是右节点，加1，直到根节点。只要获取了字符和二进制码之间的mapping关系，编码就非常简单。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticStringencode(StringoriginalStr,
  2. Map<Character,Integer>statistics){
  3. if(originalStr==null||originalStr.equals("")){
  4. return"";
  5. }
  7. char[]charArray=originalStr.toCharArray();
  8. List<Node>leafNodes=newArrayList<Node>();
  9. buildTree(statistics,leafNodes);
  10. Map<Character,String>encodInfo=buildEncodingInfo(leafNodes);
  12. StringBufferbuffer=newStringBuffer();
  13. for(charc:charArray){
  14. Charactercharacter=newCharacter(c);
  15. buffer.append(encodInfo.get(character));
  16. }
  18. returnbuffer.toString();
  19. }
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. privatestaticMap<Character,String>buildEncodingInfo(List<Node>leafNodes){
  2. Map<Character,String>codewords=newHashMap<Character,String>();
  3. for(NodeleafNode:leafNodes){
  4. Charactercharacter=newCharacter(leafNode.getChars().charAt(0));
  5. Stringcodeword="";
  6. NodecurrentNode=leafNode;
  8. do{
  9. if(currentNode.isLeftChild()){
  10. codeword="0"+codeword;
  11. }else{
  12. codeword="1"+codeword;
  13. }
  15. currentNode=currentNode.parent;
  16. }while(currentNode.parent!=null);
  18. codewords.put(character,codeword);
  19. }
  21. returncodewords;
  22. }

解码

因为Huffman编码算法能够保证任何的二进制码都不会是另外一个码的前缀，解码非常简单，依次取出二进制的每一位，从树根向下搜索，1向右，0向左，到了叶子节点(命中)，退回根节点继续重复以上动作。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticStringdecode(StringbinaryStr,
  2. Map<Character,Integer>statistics){
  3. if(binaryStr==null||binaryStr.equals("")){
  4. return"";
  5. }
  7. char[]binaryCharArray=binaryStr.toCharArray();
  8. LinkedList<Character>binaryList=newLinkedList<Character>();
  9. intsize=binaryCharArray.length;
  10. for(inti=0;i<size;i++){
  11. binaryList.addLast(newCharacter(binaryCharArray[i]));
  12. }
  14. List<Node>leafNodes=newArrayList<Node>();
  15. Treetree=buildTree(statistics,leafNodes);
  17. StringBufferbuffer=newStringBuffer();
  19. while(binaryList.size()>0){
  20. Nodenode=tree.root;
  22. do{
  23. Characterc=binaryList.removeFirst();
  24. if(c.charValue()=='0'){
  25. node=node.leftNode;
  26. }else{
  27. node=node.rightNode;
  28. }
  29. }while(!node.isLeaf());
  31. buffer.append(node.chars);
  32. }
  34. returnbuffer.toString();
  35. }

测试以及比较

以下测试Huffman编码的正确性(先编码，后解码，包括中文)，以及Huffman编码与常见的字符编码的二进制字符串比较。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticvoidmain(String[]args){
  2. StringoriStr="Huffmancodescompressdataveryeffectively:savingsof20%to90%aretypical,"
  3. +"dependingonthecharacteristicsofthedatabeingcompressed.中华崛起";
  4. Map<Character,Integer>statistics=statistics(oriStr.toCharArray());
  5. StringencodedBinariStr=encode(oriStr,statistics);
  6. StringdecodedStr=decode(encodedBinariStr,statistics);
  8. System.out.println("Originalsstring:"+oriStr);
  9. System.out.println("Huffmanencoedbinarystring:"+encodedBinariStr);
  10. System.out.println("decodedstringfrombinariystring:"+decodedStr);
  12. System.out.println("binarystringofUTF-8:"
  13. +getStringOfByte(oriStr,Charset.forName("UTF-8")));
  14. System.out.println("binarystringofUTF-16:"
  15. +getStringOfByte(oriStr,Charset.forName("UTF-16")));
  16. System.out.println("binarystringofUS-ASCII:"
  17. +getStringOfByte(oriStr,Charset.forName("US-ASCII")));
  18. System.out.println("binarystringofGB2312:"
  19. +getStringOfByte(oriStr,Charset.forName("GB2312")));
  20. }
  22. publicstaticStringgetStringOfByte(Stringstr,Charsetcharset){
  23. if(str==null||str.equals("")){
  24. return"";
  25. }
  27. byte[]byteArray=str.getBytes(charset);
  28. intsize=byteArray.length;
  29. StringBufferbuffer=newStringBuffer();
  30. for(inti=0;i<size;i++){
  31. bytetemp=byteArray[i];
  32. buffer.append(getStringOfByte(temp));
  33. }
  35. returnbuffer.toString();
  36. }
  38. publicstaticStringgetStringOfByte(byteb){
  39. StringBufferbuffer=newStringBuffer();
  40. for(inti=7;i>=0;i--){
  41. bytetemp=(byte)((b>>i)&0x1);
  42. buffer.append(String.valueOf(temp));
  43. }
  45. returnbuffer.toString();
  46. }

Huffman编码介绍

Huffman编码处理的是字符以及字符对应的二进制的编码配对问题，分为编码和解码，目的是压缩字符对应的二进制数据长度。我们知道字符存贮和传输的时候都是二进制的(计算机只认识0/1)，那么就有字符与二进制之间的mapping关系。字符属于字符集(Charset), 字符需要通过编码(encode)为二进制进行存贮和传输，显示的时候需要解码(decode)回字符，字符集与编码方法是一对多关系(Unicode可以用UTF-8,UTF-16等编码)。理解了字符集，编码以及解码，满天飞的乱码问题也就游刃而解了。以英文字母小写a为例, ASCII编码中，十进制为97，二进制为01100001。ASCII的每一个字符都用8个Bit(1Byte)编码，假如有1000个字符要传输，那么就要传输8000个Bit。问题来了，英文中字母e的使用频率为12.702%，而z为0.074%，前者是后者的100多倍，但是确使用相同位数的二进制。可以做得更好，方法就是可变长度编码，指导原则就是频率高的用较短的位数编码，频率低的用较长位数编码。Huffman编码算法就是处理这样的问题。

Huffman编码Java实现

Huffman编码算法主要用到的数据结构是完全二叉树(full binary tree)和优先级队列。后者用的是java.util.PriorityQueue，前者自己实现(都为内部类)，代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. staticclassTree{
  2. privateNoderoot;
  4. publicNodegetRoot(){
  5. returnroot;
  6. }
  8. publicvoidsetRoot(Noderoot){
  9. this.root=root;
  10. }
  11. }
  13. staticclassNodeimplementsComparable<Node>{
  14. privateStringchars="";
  15. privateintfrequence=0;
  16. privateNodeparent;
  17. privateNodeleftNode;
  18. privateNoderightNode;
  20. @Override
  21. publicintcompareTo(Noden){
  22. returnfrequence-n.frequence;
  23. }
  25. publicbooleanisLeaf(){
  26. returnchars.length()==1;
  27. }
  29. publicbooleanisRoot(){
  30. returnparent==null;
  31. }
  33. publicbooleanisLeftChild(){
  34. returnparent!=null&&this==parent.leftNode;
  35. }
  37. publicintgetFrequence(){
  38. returnfrequence;
  39. }
  41. publicvoidsetFrequence(intfrequence){
  42. this.frequence=frequence;
  43. }
  45. publicStringgetChars(){
  46. returnchars;
  47. }
  49. publicvoidsetChars(Stringchars){
  50. this.chars=chars;
  51. }
  53. publicNodegetParent(){
  54. returnparent;
  55. }
  57. publicvoidsetParent(Nodeparent){
  58. this.parent=parent;
  59. }
  61. publicNodegetLeftNode(){
  62. returnleftNode;
  63. }
  65. publicvoidsetLeftNode(NodeleftNode){
  66. this.leftNode=leftNode;
  67. }
  69. publicNodegetRightNode(){
  70. returnrightNode;
  71. }
  73. publicvoidsetRightNode(NoderightNode){
  74. this.rightNode=rightNode;
  75. }
  76. }

统计数据

既然要按频率来安排编码表，那么首先当然得获得频率的统计信息。我实现了一个方法处理这样的问题。如果已经有统计信息，那么转为Map<Character,Integer>即可。如果你得到的信息是百分比，乘以100或1000，或10000。总是可以转为整数。比如12.702%乘以1000为12702，Huffman编码只关心大小问题。统计方法实现如下：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticMap<Character,Integer>statistics(char[]charArray){
  2. Map<Character,Integer>map=newHashMap<Character,Integer>();
  3. for(charc:charArray){
  4. Charactercharacter=newCharacter(c);
  5. if(map.containsKey(character)){
  6. map.put(character,map.get(character)+1);
  7. }else{
  8. map.put(character,1);
  9. }
  10. }
  12. returnmap;
  13. }

构建树

构建树是Huffman编码算法的核心步骤。思想是把所有的字符挂到一颗完全二叉树的叶子节点，任何一个非页子节点的左节点出现频率不大于右节点。算法为把统计信息转为Node存放到一个优先级队列里面，每一次从队列里面弹出两个最小频率的节点，构建一个新的父Node(非叶子节点), 字符内容刚弹出来的两个节点字符内容之和，频率也是它们的和，最开始的弹出来的作为左子节点，后面一个作为右子节点，并且把刚构建的父节点放到队列里面。重复以上的动作N-1次，N为不同字符的个数(每一次队列里面个数减1)。结束以上步骤，队列里面剩一个节点，弹出作为树的根节点。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. privatestaticTreebuildTree(Map<Character,Integer>statistics,
  2. List<Node>leafs){
  3. Character[]keys=statistics.keySet().toArray(newCharacter[0]);
  5. PriorityQueue<Node>priorityQueue=newPriorityQueue<Node>();
  6. for(Charactercharacter:keys){
  7. Nodenode=newNode();
  8. node.chars=character.toString();
  9. node.frequence=statistics.get(character);
  10. priorityQueue.add(node);
  11. leafs.add(node);
  12. }
  14. intsize=priorityQueue.size();
  15. for(inti=1;i<=size-1;i++){
  16. Nodenode1=priorityQueue.poll();
  17. Nodenode2=priorityQueue.poll();
  19. NodesumNode=newNode();
  20. sumNode.chars=node1.chars+node2.chars;
  21. sumNode.frequence=node1.frequence+node2.frequence;
  23. sumNode.leftNode=node1;
  24. sumNode.rightNode=node2;
  26. node1.parent=sumNode;
  27. node2.parent=sumNode;
  29. priorityQueue.add(sumNode);
  30. }
  32. Treetree=newTree();
  33. tree.root=priorityQueue.poll();
  34. returntree;
  35. }

编码

某个字符对应的编码为，从该字符所在的叶子节点向上搜索，如果该字符节点是父节点的左节点，编码字符之前加0，反之如果是右节点，加1，直到根节点。只要获取了字符和二进制码之间的mapping关系，编码就非常简单。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticStringencode(StringoriginalStr,
  2. Map<Character,Integer>statistics){
  3. if(originalStr==null||originalStr.equals("")){
  4. return"";
  5. }
  7. char[]charArray=originalStr.toCharArray();
  8. List<Node>leafNodes=newArrayList<Node>();
  9. buildTree(statistics,leafNodes);
  10. Map<Character,String>encodInfo=buildEncodingInfo(leafNodes);
  12. StringBufferbuffer=newStringBuffer();
  13. for(charc:charArray){
  14. Charactercharacter=newCharacter(c);
  15. buffer.append(encodInfo.get(character));
  16. }
  18. returnbuffer.toString();
  19. }
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. privatestaticMap<Character,String>buildEncodingInfo(List<Node>leafNodes){
  2. Map<Character,String>codewords=newHashMap<Character,String>();
  3. for(NodeleafNode:leafNodes){
  4. Charactercharacter=newCharacter(leafNode.getChars().charAt(0));
  5. Stringcodeword="";
  6. NodecurrentNode=leafNode;
  8. do{
  9. if(currentNode.isLeftChild()){
  10. codeword="0"+codeword;
  11. }else{
  12. codeword="1"+codeword;
  13. }
  15. currentNode=currentNode.parent;
  16. }while(currentNode.parent!=null);
  18. codewords.put(character,codeword);
  19. }
  21. returncodewords;
  22. }

解码

因为Huffman编码算法能够保证任何的二进制码都不会是另外一个码的前缀，解码非常简单，依次取出二进制的每一位，从树根向下搜索，1向右，0向左，到了叶子节点(命中)，退回根节点继续重复以上动作。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticStringdecode(StringbinaryStr,
  2. Map<Character,Integer>statistics){
  3. if(binaryStr==null||binaryStr.equals("")){
  4. return"";
  5. }
  7. char[]binaryCharArray=binaryStr.toCharArray();
  8. LinkedList<Character>binaryList=newLinkedList<Character>();
  9. intsize=binaryCharArray.length;
  10. for(inti=0;i<size;i++){
  11. binaryList.addLast(newCharacter(binaryCharArray[i]));
  12. }
  14. List<Node>leafNodes=newArrayList<Node>();
  15. Treetree=buildTree(statistics,leafNodes);
  17. StringBufferbuffer=newStringBuffer();
  19. while(binaryList.size()>0){
  20. Nodenode=tree.root;
  22. do{
  23. Characterc=binaryList.removeFirst();
  24. if(c.charValue()=='0'){
  25. node=node.leftNode;
  26. }else{
  27. node=node.rightNode;
  28. }
  29. }while(!node.isLeaf());
  31. buffer.append(node.chars);
  32. }
  34. returnbuffer.toString();
  35. }

测试以及比较

以下测试Huffman编码的正确性(先编码，后解码，包括中文)，以及Huffman编码与常见的字符编码的二进制字符串比较。代码如下:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. publicstaticvoidmain(String[]args){
  2. StringoriStr="Huffmancodescompressdataveryeffectively:savingsof20%to90%aretypical,"
  3. +"dependingonthecharacteristicsofthedatabeingcompressed.中华崛起";
  4. Map<Character,Integer>statistics=statistics(oriStr.toCharArray());
  5. StringencodedBinariStr=encode(oriStr,statistics);
  6. StringdecodedStr=decode(encodedBinariStr,statistics);
  8. System.out.println("Originalsstring:"+oriStr);
  9. System.out.println("Huffmanencoedbinarystring:"+encodedBinariStr);
  10. System.out.println("decodedstringfrombinariystring:"+decodedStr);
  12. System.out.println("binarystringofUTF-8:"
  13. +getStringOfByte(oriStr,Charset.forName("UTF-8")));
  14. System.out.println("binarystringofUTF-16:"
  15. +getStringOfByte(oriStr,Charset.forName("UTF-16")));
  16. System.out.println("binarystringofUS-ASCII:"
  17. +getStringOfByte(oriStr,Charset.forName("US-ASCII")));
  18. System.out.println("binarystringofGB2312:"
  19. +getStringOfByte(oriStr,Charset.forName("GB2312")));
  20. }
  22. publicstaticStringgetStringOfByte(Stringstr,Charsetcharset){
  23. if(str==null||str.equals("")){
  24. return"";
  25. }
  27. byte[]byteArray=str.getBytes(charset);
  28. intsize=byteArray.length;
  29. StringBufferbuffer=newStringBuffer();
  30. for(inti=0;i<size;i++){
  31. bytetemp=byteArray[i];
  32. buffer.append(getStringOfByte(temp));
  33. }
  35. returnbuffer.toString();
  36. }
  38. publicstaticStringgetStringOfByte(byteb){
  39. StringBufferbuffer=newStringBuffer();
  40. for(inti=7;i>=0;i--){
  41. bytetemp=(byte)((b>>i)&0x1);
  42. buffer.append(String.valueOf(temp));
  43. }
  45. returnbuffer.toString();
  46. }
iteye_4639
关注
huffman编码Java实现
xj15291519671的博客
10-17 248
实现思路 huffmantree的创建、压缩和解压 创建思路 1、写一个方法得到对应的String的Byte数组 2、创建一个Node节点： 属性：data(每个数据的asc码) weight(数据出现的次数) left right 继承Comparable 方法:toString(重写toString) preOrder(前序遍历) comparableto(比较大小的方法) 3、方法：将Byte数组转化为map集合（key存储数据，value存储出现的次数） 4、将map集合转化为list 5、对li
huffman 编码 java_Java 实现Huffman 编码算法详解
weixin_28366353的博客
02-12 141
static class Tree {private Node root;public Node getRoot() {return root;}public void setRoot(Node root) {this.root = root;}}static class Node implements Comparable {private String chars = "";private i...
JAVA实现Huffman编码(赫夫曼编码)
小飞的博客
02-17 497
思路： 把字符串转化为字节数组，对字符串中不同字符出现的次数进行统计，统计结果存储到一个Map中 键为字符字节,值为此字符字节在字符串中出现的次数 创建赫夫曼树 读取每一个字符字节的路径方向值，把字符串中的每个字符用路径方向值来表示 把得到的二进制字符串切分为有符号字节存储到字节数组中 打印原字符串，二进制字符串，字节数组   代码如下： //Node类用于创建树结构 publi...
Huffman编码——Java实现
dianzhikun7893的博客
08-21 188
Huffman编码 是一种编码方式，常用于无损压缩。本文只介绍用Java语言来实现该编码方式的算法和数据结构。Huffman编码的核心在于构建一颗最优化的二叉树，首先要得到一个原数据编码中的【编码：频率】的列表，然后根据列表构建二叉树，最后对二叉树编码。 第一步: 计算出每个词（编码）出现的频次，并输出到一个列表 例如字符串："this is an example of a ...
基于Java实现的huffman编码
xiaojing5576的博客
11-18 570
Huffman的应用背景： 在信息的编码中，由于信息表示使用的每个字母的使用频率不一样，若是每个字母都使用相同长度的编码，对于那些用的不多的字符，但是占据空间又较大的字符，就会造成很大的空间浪费，由此，想出了一种新的编码方式，根据字符的使用频率，平率较大的使用较短的编码，反之，使用较大的编码，但是，就又会出现一种新的问题，若是有的字符的编码是另外一个字符的前缀怎么办？例如a的编码是“001”，而b
Huffman编码的java实现
06-13
在Java环境下实现Huffman编码，我们需要理解以下几个关键概念： 1. **字符频率统计**：首先，我们需要统计输入文本中各个字符的出现频率。这个过程可以通过遍历文本并使用HashMap或数组来存储每个字符及其对应的...
Java实现Huffman编码算法详解
"这篇文章主要介绍了如何使用Java实现Huffman编码算法，这是一种用于无损数据压缩的编码技术。文章探讨了Huffman编码的基本概念，强调了它在优化字符频率分布不均时的作用，并提供了相关的Java代码实现。" Huffman...
Java实现Huffman编码与译码
HSBhuang的博客
06-28 1704
一、实验目的 通过实验掌握从文件中读取数据及将运行结果保存到文件中的方法，了解Huffman编码的算法设计及使用Java实现的方法。 二、实验内容 对文件Input.txt中的字符使用Huffman编码进行编码，将编码结果保存到文件Output.txt文件中，最后对Output.txt文件中的字符进行译码。 程序要先统计文件中字符的种类数，每种字符的个数，然后通过Huffman算法计算出各字符的Huffman编码，使用该编码对文件进行编码，并将结果保存到Output.txt文件中。最后对Output.txt
huffman编码java实现
11-14
包含huffman编码java实现源程序、该java程序的javadoc文档、huffman编码简单原理ppt
java实现huffman编码解码
07-09
本程序利用Java实现以下功能： 1、读取一行或多行数据，统计出现的所有字母的出现次数 2、构造huffman树 3、生成出现字母的编码表 4、对输入的数据进行编码输出 5、输入编码结果，对编码结果进行解码，得到原来的输入数据。
java实现huffman算法
05-27
java实现huffman算法 ~可以在控制台输入字符串编码~
哈夫曼编码Java实现
qq_40516377的博客
12-12 1766
哈夫曼编码 1、基本概念 1）一种可变长的前缀编码，常用于数据压缩 2、实现步骤 1）把字符串转换为字符数组，统计出每个字符出现的次数； 2）把每个字符出现的次数作为该字符的权值，每个字符对应的ascii码作为数据； 3）利用每个字符的权值，构建哈夫曼树； 4）根据哈夫曼树，给每个字符编码，向左的路径编码为 0，向右的路径编码为 1； // 构建哈夫曼树 public static Node createHuffmanTree(List<Node> nodes){ while(nodes.si
Java实现哈夫曼编码和解码
tianyaleixiaowu的专栏
08-08 4269
最近无意中想到关于api返回值加密的问题，譬如我们的api需要返回一些比较敏感或者重要不想让截获者得到的信息，像如果是做原创图文的，文章明文返回的话则有可能被抓包者窃取。关于请求时加密的方式比较多，像常见的如阿里某api就是根据所有参数ascii码升序排序并加盐加密，这样能避免黑客篡改请求值。那关于返回值加密的，我觉得用哈夫曼编码就不错。大家都知道哈夫曼是用来做压缩解压的算法，通过哈夫曼压缩后的数
数据结构与算法基础-Huffman Tree(Java)
每天都要加油鸭
04-07 191
public class Node implements Comparable<Node> { int value; Node left; Node right; public Node(int value) { this.value = value; } @Override public int compareTo(Node o) { return -(th...
JAVA:实现Huffman霍夫曼编码算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-12 260
JAVA:实现Huffman霍夫曼编码算法(附完整源码)
Huffman 编码算法之 Java 实现
fh09102103的专栏
10-01 628
Huffman编码介绍 Huffman编码 处理的是字符以及字符对应的二进制的编码配对问题，分为编码和解码，目的是压缩字符对应的二进制数据长度。我们知道字符存贮和传输的时候都是二进制的(计算机只认识0/1)，那么就有字符与二进制之间的mapping关系。字符属于字符集(Charset), 字符需要通过编码(encode)为二进制进行存贮和传输，显示的时候需要解码(decode)回 字符，字符集
哈夫曼算法详解及Java语言实现
chinahyn的博客
04-27 1186
一、哈夫曼编码 哈夫曼编码简介 哈夫曼编码可以有效地压缩数据，通常可以节省20%~90%的空间，具体压缩率依赖于数据的特性。我们将待压缩数据看作字符序列。根据每个字符的出现频率，哈夫曼贪心算法构造出字符最优的二进制表示。 假定我们希望压缩一个十万个字符的数据文件，设文中只有6个不同字符，每个字符的频次、定长编码、变长编码如下表所示： 信息 a b c d e f 频次（千次） 45 13 12 16 9 5 定长编码 000 001 010 011 100 101 导管 0
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值