scala中带尾部递归的递归排序

我试图在Scala中用尾部递归编写这个算法

public ArrayList sort(ArrayList<int> toSort)
{
  ArrayList<int> list=toSort;
      for(int i=0; i<list.size();i++)
      {    int min=100;
           int pos=-1;
           for(int j=i+1; j<list.size();j++)
           {
                if(list.get(i)>list.get(j) && list.get(j)<min)
                {
                    min=list.get(j);
                    pos=j;
                }
           }
           if(pos!=-1)
           {
                int a=list.get(i);
                list.set(i,list.get(pos));
                list.set(pos,a);
           }
      }
    return list;
}

公共ArrayList排序（ArrayList-toSort）
{
ArrayList list=toSort；
对于（int i=0；i这里有一段代码，它在Scala中“是”，尽管这是我所写过的最差的Scala代码。我想让它与您的代码保持1:1的比例。但我希望它能用于演示如何编写尾部递归。仅此而已

def sort(toSort: util.ArrayList[Int]): util.ArrayList[Int] = {
  val list = toSort

  @tailrec
  def outerLoop(i: Int) {

    if (i < list.size) {
      var min = 100
      var pos = -1

      @tailrec
      def innerLoop(j: Int) {
        if (j < list.size) {
          if (list.get(i) > list.get(j) && list.get(j) < min) {
            min = list.get(j)
            pos = j
          }

          innerLoop(j + 1)
        }
      }

      if (pos != -1) {
        val a = list.get(i)
        list.set(i, list.get(pos))
        list.set(pos, a)
      }

      outerLoop(i + 1)
    }
  }

  outerRec(0)
}

def排序（toSort:util.ArrayList[Int]）：util.ArrayList[Int]={
val list=toSort
@泰勒克
def outerLoop（i:Int）{
如果（ilist.get（j）&&list.get（j）
这里是不可变的tailrec解决方案。它并不复杂，我只是正确地将您的代码转换为不可变的方法

import annotation.tailrec

val list = List(1,4,2,7,6,9,8)

@tailrec
final def inner(min: Int, pos: Int, item: Int, i: Int, list: List[(Int, Int)]): Map[Int, Int] = list match {
  case (pItem, p) :: tail if(item > pItem &&  pItem < min) => inner(pItem, p, item, i, tail)
  case (pItem, p) :: tail => inner(min, pos, item, i, tail)
  case Nil if(pos != -1) => Map(i -> min, pos -> item)
  case Nil => Map.empty[Int, Int]
}

@tailrec
final def outer(list: List[(Int, Int)], acc: Map[Int, Int] = Map.empty[Int, Int]): Map[Int, Int] = list match {
  case (item, i) :: tail => outer(tail, acc ++ inner(100, -1, item, i, tail))
  case Nil => acc
}

def tailSort(list: List[Int]) = {
  val zipped = list.zipWithIndex
  outer(zipped, zipped.map(_.swap).toMap).toList.sortBy(_._1).map(_._2)
}

tailSort(list)

res41: List[Int] = List(1, 2, 4, 6, 7, 8, 9)

import annotation.tailrec
val list=列表（1,4,2,7,6,9,8）
@泰勒克
最终定义内部（min:Int，pos:Int，item:Int，i:Int，list:list[（Int，Int）]）：Map[Int，Int]=列表匹配{
案例（pItem，p）：如果（项目>pItem&&pItem内部（pItem，p，项目，i，tail），则为尾部
案例（pItem，p）：：尾部=>内部（最小，位置，项目，i，尾部）
如果（pos！=-1）=>映射（i->min，pos->item），则无案例
case Nil=>Map.empty[Int，Int]
}
@泰勒克
最终定义外部（list:list[（Int，Int）]，acc:Map[Int，Int]=Map.empty[Int，Int]）：Map[Int，Int]=list匹配{
案例（项目，i）：：尾部=>外部（尾部，acc++内部（100，-1，项目，i，尾部））
案例无=>acc
}
def tailSort（列表：列表[Int]）={
val zipped=list.zipWithIndex
outer（zipped，zipped.map（u.swap）.toMap.toList.sortBy（u._1）.map（u._2）
}
尾排序（列表）
res41:List[Int]=List（1,2,4,6,7,8,9）
您可以为此使用连续传递样式

val sort: List[Int] => List[Int] = {
  @tailrec def ins(n: Int, l: List[Int], acc: List[Int]): List[Int] = l match {
    case Nil => (n :: acc).reverse
    case x :: xs => if (n < x) acc.reverse ++ (n :: l) else ins(n, xs, x :: acc)
  }

  @tailrec def sort1[A](l: List[Int], k: List[Int] => A): A = l match {
    case Nil => k(Nil)
    case x :: xs => sort1(xs, l => k(ins(x, l, Nil)))
  }

  l => sort1(l, x => x)
}

val排序：List[Int]=>List[Int]={
@tailrec def ins（n:Int，l:List[Int]，acc:List[Int]）：List[Int]=l匹配{
案例Nil=>（n:：acc）。反向
案例x：：xs=>if（nA）：A=l匹配{
案例Nil=>k（Nil）
案例x：：xs=>sort1（xs，l=>k（ins（x，l，Nil）））
}
l=>sort1（l，x=>x）
}
谢谢您的回答，您对我的编译错误的回答是对的。您的回答很好，但实际上我正在寻找一个不变的解决方案。再次感谢您，先生。我想是的。Scala排序如下：val list=list（3，2，1）.sortedScala不可变列表作为链表实现，链表的数据结构与java ArrayList不同，因此使用了不同的排序算法。