实现 ListPriorityQueue

Author: yangbajing

README.md

@@ -1,6 +1,8 @@
 # 算法学习
 
-- [AlgoCasts](https://algocasts.io/)
-- [算法图解](http://www.ituring.com.cn/book/1864)
-- [算法（第4版）](http://www.ituring.com.cn/book/875)
+- [algocasts](algocasts)：[AlgoCasts](https://algocasts.io/)
+- [algs4](algs4)：[算法（第4版）](http://www.ituring.com.cn/book/875)
+- [algs4-scala](algs4-scala)：算法（第4版）Scala实现，初始源码来自https://github.com/garyaiki/Scala-Algorithms.git
+- [leetcode](leetcode)：leetcode 习题
+- [algorithm](algorithm)：［算法图解](https://www.ituring.com.cn/book/1864)
 - [算法的乐趣](http://www.ituring.com.cn/book/1605)

algs4-scala/src/main/scala/org/gs/queue/ListPriorityQueue.scala

@@ -0,0 +1,74 @@
+package org.gs.queue
+
+import scala.annotation.tailrec
+import scala.reflect.ClassTag
+
+// O(n)
+abstract class ListPriorityQueue[T](implicit ord: Ordering[T]) extends Iterable[T] {
+  import ListPriorityQueue._
+
+  private val dummy: Node[T] = Node(null.asInstanceOf[T])
+
+  private var n = 0
+
+  protected def cmp(nv: T, v: T): Boolean
+
+  def enqueue(v: T): Unit = {
+    @tailrec
+    def loop(root: Node[T]): Unit = root.next match {
+      case null => root.next = Node(v)
+      case node if cmp(node.value, v) =>
+        if (node.next == null) node.next = Node(v) else loop(node.next)
+      case node => root.next = Node(v, node)
+    }
+
+    loop(dummy)
+    n += 1
+  }
+
+  def dequeue: Option[T] = {
+    if (isEmpty) {
+      None
+    } else {
+      val v = head
+      dummy.next = dummy.next.next
+      n -= 1
+      Some(v)
+    }
+  }
+
+  override def headOption: Option[T] = Option(dummy.next).map(_.value)
+
+  override def head: T = dummy.next.value
+
+  override def isEmpty: Boolean = n == 0
+
+  override def size: Int = n
+
+  override def iterator: Iterator[T] = {
+    new Iterator[T] {
+      private var node = dummy.next
+      override def hasNext: Boolean = node ne null
+
+      override def next(): T = {
+        val value = node.value
+        node = node.next
+        value
+      }
+    }
+  }
+}
+
+object ListPriorityQueue {
+  case class Node[T](var value: T, var next: Node[T] = null)
+}
+
+class ListMaxPQ[T: ClassTag](elems: T*)(implicit ord: Ordering[T]) extends ListPriorityQueue[T] {
+  elems.foreach(enqueue)
+  override protected def cmp(nv: T, v: T): Boolean = ord.gt(nv, v)
+}
+
+class ListMinPQ[T: ClassTag](elems: T*)(implicit ord: Ordering[T]) extends ListPriorityQueue[T] {
+  elems.foreach(enqueue)
+  override protected def cmp(nv: T, v: T): Boolean = ord.lt(nv, v)
+}

algs4-scala/src/test/scala/org/gs/queue/ListPriorityQueueTest.scala

@@ -0,0 +1,45 @@
+package org.gs.queue
+
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpec
+
+class ListPriorityQueueTest extends AnyWordSpec with Matchers {
+  "Max" should {
+    "head" in {
+      val q = new ListMaxPQ[Int]()
+      q.enqueue(5)
+      q.head shouldBe 5
+    }
+
+    "enqueue" in {
+      val q = new ListMaxPQ[Int](7, 5, 3, 7)
+      q.toList shouldBe List(7, 7, 5, 3)
+    }
+
+    "dequeue" in {
+      val q = new ListMaxPQ[Int](7, 5, 3, 7)
+      q.head shouldBe 7
+      q.dequeue shouldBe Some(7)
+      q.head shouldBe 7
+      q.dequeue shouldBe Some(5)
+      q.head shouldBe 3
+    }
+  }
+
+  "Min" should {
+    "head" in {
+      val q = new ListMaxPQ[Int]()
+      q.enqueue(5)
+      q.head shouldBe 5
+    }
+
+    "enqueue" in {
+      val q = new ListMaxPQ[Int](5, 5, 3, 7)
+      q.toList shouldBe List(3, 5, 5, 7)
+    }
+
+    "dequeue" in {
+      val q = new ListMaxPQ[Int](7, 5, 3, 7)
+    }
+  }
+}