快速霍夫曼解码

Question

我在 Scala 中编写了一个霍夫曼压缩/解压缩。解码小文件时需要几秒钟，但解码大文件时需要很长时间。关于如何加快此过程的任何建议？

def lookup(list:List[Int],list2:List[(Char,List[Int])]): Option[String]={
  val mutableListBuffer = scala.collection.mutable.ArrayBuffer(list2: _*)
  var option:Option[String]= None
  for(i <- 0 until mutableListBuffer.length){  
    if(mutableListBuffer(i)._2 == list){
      option =  Some(mutableListBuffer(i)._1.toString)         
    }
  }
  option
}

/*
*Decode function for matching groups of bits in a list to characters    in     the HCodeMap
*@returns String
*/
def decode(acc:Int,s:String,list:(List[Int],List[(Char,List[Int])])):String ={
  var s = ""
  var accum = 1
  val listp1 = scala.collection.mutable.ArrayBuffer(list._1: _*)
  val listp2 = scala.collection.mutable.ArrayBuffer(list._2: _*)
  var tupList = (listp1,listp2)

  while(!tupList._1.isEmpty){
    if(lookup(tupList._1.take(accum).toList,tupList._2.toList).isDefined){
      println(accum)
      s = s ++ lookup(tupList._1.take(accum).toList,tupList._2.toList).getOrElse("a")
      Log.d("MyTAG", "de" + s)  
      tupList._1.remove(0,accum)
      accum = accum - accum + 1
    }
    else{
      accum =  accum + 1
    }        
  }
  s
}

代码在 Android 设备上执行，因此使用递归不是一个有效的选项，使用不可变列表也不是。任何建议将不胜感激。再次感谢。

Answer 1

如果你想让它快一点，那你的出发点就错了。您应该直接使用位流，而不是每个整数包含一位的整数列表。您在某处浪费时间将传入的位转换为整数列表，然后浪费大量时间解码该列表。

制作快速霍夫曼解码器的一种方法是构建允许直接索引查找的解码表。选择一些比特，n，这将是一个统一代码的长度。例如。如果你有 256 个符号，让我们从 n 开始作为 8 个。 （您可以稍后再弄乱 n 以优化速度。）

现在构建一个包含 256 个条目的表，该表由接下来的 8 位输入索引。每个条目表示a) 下一个代码为8 位或更少，或b) 下一个代码的长度为9 位或更多。对于 a)，该表告诉您代码中的位数及其解码为的符号。在这种情况下，您从流中删除那么多位并发出符号。

对于 b) 表指向下一个表以用后续位和多少位进行索引。然后，您从流中丢弃八位并索引子表，该子表也将指示 a) 或 b)。虽然可能两级表是最佳的，但子表将始终指示 a)，完成解码并发出符号。在这种情况下，子表的大小（即索引中的位数）是最长代码的长度减去八，它具有索引主表的八位前缀。

这些表构建起来很简单，构建一次就可以多次使用，因此构建时间非常值得。表中的条目经常重复多次。例如。一个四位代码将在基本八位表中重复 16 次。

您将在位缓冲区（一个整数）上使用位操作，根据需要从流中提取字节，以保持其加载足够的位以形成下一个索引。简单的位移会在使用时将位向下移动，而输入字节的位移会在或将它们放入位缓冲区之前完成。

一旦一切正常，您可以改变 n 并使用代表性输入为解码器计时，以找到 n 的最佳值。

Answer 2

这可能属于 codereview，但我认为这里的代码与您的代码直接等效，无需任何转换为​​ ArrayBuffers（这不是必需的）。列表操作是相当有效的，只是采取和删除，以及列表遍历，所以我认为你在错误的方向上指责不可变列表。

def lookup(list: List[Int], list2: List[(Char, List[Int])]): Option[String] = 
 list2.find(_._2 == list).map(_._1.toString)

/*
*Decode function for matching groups of bits in a list to characters    in     the HCodeMap
*@returns String
*/

 def decode(s: String, list: (List[Int], List[(Char, List[Int])])): String = {

  var s = ""
  var accum = 1
  var listp1 = list._1
  val listp2 = list._2

  while (!listp1.isEmpty) {

    lookup(listp1.take(accum), listp2) match {
      case Some(m) =>
        println(accum)
        s = s ++ m
        Log.d("MyTAG", "de" + s)
        listp1 = listp1.drop(accum)
        accum = 1
      case None =>
        accum = accum + 1
    }
  }
  s
}