使用隐式排序优先队列（Scala）时出现问题

我正在尝试创建一个数据结构，其中包含

PriorityQueue

。我成功地制作了一个非通用版本。我可以说它有效，因为它解决了我的人工智能问题。
以下是其中的一个片段：

class ProntoPriorityQueue { //TODO make generic

implicit def orderedNode(node: Node): Ordered[Node] = new Ordered[Node] {
   def compare(other: Node) = node.compare(other)
}

val hashSet = new HashSet[Node]
val priorityQueue = new PriorityQueue[Node]()
...

我试图使其通用，但如果我使用此版本，它将停止解决问题：

class PQ[T <% Ordered[T]] {
//[T]()(implicit val ord: T => Ordered[T]) {
//[T]()(implicit val ord: Ordering[T] {

val hashSet = new HashSet[T]
val priorityQueue = new PriorityQueue[T]
...

我还尝试将隐式def移动到

节点

对象中（并导入），但本质上是相同的问题

我在通用版本中做错了什么？我应该把它放在哪里

---

解决方案

---

问题不在于我的含蓄定义。问题是，

集合

自动在

for（…）yield（…）

语句中生成了隐式排序。这导致生成的集只包含一个状态的问题。

在

节点上定义
排序
（
排序[Node]
）并使用已经通用的Scala
优先级队列有什么错

一般来说，使用
Ordering[T]
比使用
T更好。一个可能的问题是，您的
Ordering[Node]
不是
节点：

implicit def orderedNode(node: Node): Ordered[Node] = new Ordered[Node] {
  def compare(other: Node) = node.compare(other)
}

我会尝试使用
排序[Node]
，您说您已经尝试过了，但是没有更多的相关信息
PQ
将被声明为
PQ[T:Ordering]
我已将
PQ
定义更改为：
class PQ[T:Ordering]{…
并将我的隐式定义更改为：
隐式定义orderedNode:Ordering[Node]=新的排序[Node]{]{定义比较（某些：Node，其他：Node）=）=一些。比较（其他）}）
但它仍然没有work@Tombstone嗯，没有足够的信息。你给我们的只是一个依赖于它的算法不再工作了——我怀疑这是算法中的一个错误。在没有“当我做Y时它做X，它应该做Z”的情况下，我们所能做的就是猜测。该算法可能存在问题，但我对此表示怀疑，原因有以下几个：1）它基于我的图形搜索算法，该算法适用于探索集的其他数据结构（LIFO、FIFO）最大的区别是从堆栈| |队列更改为优先级队列3。）我让它使用非泛型的数据结构工作（现在有一个非泛型、非隐式的工作版本）。放置算法的所有相关信息需要数百行。我尝试在我的节点上扩展
排序[Node]
。我实现了
比较（其他：节点）
和
比较（一些：节点，其他：节点）
这在涉及
节点的其他方法调用中导致了一系列问题，这里有一些问题：-类型scala.collection.generic.CanBuildFrom[main.Moves.ValueSet，Option[main.Node]的隐式扩展出现分歧，该扩展以对象SortedSet中的方法newCanBuildFrom开始-方法映射的参数不足：（隐式bf:scala.collection.generic.CanBuildFrom[main.Moves.ValueSet，Option[main.Node]，That]）该.Unspecified值参数bf@Tombstone：您没有使
节点
类扩展
排序[节点]
，而是定义了一个扩展
排序[节点]的类
通过定义方法
compare
来定义
节点上的排序关系。我创建了一个扩展排序[Node]的新类，它可以工作。谢谢。我仍然有一个关于隐式的问题。我以前的隐式为什么不工作？
隐式定义节点排序器：排序[Node]=新排序[Node]{def compare（some:Node，other:Node）=some.compare（other）}
隐式valorder:Ordering[Node]=新排序[Node]{def compare（some:Node，other:Node）=some.compare（other）}
@Tombstone:您必须在范围内正确地组合键入的（它们）（如果不是注释掉的话，它们会是）使用
的隐式转换感谢您的患者对我的帮助。遗憾的是，我还没有弄明白。您能告诉我如何定义类、调用构造函数以及要使用的隐式定义吗？
/* Here's how it would be with direct implementation of `Ordered` */

class   CIString1(val s: String)
extends Ordered[CIString1]
{
  private val lowerS = s.toLowerCase

  def compare(other: CIString1) = lowerS.compareTo(other.lowerS)
}

/* An uninteresting, empty ordered set of CIString1
    (fails without the `extends` clause) */
val os1 = TreeSet[CIString1]()


/* Here's how it would look with ordering external to `CIString2`
    using an implicit conversion to `Ordered` */

class CIString2(val s: String) {
  val lowerS = s.toLowerCase
}

class CIString2O(ciS: CIString2)
extends Ordered[CIString2]
{
  def compare(other: CIString2) = ciS.lowerS.compareTo(other.lowerS)
}

implicit def cis2ciso(ciS: CIString2) = new CIString2O(ciS)

/* An uninteresting, empty ordered set of CIString2
    (fails without the implicit conversion) */
val os2 = TreeSet[CIString2]()


/* Here's how it would look with ordering external to `CIString3`
    using an `Ordering` */

class CIString3(val s: String) {
  val lowerS = s.toLowerCase
}

/* The implicit object could be replaced by
    a class and an implicit val of that class */
implicit
object  CIString3Ordering
extends Ordering[CIString3]
{
  def compare(a: CIString3, b: CIString3): Int = a.lowerS.compareTo(b.lowerS)
}

/* An uninteresting, empty ordered set of CIString3
    (fails without the implicit object) */
val os3 = TreeSet[CIString3]()

implicit def orderedNode(node: Node): Ordered[Node] = new Ordered[Node] {
  def compare(other: Node) = node.compare(other)
}