Scala 是否可以递归重写此函数尾部？

我有一个递归的顺序匹配函数，我想知道是否有可能把这个函数变成一个尾部递归函数？以及如何

还是有更好的方法来提高性能？谢谢

object CollectiveMatch extends App {


  def findSubSet(orders: List[Order], goal: (Double, Double)): List[List[Order]] = {

    var collector: List[List[Order]] = List.empty
    if (orders.isEmpty) return List.empty

    def findMatches(orders: List[Order], index: Int, current: (Double, Double), goal: (Double, Double), result: List[Order]) {
      if (orders.length < index) return
      for (i <- index until orders.length) {
        val newCurrent = if ("Buy".equals(orders(i).side)) {
          (current._1 + orders(i).qty, current._2 + orders(i).volume)
        } else {
          (current._1 - orders(i).qty, current._2 - orders(i).volume)
        }
        if (Math.abs(newCurrent._1 - goal._1) <= 0.00001 && Math.abs(newCurrent._2 - goal._2) <= 0.00001) {
          collector = collector :+ (result :+ orders(i))
        } else {
          findMatches(orders, i + 1, newCurrent, goal, result :+ orders(i))
        }
      }
    }

    findMatches(orders, 0, (0.0, 0.0), (0.0, 0.0), List.empty)
    collector
  }


  val orders = List[Order](
    Order("boc", "Buy", 75.5, 30),
    Order("jp", "Buy", 76, 120),
    Order("ocbc", "Buy", 78, 40),
    Order("sxs", "Buy", 76, 20),
    Order("icbc", "Buy", 79.5, 30),
    Order("morgan", "Buy", 80.5, 30),

    Order("eb", "Sell", 75.5, 50),
    Order("gdb", "Sell", 76.5, 50),
    Order("bocc", "Sell", 77, 80),
    Order("abc", "Sell", 80, 60),
  )

  val allSets: List[List[Order]] = findSubSet(orders, (0.0, 0.0))


}

对象集合匹配扩展应用程序{
def findSubSet（订单：List[Order]，目标：（Double，Double））：List[List[Order]={
变量收集器：List[List[Order]]=List.empty
if（orders.isEmpty）return List.empty
def findMatches（顺序：List[Order]，索引：Int，current:（Double，Double），goal:（Double，Double），result:List[Order]）{
if（orders.length对于（i有一些方法可以优化和增强代码，如果您将
var收集器
作为函数参数传递给递归函数，这样您就更接近您想要的，并且在函数编程方面也更好（避免
var s
），在函数结束时，如果到达断点，则可以返回
收集器作为结果，而不是返回空的
return
。我想这就是您要查找的

你也可以去掉return关键字。
是的。你需要将head/tail作为一个“外部”递归来递归List[Order]，然后递归一个仍要执行
List[List[Order]
的尾部工作列表（取自orders.tails）每次进入内部递归循环时都会附加到该循环中。
该方法的目的是什么？您试图实现什么？为提高性能，您能做的最大的一件事很可能是不在
列表上使用随机访问模式（即不要编写
命令（i））
如果
订单
是一个
列表
）。同样值得注意的是，它已经是尾部递归的（假设
返回
没有把事情搞砸）。原始代码没有最小化（请参阅），所以我不打算尝试让代码正常工作