问题 创建二叉树scala的和树

首先，我相信，如果我可以这么说，你做得很好。我可以建议对您的代码进行一些细微的更改：

abstract class Tree 
case class Node(value: Int, left: Tree, right: Tree) extends Tree
case object Nil extends Tree

1. Tree不需要是case-class，除了使用case-class作为非叶节点之外，由于可能出现的自动生成方法的错误行为而被弃用。
2. Nil 是一个单例，最好定义为case-object而不是case-class。

3. 另外考虑符合条件的超级班级 Tree 同 sealed。 sealed 告诉编译器该类只能从同一个源文件中继承。这使得编译器可以在以下匹配表达式不详尽时发出警告 - 换句话说，不包括所有可能的情况。

   密封的抽象类树

接下来的几个改进可以做到 sumTree：

def sumTree(t: Tree) = {
  // create a helper function to extract Tree value
  val nodeValue: Tree=>Int = {
    case Node(v,_,_) => v
    case _ => 0
  }
  // parametrise fold with Tree to aid type inference further down the line
  fold[Tree](t,Nil,(acc,l,r)=>Node(acc + nodeValue(l) + nodeValue(r) ,l,r)) 
}

nodeValue 辅助函数也可以定义为（上面使用的替代符号是可能的，因为花括号中的一系列情况被视为函数文字）：

def nodeValue (t:Tree) = t match {
  case Node(v,_,_) => v
  case _ => 0
}

接下来的一点改进是参数化 fold 方法用 Tree （fold[Tree]）。因为Scala类型inferer按顺序从左到右通过表达式告诉它我们将要处理Tree's让我们在定义传递给的函数文字时省略类型信息 fold 进一步。

所以这里是完整的代码，包括建议：

sealed abstract class Tree
case class Node(value: Int, left: Tree, right: Tree) extends Tree
case object Nil extends Tree

object Tree {
  def fold[B](t: Tree, e: B, n: (Int, B, B) => B): B = t match {
    case Node(value, l, r) => n(value,fold(l,e,n),fold(r,e,n))
    case _ => e
  }
  def sumTree(t: Tree) = {
    val nodeValue: Tree=>Int = {
      case Node(v,_,_) => v
      case _ => 0
    }
    fold[Tree](t,Nil,(acc,l,r)=>Node(acc + nodeValue(l) + nodeValue(r) ,l,r)) 
  }
}

您提出的递归是唯一可能的方向，它允许您遍历树并生成不可变数据结构的修改副本。在添加到根之前，必须首先创建任何叶节点，因为树的各个节点是不可变的，构造节点所需的所有对象必须在构造之前知道：在创建root之前需要创建叶节点节点。

首先，我相信，如果我可以这么说，你做得很好。我可以建议对您的代码进行一些细微的更改：

abstract class Tree 
case class Node(value: Int, left: Tree, right: Tree) extends Tree
case object Nil extends Tree

1. Tree不需要是case-class，除了使用case-class作为非叶节点之外，由于可能出现的自动生成方法的错误行为而被弃用。
2. Nil 是一个单例，最好定义为case-object而不是case-class。

3. 另外考虑符合条件的超级班级 Tree 同 sealed。 sealed 告诉编译器该类只能从同一个源文件中继承。这使得编译器可以在以下匹配表达式不详尽时发出警告 - 换句话说，不包括所有可能的情况。

   密封的抽象类树

接下来的几个改进可以做到 sumTree：

def sumTree(t: Tree) = {
  // create a helper function to extract Tree value
  val nodeValue: Tree=>Int = {
    case Node(v,_,_) => v
    case _ => 0
  }
  // parametrise fold with Tree to aid type inference further down the line
  fold[Tree](t,Nil,(acc,l,r)=>Node(acc + nodeValue(l) + nodeValue(r) ,l,r)) 
}

nodeValue 辅助函数也可以定义为（上面使用的替代符号是可能的，因为花括号中的一系列情况被视为函数文字）：

def nodeValue (t:Tree) = t match {
  case Node(v,_,_) => v
  case _ => 0
}

接下来的一点改进是参数化 fold 方法用 Tree （fold[Tree]）。因为Scala类型inferer按顺序从左到右通过表达式告诉它我们将要处理Tree's让我们在定义传递给的函数文字时省略类型信息 fold 进一步。

所以这里是完整的代码，包括建议：

sealed abstract class Tree
case class Node(value: Int, left: Tree, right: Tree) extends Tree
case object Nil extends Tree

object Tree {
  def fold[B](t: Tree, e: B, n: (Int, B, B) => B): B = t match {
    case Node(value, l, r) => n(value,fold(l,e,n),fold(r,e,n))
    case _ => e
  }
  def sumTree(t: Tree) = {
    val nodeValue: Tree=>Int = {
      case Node(v,_,_) => v
      case _ => 0
    }
    fold[Tree](t,Nil,(acc,l,r)=>Node(acc + nodeValue(l) + nodeValue(r) ,l,r)) 
  }
}

您提出的递归是唯一可能的方向，它允许您遍历树并生成不可变数据结构的修改副本。在添加到根之前，必须首先创建任何叶节点，因为树的各个节点是不可变的，构造节点所需的所有对象必须在构造之前知道：在创建root之前需要创建叶节点节点。