2016 Update

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-1.scala

@@ -1,7 +1,11 @@
-def quicksortInt(coll: List[Int]): List[Int] =
-  if (coll.isEmpty) {
-    coll
-  } else {
-    val (smaller, bigger) = coll.tail partition (_ < coll.head)
-    quicksortInt(smaller) ::: coll.head :: quicksortInt(bigger)
+  def sort(xs: List[Int]): List[Int] = {
+    xs match {
+      case Nil => Nil
+      case x :: xx => {
+        // Arbitrarily partition list in two
+        val (lo, hi) = xx.partition(_ < x)
+        // Sort each half
+        sort(lo) ++ (x :: sort(hi))
+      }
+    }
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-2.scala

@@ -1,7 +1,9 @@
-def quicksortFunc[T](coll: List[T], lessThan: (T, T) => Boolean): List[T] =
-  if (coll.isEmpty) {
-    coll
-  } else {
-    val (smaller, bigger) = coll.tail partition (lessThan(_, coll.head))
-    quicksortFunc(smaller, lessThan) ::: coll.head :: quicksortFunc(bigger, lessThan)
+  def sort[T](xs: List[T], lessThan: (T, T) => Boolean): List[T] = {
+    xs match {
+      case Nil => Nil
+      case x :: xx => {
+        val (lo, hi) = xx.partition(lessThan(_, x))
+        sort(lo, lessThan) ++ (x :: sort(hi, lessThan))
+      }
+    }
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-3.scala

@@ -1,7 +1,9 @@
-def quicksortOrd[T <% Ordered[T]](coll: List[T]): List[T] =
-  if (coll.isEmpty) {
-    coll
-  } else {
-    val (smaller, bigger) = coll.tail partition (_ < coll.head)
-    quicksortOrd(smaller) ::: coll.head :: quicksortOrd(bigger)
+  def sort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = {
+    xs match {
+      case Nil => Nil
+      case x :: xx => {
+        val (lo, hi) = xx.partition(ord.lt(_, x))
+        sort[T](lo) ++ (x :: sort[T](hi))
+      }
+    }
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-4.scala

@@ -1,11 +1,9 @@
-def quicksort
-  [T, CC[X] <: Seq[X] with SeqLike[X, CC[X]]]       // My type parameters
-  (coll: CC[T])                                                     // My explicit parameter
-  (implicit o: T => Ordered[T], cbf: CanBuildFrom[CC[T], T, CC[T]]) // My implicit parameters
-  : CC[T] =                                                         // My return type
-  if (coll.isEmpty) {
-    coll
-  } else {
-    val (smaller, bigger) = coll.tail partition (_ < coll.head)
-    quicksort(smaller) ++ (coll.head +: quicksort(bigger))
+  def sort[T <: Ordered[T]](xs: List[T]): List[T] = {
+    xs match {
+      case Nil => Nil
+      case x :: xx => {
+        val (lo, hi) = xx.partition(_ < x)
+        sort(lo) ++ (x :: sort(hi))
+      }
+    }
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-5.scala

@@ -1,7 +1,17 @@
-def quicksortInt(list: List[Int]): List[Int] = list match {
-    case List(head) => list
-    case head :: tail =>
-      val (smaller, bigger) = tail partition (_ < head)
-      quicksortInt(smaller) ::: head :: quicksortInt(bigger)
-    case _ => list
+  def sort[T, C[T] <: scala.collection.TraversableLike[T, C[T]]]
+    (xs: C[T])
+    (implicit ord: scala.math.Ordering[T],
+      cbf: scala.collection.generic.CanBuildFrom[C[T], T, C[T]]): C[T] = {
+    // Some collection types can't pattern match
+    if (xs.isEmpty) {
+      xs
+    } else {
+      val (lo, hi) = xs.tail.partition(ord.lt(_, xs.head))
+      val b = cbf()
+      b.sizeHint(xs.size)
+      b ++= sort(lo)
+      b += xs.head
+      b ++= sort(hi)
+      b.result()
+    }
   }