Question

我正在学习Scala。现在我有了这段代码：

sealed abstract class BSTree {
    def fold[A](init: A)(f: (A, Int) => A): A = this match {
      case Empty => init
      case Node(left, data, right) =>
        val curInorder:A = f(left.fold(init)(f), data)
        right.fold(curInorder)(f)
    }
}

case object Empty extends BSTree
case class Node(left: BSTree, data: Int, right: BSTree) extends BSTree

我的目标是在class BSTree中添加另一个方法toList，它位于顶部方法fold并从二叉树中按顺序遍历构建List。

我目前的实施是：

sealed abstract class BSTree {
    def fold[A](init: A)(f: (A, Int) => A): = .....//code snippet skipped
    def toList: List[Int] =  
             fold(Nil: List[Int])((xs: List[Int], hd)=> hd::xs).reverse
}

但我觉得建立一个List然后扭转它是丑陋的。有更优雅的方法吗？任何提示都表示赞赏。

Answer 1

首先，您的折叠不是尾递归，对于大输入可能会导致StackOverflowException。我鼓励您尝试使用Stack自行实施。作为参考，我将在我的帖子底部放置一个示例实现。

其次，正如评论中已经提到的那样 - 您可能希望使用ListBuffer，以便按相反的顺序构建列表更有效（因此，无需将其反转）。

这是一个单行：

def toList: List[Int] = fold(ListBuffer.empty[Int])(_ += _).toList

实现tail-recursive fold的参考：

def fold[B](init: B)(op: (B, A) => B): B = {
  def go(stack: List[(A, Tree[A])], current: Tree[A], acc: B): B = (current, stack) match {
    case (Empty, Nil) => acc
    case (Empty, (d, r) :: xs) => go(xs, r, op(acc, d))
    case (Node(l, d, r), _) => go((d, r) +: stack, l, acc)
  }

  go(Nil, this, init)
}

Answer 2

我发现仅使用xs :+ hd代替hd::xs会将值放入正确的顺序（深度优先，从左到右）。

val testTree: BSTree =
  Node(Node(Empty, 0, Empty), 1, Node(Empty, 2, Node(Node(Empty, 3, Empty), 4, Empty)))

def toList(bSTree: BSTree): List[Int] =
  bSTree.fold(List[Int]())((acc, next) => acc :+ next)

toList(testTree) // List(0,1,2,3,4)

我上面的实现是 O（n²）。根据@ dkim的评论，我们可以使用ListBuffer将其改进为 O（n），或者我们可以使用Vector然后转换为List时我们已经完成了。

除了简单地修复toList方法之外，我们可能会问为什么使用fold来实现toList的结果与我们的直觉不一致（给我们一个向后的列表而不是转发名单）。有人可能会指出列表的折叠签名与List类层次结构的结构相匹配。

abstract class List[+A] {
  def fold[B](init: B)(step: (A, B) => B): B
}

case object Empty extends List[Nothing] {
  def fold[B](init: B)(step: (A, B) => B): B = init
}

case class Cons[+A](head: A, tail: List[A]) extends List[A] {
  def fold[B](init: B)(step: (A, B) => B): B =
    step(head, tail.fold(init)(step))
}

注意fold的方法签名如何匹配类层次结构，甚至是每个实现类所拥有的值。（旁白：为了简洁起见，我使用了一个非常天真的fold实现既不高效又不安全堆栈。生产实现应该是尾递归或使用循环和可变缓冲区，但重点是方法签名也是一样的。）

我们可以为您的BSTree课程执行相同操作，fold签名将为：

abstract class BSTree {
  def fold[A](withEmpty: A)(withNode: (A, Int, A) => A): A
}

然后toList将是tree.fold(List[Int]())((l, n, r) => l ++ List(n) ++ r)。但是，如果您预计Vector甚至大约有50个条目，请使用缓冲区或tree来获得不错的效果。

使用函数＆＃34; fold＆＃34;

2 个答案: