Scala 二叉树中未为定义隐式排序_Scala_Data Structures_Binary Tree_Generic Programming

Scala 二叉树中未为定义隐式排序

scala data-structures

Scala 二叉树中未为定义隐式排序,scala,data-structures,binary-tree,generic-programming,Scala,Data Structures,Binary Tree,Generic Programming,我试图在Scala中开发二叉树结构，但我有一个错误，即： Error:(15, 54) No implicit Ordering defined for A. override def add[A](new_value: A): BinaryTree[A] = new Node(NullNode,new_value,NullNode) 有人能解释一下我怎么修吗？下面是代码，问题出在NullNode对象的add方法中，当您尝试为节点创建一个left时，会调用此方法 sealed abstr

我试图在Scala中开发二叉树结构，但我有一个错误，即：

 Error:(15, 54) No implicit Ordering defined for A.

 override def add[A](new_value: A): BinaryTree[A] = new Node(NullNode,new_value,NullNode)

有人能解释一下我怎么修吗？下面是代码，问题出在NullNode对象的add方法中，当您尝试为节点创建一个left时，会调用此方法

sealed abstract class BinaryTree[+A] {
  def isEmpty: Boolean
  def isValid: Boolean
  def add[B >: A](new_value: B): BinaryTree[A]
  def isLeaf: Boolean
  def length: Int
}

case object NullNode extends BinaryTree[Nothing] {
  override def isEmpty: Boolean = true
  override def isValid: Boolean = true
  override def isLeaf: Boolean = false
  override def add[A](new_value: A): BinaryTree[A] = new Node(NullNode,new_value,NullNode)
  override def length: Int = 0
}

case class Node[A] (
      var left  : BinaryTree[A],
      var value : A,
      var rigth : BinaryTree[A] )
    ( implicit ord: Ordering[A] ) extends BinaryTree[A] {
  override def isEmpty: Boolean = false
  override def isValid: Boolean = {
    import ord._

    def isValidWith (f: A => Boolean, t: BinaryTree[A]): Boolean = t match {
      case NullNode => true
      case Node(_,valueNode,_) => f(valueNode) && t.isValid
    }

    isValidWith(value < _, left) && isValidWith(value > _, rigth)
  }

  override def isLeaf: Boolean = left.isEmpty && rigth.isEmpty
  override def add[B >: A](new_value: B): BinaryTree[A] = {
    import ord._

    def travel (t: BinaryTree[A]): BinaryTree[A] = t match {
      case NullNode => t.add(new_value)
      case Node (left,nodeValor,rigth) => {
        if (new_value > nodeValor) new Node(travel(left),nodeValor,rigth)
        else if (new_value < nodeValor) new Node(left,nodeValor, travel(rigth))
        else throw new Exception("Valor ya introducido")
      }
    }

    travel(this)
  }
  override def length: Int = {
    def travel (t: BinaryTree[A]): Int = t match {
      case NullNode => t.length
      case Node(left,_,rigth) => left.length + rigth.length + 1
    }

    travel(this)
  }

}

object BinaryTree {
  def apply[A] (value: A)(implicit ord: Ordering[A]): BinaryTree[A] = new Node(NullNode,value,NullNode)
}

密封抽象类二进制树[+A]{
def isEmpty:Boolean
def isValid:Boolean
def add[B>：A]（新值：B）：二进制树[A]
def isLeaf：布尔值
定义长度：Int
}
案例对象NullNode扩展BinaryTree[无]{
override def isEmpty:Boolean=true
override def isValid:布尔值=真
覆盖def isLeaf:Boolean=false
override def add[A]（新_值：A）：二进制树[A]=新节点（NullNode，新_值，NullNode）
覆盖定义长度：Int=0
}
案例类节点[A](
左变量：二进制树[A]，
var值：A，
变量rigth:BinaryTree[A]）
（隐式ord:Ordering[A]）扩展了二进制树[A]{
override def isEmpty:Boolean=false
覆盖定义有效：布尔={
进口订单_
def isValidWith（f:A=>Boolean，t:BinaryTree[A]）：Boolean=t match{
case NullNode=>true
案例节点（u，valueNode，u）=>f（valueNode）&&t.isValid
}
isValidWith（值<右）和&isValidWith（值>右）
}
覆盖def isLeaf:Boolean=left.isEmpty&&rigth.isEmpty
覆盖def add[B>：A]（新值：B）：二进制树[A]={
进口订单_
def行程（t:BinaryTree[A]）：BinaryTree[A]=t匹配{
case NullNode=>t.add（新的_值）
案例节点（左侧、节点颜色、右侧）=>{
如果（新值>节点颜色）新节点（行程（左）、节点颜色、右侧）
else if（新值<节点颜色）新节点（左侧、节点颜色、行程（右侧））
否则抛出新异常（“Valor ya Introducto”）
}
}
旅行（本）
}
覆盖定义长度：Int={
def行程（t:BinaryTree[A]）：Int=t匹配{
case NullNode=>t.length
案例节点（左，右）=>left.length+rigth.length+1
}
旅行（本）
}
}
对象二叉树{
def apply[A]（值：A）（隐式order:Ordering[A]）：二进制树[A]=新节点（NullNode，value，NullNode）
}

目前，我尝试了不同的实现，将排序添加到抽象类的泛型类型，或者将抽象类变成一个特征，但这些都没有像我所希望的那样起作用。如果有人能解释这个错误的原因，我将不胜感激。

基本问题来自这样一个事实，即没有

排序[无]

，这意味着

NullNode

不能排序，但

Node.value

类型需要排序

我通过向每个

add（）

方法引用添加

排序

，并调整

值

类型与

左

右

节点类型之间的关系来编译它

sealed abstract class BinaryTree[+A] {
  def isEmpty: Boolean
  def isValid: Boolean
  def add[B >: A :Ordering](new_value: B): BinaryTree[B]
  . . .

代码还有其他问题和问题，但至少可以编译。