Algorithm Scala是在集合中查找对的最佳方法

我正试图找到在Scala集合中查找配对的最佳方法。比如说,

val list = List(1,2,3)

我应该生产这双

(1,2) (1,3) (2,1) (2,3) (3,1) (3,2)

我现在的工具似乎很贵。我如何进一步优化这个

val pairs = list.flatMap { currentElement =>
      val clonedList: mutable.ListBuffer[Int] = list.to[ListBuffer]
      val currentIndex = list.indexOf(currentElement)
      val removedValue = clonedList.remove(currentIndex)

      clonedList.map { y =>
        (currentElement, y)
      }
    }

假设“最佳方式”可以以不同的方式处理（例如，大多数时候我都是这样处理的，让我自己更有效率），我建议以下方法：

val originalList = (1 to 1000) toStream
def orderedPairs[T](list: Stream[T]) = list.combinations(2).map( p => (p(0), p(1)) ).toStream
val pairs = orderedPairs(originalList) ++ orderedPairs(originalList.reverse)
println(pairs.slice(0, 1000).toList)

---

1000个元素需要1秒多一点。

当你说“优化”时，你想优化什么？例如，什么是更重要的CPU或内存？另一个问题是源列表的典型大小是多少？（是几十个元素？几千个？几百万个？）重复的呢？

（1,1,2）

应该产生什么？@Brian该解决方案会产生重复项：（1,1）@Tom我们必须忽略重复项，以便当前元素不与其自身配对这不会产生期望的结果。scala.collection.mutable.HashSet[（Int，Int）]=Set（（3,0），（1,2），（0,2），（3,1），（2,0），（1,0），（2,1），（0,1），（1,3），（3,2），（2,3））True，我返回的是标记，而不是列表中相应的元素。我做了一个小的修改来纠正它。我试图找出一个递归解决方案来解决这个问题，而不是O（n^2）复杂度我添加了一个递归版本，但复杂度仍然是O（n^2）。请注意，由于输出的大小是以输入大小的O（n^2）为单位的，因此不能比O（n^2）的复杂度更好。您的递归版本不是尾部递归的。每次使用map或toList之类的工具时，您都会复制整个列表。顺便说一下，“++”也是一样。这种方法已经在我的笔记本电脑上花费了8秒，n=1000。我已经做了一些轻微的调整，可以解决上面提到的性能问题。

val l = Array(1,2,3,4)
val result = scala.collection.mutable.HashSet[(Int, Int)]()
for(i <- 0 until l.size) {
    for(j<- (i+1) until l.size) {
        result += l(i)->l(j)
        result += l(j)->l(i)
    }
}

def combi(s : Seq[Int]) : Seq[(Int, Int)] = 
    if(s.isEmpty)
         Seq()
    else
        s.tail.flatMap(x=> Seq(s.head -> x, x -> s.head)) ++ combi(s.tail)