Scala：如何在指定的索引范围内对数组进行排序？

代码中已经有一个比较函数“compr”来比较两个值

我想要这样的东西：

Sorting.stableSort（arr[i，j]，compr）

---

其中，arr[i，j]是数组中的一系列元素。

将数组分为三部分，对中间部分进行排序，然后将它们合并，这不是最有效的方法，但这是关心性能的FP=）

val排序=
为了{
首先将数组分成三部分，对中间部分进行排序，然后对它们进行合并，这不是最有效的方法，但这是关心性能的FP=）

val排序=
为了{
首先是这样的：

def stableSort[T](x: Seq[T], i: Int, j: Int, comp: (T,T) => Boolean ):Seq[T] = {
    x.take(i) ++ x.slice(i,j).sortWith(comp) ++ x.drop(i+j-1)
}                                         

def comp: (Int,Int) => Boolean = { case (x1,x2) => x1 < x2 } 
val x = Array(1,9,5,6,3)                           
stableSort(x,1,4, comp)
// > res0: Seq[Int] = ArrayBuffer(1, 5, 6, 9, 3)

defstablesort[T]（x:Seq[T]，i:Int，j:Int，comp:（T，T）=>布尔值）：Seq[T]={
x、 取（i）+x.slice（i，j）或sortWith（comp）+x.drop（i+j-1）
}                                         
def comp：（Int，Int）=>Boolean={case（x1，x2）=>x1res0:Seq[Int]=ArrayBuffer（1,5,6,9,3）

如果您的类实现了排序，那么它就不那么麻烦了。
类似于：

def stableSort[T](x: Seq[T], i: Int, j: Int, comp: (T,T) => Boolean ):Seq[T] = {
    x.take(i) ++ x.slice(i,j).sortWith(comp) ++ x.drop(i+j-1)
}                                         

def comp: (Int,Int) => Boolean = { case (x1,x2) => x1 < x2 } 
val x = Array(1,9,5,6,3)                           
stableSort(x,1,4, comp)
// > res0: Seq[Int] = ArrayBuffer(1, 5, 6, 9, 3)

defstablesort[T]（x:Seq[T]，i:Int，j:Int，comp:（T，T）=>布尔值）：Seq[T]={
x、 取（i）+x.slice（i，j）或sortWith（comp）+x.drop（i+j-1）
}                                         
def comp：（Int，Int）=>Boolean={case（x1，x2）=>x1res0:Seq[Int]=ArrayBuffer（1,5,6,9,3）

如果您的类实现了排序，那么就不会那么麻烦。
将切片作为视图，排序并复制回去（或者将切片作为工作缓冲区）

在REPL之外，不需要额外的
.toSeq
：

vs.view(2,5).sorted.copyToArray(vs,2)

将切片作为视图，排序并复制回（或将切片作为工作缓冲区）

在REPL之外，不需要额外的
.toSeq
：

vs.view(2,5).sorted.copyToArray(vs,2)

这应该是在不重新实现排序的情况下所能得到的最好结果。只创建一个额外的数组，该数组的大小与要排序的切片的大小相同

def stableSort[K:reflect.ClassTag](xs:Array[K], from:Int, to:Int, comp:(K,K) => Boolean) : Unit = {
  val tmp = xs.slice(from,to)
  scala.util.Sorting.stableSort(tmp, comp)
  tmp.copyToArray(xs, from)
}

这应该是在不重新实现排序的情况下所能得到的最好结果。只创建一个额外的数组，该数组的大小与要排序的切片的大小相同

def stableSort[K:reflect.ClassTag](xs:Array[K], from:Int, to:Int, comp:(K,K) => Boolean) : Unit = {
  val tmp = xs.slice(from,to)
  scala.util.Sorting.stableSort(tmp, comp)
  tmp.copyToArray(xs, from)
}

如果我使用对象而不是原语，那么我必须扩展排序[T]类并重载比较函数。对吗？或者使用
sortWith（comparator）
。注意元组已经有排序，请参见math.Ordering。还有
Ordering.by
。如果我使用对象而不是原语，那么我必须扩展排序[T]类和重载比较函数。对吗？或者使用
sortWith（comparator）
。注意元组已经有顺序，请参阅math.Ordering。也可以使用
Ordering.by
。