Scala快速排序算法的实现

我需要帮助来填补一些空白，以便分区在调用分区（data，lower，upper）时工作。尽管如此，我认为if语句应该是if（lower

 object Quicksort {
  def partition[A](data: Array[A], lower: Int, upper: Int)
                  (implicit comp: Ordering[A]): Int = {
    val pivot = data(upper-1)
    var mid = lower-1
    for (i <- lower until upper-1) {
      if (comp.lteq(data(i),pivot)) {
        mid += 1
        swap(data,mid,i)
      }
    }
    swap(data,mid+1,upper-1)
    mid+1
  }
  def sort[A](data: Array[A])(...): Unit = {
    def sortRange(data: Array[A], lower: Int, upper: Int):
    Unit = {
      if(lower < upper) {
        val pivotIndex = partition(data,lower,upper)
        sortRange(data,lower,pivotIndex)
        sortRange(data,pivotIndex+1,upper)
      }
    }
    sortRange(data,0,data.length)
  }
  def main(args: Array[String]) : Unit = {
    //Result of partition(data,lower,upper):
    //sortRange results in quick-sorting the range: [lower,upper)
  }
}

对象快速排序{
def分区[A]（数据：数组[A]，下：整数，上：整数）
（隐式comp:Ordering[A]）：Int={
val pivot=数据（上-1）
var mid=低-1
对于（i由于快速排序是一种就地排序算法（即，它与副作用有关），我不想传递要排序的集合，而是希望将该方法“附加”到所述集合

我还想删除所有那些讨厌的可变变量

implicit class QSort[A:Ordering](as: Array[A]) {
  import Ordering.Implicits._
  private def swap(x: Int, y: Int): Unit = {
    val hold = as(x)
    as(x) = as(y)
    as(y) = hold
  }

  private def partition(lo: Int, hi: Int): Int =
    ((lo until hi).filter(as(_) < as(hi)) :+ hi)
      .zipWithIndex.foldLeft(0){
        case (_,(j,x)) => swap(j, lo+x); lo+x
      }

  private def quicksort(lo:Int, hi:Int): Unit =
    if (lo < hi) { 
      val p = partition(lo, hi)
      quicksort(lo, p-1)
      quicksort(p+1, hi)
    }

  def qsort(): Unit = quicksort(0, as.length - 1)
}

你尝试过什么？你理解隐式和类型参数/泛型的概念吗？@mchaJIS我相信隐式对数据施加了排序（比这个意义上的整数小）而类型参数/泛型，例如类型A，可以在实例化时指定一个具体类型的整数或整数数组。例如，当我执行val cs=array（'g'，'A'，'t'，'b'，'z'，'h'）println（cs.mkString（'array（“，”，“，”，”））时，它只输出数组（g，A，t，z），而不输出数组（g，A，t，b，z，h）对我来说scala>val cs=Array（'g'，'a'，'t'，'b'，'z'，'h'）cs:Array[Char]=Array（g，a，t，b，z，h）scala>println（cs.mkString（“Array（“，”，“，”）））Array（g，a，t，z）我看到对于其他人来说，它的工作方式与预期的一样，所以可能是我正在使用的版本，或者只是我自己的一些小毛病。我想这是2.13.0中的一些奇怪的错误
val cs = Array('g','a','t','b','z','h')
cs.qsort()  //: Unit
cs          //: Array[Char] = Array(a, b, g, h, t, z)

val ns = Array(9,8,7,6,5,4,3,2,1)
ns.qsort()  //: Unit
ns          //: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)