Scala 问题对 Stack[A] 使用 PriorityQueue 非默认排序

Question

我正在尝试使用 Scala 编写耐心排序的简单实现。
我已经正确地创建了初始桩；但是，我使用优先级队列来简化输出列表的生成让我很头疼。

看来我的排序实现要么错误，要么被忽略：

def PileOrdering = new Ordering[Stack[A]] {
    def compare(a : Stack[A], b : Stack[A]) = a.head.compare(b.head)
}

// Use a priority queue, ordering on stack heads (smallest stack elems)
val pq = new PriorityQueue[Stack[A]]()(PileOrdering)

// piles is a List[Stack[A]]
pq ++= piles

// Extract an ordered list of elements
val returnVal = (0 until count) map (_ => {
    val smallestList = pq.dequeue
    val smallestVal = smallestList.pop

    if (smallestList.length > 0){
        pq.enqueue(smallestList)
    }

    smallestVal
})

PriorityQueue 似乎是按（我想是默认的堆栈排序）堆栈大小排序的，而不是我的排序。

有什么明显错误的地方跳出来吗？ 任何帮助都会受到极大的欢迎。
谢谢，

编辑：我在最初的问题中没有说清楚：我使用的是 Scala 2.8.1。
Edit2：我期待 returnVal包含从最小到最大的元素排序，通过从所有堆栈的头部获取最小元素来找到。 Daniel 指出，我的 Ordering 将从最大到最小的 Stacks 排序（堆栈本身已经正确排序，最小的元素在顶部），这似乎是问题所在。

Answer 1

您不会对优先级队列中的第一个元素是具有 最大 值的元素感到困惑吗？代码似乎期望第一个元素是具有最小值的元素。

Answer 2

很难回答发生了什么，因为您没有包含整个程序的输入和输出。我的猜测是，这是由于 2.8.1 中 PriorityQueue 的旧实现。以下程序使用自定义排序，并使用堆栈列表填充优先级队列：

import collection._                                                                                                 
import collection.mutable.PriorityQueue                                                                             
import collection.mutable.Stack                                                                                     



class Test[A](piles: Traversable[Stack[A]])(implicit ord: Ordering[A]) {                                            

  def PileOrdering = new Ordering[Stack[A]] {                                                                       
    def compare(a : Stack[A], b : Stack[A]) = ord.compare(a.head, b.head)                                           
  }                                                                                                                 

  // Use a priority queue, ordering on stack heads (smallest stack elems)                                           
  val pq = new PriorityQueue[Stack[A]]()(PileOrdering)                                                              

  // piles is a List[Stack[A]]                                                                                      
  pq ++= piles                                                                                                      

}                                                                                                                   

object Main {                                                                                                       
  def main(args: Array[String]) {                                                                                   
    val t = new Test(Seq(Stack(1, 2, 3), Stack(15, 8), Stack(3, 4, 9, 0, -1), Stack(45, 1, 2, 3, 4)))               
    while (t.pq.nonEmpty) {                                                                                         
      println(t.pq.dequeue)                                                                                         
    }                                                                                                               
  }                                                                                                                 
}  

程序输出：

Stack(45, 1, 2, 3, 4)                                                                                               
Stack(15, 8)                                                                                                        
Stack(3, 4, 9, 0, -1)                                                                                               
Stack(1, 2, 3)

使用 Scala 主干，这似乎是正确的。我应该指出，PriorityQueue 进行了一些更改，出于二进制兼容性的原因，这些更改未包含在 2.8.1 中，但将在 2.9 中提供：

• 它曾经是一个序列，它不再是一个序列 - apply 和 update 无法有意义地实现
• 调用toString 或遍历元素不会产生堆顺序- 获得它的唯一方法是使用dequeue