Question

我正在将一个算法从Java移植到Scala，它在VP Tree上进行范围搜索。简而言之，树中的节点具有空间坐标和半径：该半径内的节点可以在左子树上找到，而该半径外的节点可以在右子树上找到。范围搜索尝试在查询对象的指定距离内查找树中的所有对象。

在Java中，我传递了一个arraylist函数，它在其中累积了结果，可能会递归其中一个或两个子树。这是Scala的直接端口：

def search(node: VPNode[TPoint, TObject], query: TPoint, radius: Double,
    results: collection.mutable.Set[TObject]) {

  var dist = distance(query, node.point)

  if (dist < radius)
    results += node.obj

  if (node.left != null && dist <= radius + node.radius)
    search(node.left, query, radius, results)

  if (node.right != null && dist >= radius + node.radius)
    search(node.right, query, radius, results)
}

Scala的默认集合类型是不可变的，我认为必须一直输入collection.mutable.有点烦人，所以我开始研究它。似乎建议使用不可变集合几乎总是好的：虽然我使用这个代码进行数百万次查找，但在我看来，复制和连接结果数组会降低它的速度。

例如this等答案表明，问题需要更多地“功能性”接近。

那么，我应该怎么做才能以更加Scala风格的方式解决这个问题呢？理想情况下，我希望它与Java版本一样快，但我对解决方案感兴趣（并且可以随时对它们进行分析以确定它是否有很大差异）。

请注意，我刚刚开始学习Scala（想想我可能会对有用的东西不屑一顾）但我不熟悉函数式编程，之前曾使用过Haskell（尽管我不认为我那么好在它！）。

Answer 1

这是我认为更具功能性的方法：

val emptySet = Set[TObject]()

def search(node: VPNode[TPoint, TObject], query: TPoint, radius: Double): Set[TObject] = {
  val dist = distance(query, node.point)

  val left = Option(node.left) // avoid nulls
    .filter(_ => dist <= radius + node.radius) // do nothing if predicate fails
    .fold(emptySet)(l => search(l, query, radius)) // continue your search

  val right = Option(node.right)
    .filter(_ => dist >= radius + node.radius)
    .fold(emptySet)(r => search(r, query, radius))

  left ++ right ++ (if (dist < radius) Set(node.obj) else emptySet)
}

mutable.Set函数返回search，然后将其连接到其他集合，而不是将search传递给每个Set[TObject]函数。如果要构建函数调用，看起来树的每个节点都在相互连接（假设它们在你的半径范围内）。

从效率的角度来看，这可能不如可变版本那么有效。使用List代替Set可能会更好，然后您可以在完成后将最终List转换为Set（尽管可能仍然不是禁食作为可变版本。）

<强>更新回答你关于好处的问题：

确定性 - 由于它是不可变的，因此在使用相同的参数调用此函数时，始终可以保证相同的结果。话虽如此，你原来的版本应该是确定性的，你只是不知道还有谁在修改你的结果，尽管这可能不是什么大问题。
难以阅读？ - 我认为这更多的是关于不同风格的编程的观点和经验问题。我发现您的版本难以阅读，因为您没有从函数返回任何值，并且您有多个if语句。我同意，首先Option / filter / fold看起来有点奇怪，但是在你开始使用它们一段时间后（就像任何东西一样）它变得容易阅读。我会将其与能够在.NET中读取LINQ进行比较。
性能 - 使用@ {huynhjl使用List的答案，如果不是原始版本的更好性能，你应该得到平等。您似乎并不需要使用Set，其中的开销是确保集合中的所有内容都是唯一的。
垃圾收集 - 在纯功能版本中，您可以快速创建新对象并快速删除它们，这意味着它们很可能无法在GC第一代之后存活。这很重要，因为在代之间移动对象会导致GC暂停。在可变版本中，您传递的是对原始集合的引用，该集合会挂起更长时间并可能会压缩到下一代。这不是最好的例子，因为你的可变版本可能不是那么长寿，谁知道你想对返回对象做什么（可能会保留一段时间）。在可变版本中，你最有可能最终得到指向第二代对象的第二代集合，而不可变版本最终会有第一代集合指向第二代对象。清理不可变版本将更快，更少暂停（再次，这是对您的对象的使用和GC正在做什么做出一些广泛的假设和概括，您的里程可能会有所不同）。
并行性 - 功能版本可以轻松并行化，而可变版本则不能。根据树的大小，这可能不是一个大问题。

由于您似乎很感兴趣，我建议您阅读Functional Programming in Scala。我认为这对初学者来说是一个很好的方式，它涵盖了所有这些基础知识。

Answer 2

我想知道你是否会通过使用标准的不可变List来获得良好的性能。所有search所做的就是一次检查一个节点并在满足某些条件时追加当前元素，然后进行双递归。所以你可以使用一个不可变的累加器：

def search(node: VPNode[TPoint, TObject], query: TPoint, radius: Double,
    acc: List[TObject] = Nil): List[TObject] = {

  val dist = distance(query, node.point)
  val mid = if (dist < radius) node.obj :: acc else acc

  val midLeft =
    if (node.left != null && dist <= radius + node.radius)
      search(node.left, query, radius, mid)
    else mid

  if (node.right != null && dist >= radius + node.radius)
    search(node.right, query, radius, midLeft)
  else midLeft
}

据我所知，这仅限于累加器的开头，应该很快。

请注意，我认为在内部使用可变集合并将不可变集合返回给调用者是可以的：

def search(node: VPNode[TPoint, TObject], query: TPoint, radius: Double): Vector[TObject] = {
  import collection.immutable.{VectorBuilder => Builder}
  def rec(n: VPNode[TPoint, TObject], acc: Builder[TObject]): Builder[TObject] = {
    val dist = distance(query, node.point)
    val mid = if (dist < radius) acc += node.obj
    if (node.left != null && dist <= radius + node.radius) rec(node.left, acc)
    if (node.right != null && dist >= radius + node.radius) rec(node.right, acc)
    acc
  }
  rec(node, new Builder()).result
}

在Scala中创建更多“功能”代码以使用不可变集合

2 个答案: