Scala优先级队列不维护排序

我希望这是秩序的基础上的价格

final case class Case(price: Int) {}

但它实际上是一个更大的case类，我从中删除了字段。我想这样分类

val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)

^按降价排序

现在我想让这一切继续下去

queue.enqueue(Case(price = 2))
println(queue.toString)

queue.enqueue(Case(price = 3))
println(queue.toString)

queue.enqueue(Case(price = 4))
println(queue.toString)

queue.enqueue(Case(price = 1))
println(queue.toString)

queue.enqueue(Case(price = 0))
println(queue.toString)

但是我的输出没有在第四行和第五行排序

PriorityQueue(Case(2))
PriorityQueue(Case(2), Case(3))
PriorityQueue(Case(2), Case(3), Case(4))
PriorityQueue(Case(1), Case(2), Case(4), Case(3))
PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

而且，

foreach

方法没有按顺序迭代

queue.foreach{ q =>
  print(q + ", ")
}

印刷品

Case(0), Case(1), Case(4), Case(3), Case(2), 

---

如何使队列在降价时保持有序？

打印优先级队列可能不会返回顺序中的元素

但是可以保证的是，

head

始终返回最低的（根据您的排序）元素，并重复

dequeue

按

排序所指定的顺序将元素排出来

当我这样做时：

queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()

我明白了：

res10: Case = Case(0)
res11: Case = Case(1)
res12: Case = Case(2)
res13: Case = Case(3)
res14: Case = Case(4)

打印优先级队列可能不会返回顺序中的元素

但是可以保证的是，
head
始终返回最低的（根据您的排序）元素，并重复
dequeue
按
排序所指定的顺序将元素排出来

当我这样做时：

queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()

我明白了：

res10: Case = Case(0)
res11: Case = Case(1)
res12: Case = Case(2)
res13: Case = Case(3)
res14: Case = Case(4)

根据，打印队列不会显示优先级：

只有dequeue和dequeueAll方法将在中返回方法
优先级顺序（从堆中删除元素时）。标准
包括drop、迭代器和toString在内的收集方法将被删除
或者以最方便的顺序遍历堆

因此，打印优先级队列不会显示优先级顺序
虽然将打印优先级最高的元素，但
第一。要按顺序打印元素，必须复制
优先队列（例如，通过使用克隆），然后将其出列

因此，如果您希望按顺序查看元素，则需要以下内容：

scala> val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)
queue: scala.collection.mutable.PriorityQueue[Case] = PriorityQueue()

scala> queue += Case(2) += Case(3) += Case(4) += Case(1) += Case(0)
res1: queue.type = PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

scala> while (queue.size > 0) println(queue.dequeue)
Case(0)
Case(1)
Case(2)
Case(3)
Case(4)

或者，您可以使用
dequeueAll
获取有序集合：

scala> val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)
queue: scala.collection.mutable.PriorityQueue[Case] = PriorityQueue()

scala> queue += Case(2) += Case(3) += Case(4) += Case(1) += Case(0)
res2: queue.type = PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

scala> val ordered = queue.dequeueAll                                                                      
ordered: scala.collection.immutable.IndexedSeq[Case] = Vector(Case(0), Case(1), Case(2), Case(3), Case(4)) 

scala> ordered.foreach(println)                                                                            
Case(0)                                                                                                    
Case(1)                                                                                                    
Case(2)                                                                                                    
Case(3)                                                                                                    
Case(4)                     

根据讨论
，则无法在不通过出列破坏队列的情况下按顺序检索元素。这似乎是底层数据结构（二进制堆）的实现所固有的
 根据，打印队列不会显示优先级：

只有dequeue和dequeueAll方法将在中返回方法
优先级顺序（从堆中删除元素时）。标准
包括drop、迭代器和toString在内的收集方法将被删除
或者以最方便的顺序遍历堆

因此，打印优先级队列不会显示优先级顺序
虽然将打印优先级最高的元素，但
第一。要按顺序打印元素，必须复制
优先队列（例如，通过使用克隆），然后将其出列

因此，如果您希望按顺序查看元素，则需要以下内容：

scala> val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)
queue: scala.collection.mutable.PriorityQueue[Case] = PriorityQueue()

scala> queue += Case(2) += Case(3) += Case(4) += Case(1) += Case(0)
res1: queue.type = PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

scala> while (queue.size > 0) println(queue.dequeue)
Case(0)
Case(1)
Case(2)
Case(3)
Case(4)

或者，您可以使用
dequeueAll
获取有序集合：

scala> val queue = PriorityQueue.empty[Case](Ordering.by((_: Case).price).reverse)
queue: scala.collection.mutable.PriorityQueue[Case] = PriorityQueue()

scala> queue += Case(2) += Case(3) += Case(4) += Case(1) += Case(0)
res2: queue.type = PriorityQueue(Case(0), Case(1), Case(4), Case(3), Case(2))

scala> val ordered = queue.dequeueAll                                                                      
ordered: scala.collection.immutable.IndexedSeq[Case] = Vector(Case(0), Case(1), Case(2), Case(3), Case(4)) 

scala> ordered.foreach(println)                                                                            
Case(0)                                                                                                    
Case(1)                                                                                                    
Case(2)                                                                                                    
Case(3)                                                                                                    
Case(4)                     

根据讨论
，则无法在不通过出列破坏队列的情况下按顺序检索元素。这似乎是底层数据结构（二进制堆）的实现所固有的
 是的，当优先级队列元素相等时，scala默认实现不是就地出列。您可以使用以下方法实现就地出列：

class PriorityQueueTest{
 implicit val ord: Ordering[(Any,Int)] = Ordering.by(_._2)

 var queue = mutable.PriorityQueue[(Any,Int)]()

 def inplaceDeque(number:Int): Seq[(Any,Int)] ={
  var res: Seq[(Any,Int)] = Seq()
    res =queue.take(number).toSeq
    queue =queue.drop(number)
  res
 }
}

是的，当优先级队列元素相等时，scala默认实现不是就地出列。您可以使用以下方法实现就地出列：

class PriorityQueueTest{
 implicit val ord: Ordering[(Any,Int)] = Ordering.by(_._2)

 var queue = mutable.PriorityQueue[(Any,Int)]()

 def inplaceDeque(number:Int): Seq[(Any,Int)] ={
  var res: Seq[(Any,Int)] = Seq()
    res =queue.take(number).toSeq
    queue =queue.drop(number)
  res
 }
}

但是当我用
foreach
遍历元素时，我想按从低到高的顺序遍历它们。@MichaelLafayette你可能可以用
而用
size
遍历元素时，用
foreach
遍历元素时，我想按顺序遍历它们从最低到最高。@MichaelLafayette您可能可以
使用
而
使用
大小
？