Question

我正在创建一个更快的字符串拆分器方法。首先，我写了一个返回List的非尾递归版本。接下来，使用ListBuffer然后调用toList（+=和toList的尾递归者是O（1））。我完全期望尾递归版本更快，但事实并非如此。

任何人都可以解释原因吗？

原始版本：

def split(s: String, c: Char, i: Int = 0): List[String] = if (i < 0) Nil else {
  val p = s indexOf (c, i)
  if (p < 0) s.substring(i) :: Nil else s.substring(i, p) :: split(s, c, p + 1)
}

尾递归：

import scala.annotation.tailrec
import scala.collection.mutable.ListBuffer
def split(s: String, c: Char): Seq[String] = {
  val buffer = ListBuffer.empty[String]
  @tailrec def recurse(i: Int): Seq[String] =  {
    val p = s indexOf (c, i)
    if (p < 0) {
      buffer += s.substring(i)
      buffer.toList
    } else {
      buffer += s.substring(i, p)
      recurse(p + 1)
    }
  }
  recurse(0)
}

这是使用代码here进行基准测试，结果为here，＃scala的jyxent。

Answer 1

你只是在第二种情况下做更多工作。在第一种情况下，您可能会溢出堆栈，但每个操作都非常简单，::与您可以获得的包装器一样小（您只需要创建包装器并将其指向头部）另一个清单）。在第二种情况下，您不仅最初创建了一个额外的集合，而且必须围绕s和buffer形成一个闭包，以供嵌套方法使用，但您也使用较重的ListBuffer必须检查每个+=是否已经被复制到列表中，并根据它是否为空而使用不同的代码路径（为了使O(1)追加工作）。 / p>

Answer 2

由于尾部调用优化，您希望尾递归版本更快，如果您将苹果与苹果进行比较，我认为这是正确的：

def split3(s: String, c: Char): Seq[String] = {
  @tailrec def recurse(i: Int, acc: List[String] = Nil): Seq[String] =  {
    val p = s indexOf (c, i)
    if (p < 0) {
      s.substring(i) :: acc
    } else {
      recurse(p + 1, s.substring(i, p) :: acc)
    }
  }
  recurse(0) // would need to reverse
}

我将此split3定时更快，当然除了获得扭转结果所需的相同结果。

似乎ListBuffer引入了尾递归优化无法弥补的低效率。

编辑：考虑避免反向...

def split3(s: String, c: Char): Seq[String] = {
  @tailrec def recurse(i: Int, acc: List[String] = Nil): Seq[String] =  {
    val p = s lastIndexOf (c, i)
    if (p < 0) {
      s.substring(0, i + 1) :: acc
    } else {
      recurse(p - 1, s.substring(p + 1, i + 1) :: acc)
    }
  }
  recurse(s.length - 1)
}

这具有尾调用优化并避免ListBuffer。

为什么尾递归不能在此代码中获得更好的性能？

2 个答案: