将 Scala 数组转换为唯一排序列表的有效方法

Question

任何人都可以在 Scala 中优化以下语句：

// maybe large
val someArray = Array(9, 1, 6, 2, 1, 9, 4, 5, 1, 6, 5, 0, 6) 

// output a sorted list which contains unique element from the array without 0
val newList=(someArray filter (_>0)).toList.distinct.sort((e1, e2) => (e1 > e2))

既然性能很关键，有没有更好的办法？

谢谢。

Answer 1

这条简单的代码是迄今为止最快的代码之一：

someArray.toList.filter (_ > 0).sortWith (_ > _).distinct

但到目前为止，明显的赢家是 - 由于我的测量 - Jed Wesley-Smith。也许如果 Rex 的代码是固定的，它看起来会有所不同。

典型免责声明 1 + 2：

1. 我修改了代码以接受一个数组并返回一个列表。
2. 典型的基准注意事项：
   • 这是随机数据，平均分布。对于 100 万个元素，我创建了一个 0 到 100 万之间的 100 万个整数数组。因此，或多或少的零，或多或少的重复，它可能会有所不同。
   • 可能取决于机器等。我使用的是单核 CPU，Intel-Linux-32bit，jdk-1.6，scala 2.9.0.1

这是用于生成图形 (gnuplot) 的底层 benchcoat-code and the concrete code 。 Y 轴：以秒为单位的时间。 X 轴：Array 中 100 000 到 1 000 000 个元素。

更新：

在发现 Rex 代码的问题后，他的代码和 Jed 的代码一样快，但最后一个操作是将他的 Array 转换为 List（以填充我的基准接口）。使用var result = List [Int] 和result = someArray (i) :: result 可以加快他的代码速度，因此它的速度大约是 Jed-Code 的两倍。

另一个可能很有趣的发现是：如果我按照过滤器/排序/不同 (fsd) => (dsf, dfs, fsd, ...) 的顺序重新排列我的代码，所有 6 种可能性都没有显着差异.

Answer 2

我没有测量，但我和邓肯在一起，排序然后使用类似的东西：

util.Sorting.quickSort(array)
array.foldRight(List.empty[Int]){ 
  case (a, b) => 
    if (!b.isEmpty && b(0) == a) 
      b 
    else 
      a :: b 
}

理论上这应该是相当有效的。

Answer 3

如果没有基准测试，我无法确定，但我认为以下方法非常有效：

val list = collection.SortedSet(someArray.filter(_>0) :_*).toList

还可以尝试在您的版本中的 someArray 之后添加 .par。它不能保证更快，它可能是。您应该运行基准测试和实验。

sort 已弃用。请改用.sortWith(_ > _)。

Answer 4

装箱原语会给您带来 10-30 倍的性能损失。因此，如果你真的性能有限，你会想要处理原始原始数组：

def arrayDistinctInts(someArray: Array[Int]) = {    
  java.util.Arrays.sort(someArray)
  var overzero = 0
  var ndiff = 0
  var last = 0
  var i = 0
  while (i < someArray.length) {
    if (someArray(i)<=0) overzero = i+1
    else if (someArray(i)>last) {
      last = someArray(i)
      ndiff += 1
    }
    i += 1
  }
  val result = new Array[Int](ndiff)
  var j = 0
  i = overzero
  last = 0
  while (i < someArray.length) {
    if (someArray(i) > last) {
      result(j) = someArray(i)
      last = someArray(i)
      j += 1
    }
    i += 1
  }
  result
}

如果你小心点，你会得到比这稍微好一点的（请注意，我在脑海中输入了这个；我可能打错了一些东西，但这是要使用的样式），但如果你发现现有版本太慢了，这应该至少快 5 倍，甚至可能更多。

---

编辑（除了修复之前的代码，使其实际工作）：

如果您坚持以列表结尾，那么您可以随时构建列表。您可以递归地执行此操作，但我认为在这种情况下它不会比迭代版本更清晰，所以：

def listDistinctInts(someArray: Array[Int]): List[Int] = {
  if (someArray.length == 0 || someArray(someArray.length-1) <= 0) List[Int]()
  else {
    java.util.Arrays.sort(someArray)
    var last = someArray(someArray.length-1)
    var list = last :: Nil
    var i = someArray.length-2
    while (i >= 0) {
      if (someArray(i) < last) {
        last = someArray(i)
        if (last <= 0) return list;
        list = last :: list
      }
      i -= 1
    }
    list
  }
}

此外，如果您不能通过排序破坏原始数组，那么您最好复制数组并破坏副本（基元的数组副本非常快）。

请记住，根据数据的性质，有些特殊情况的解决方案速度要快得多。例如，如果您知道自己有一个长数组，但数字的范围很小（例如 -100 到 100），那么您可以使用 bitset 来跟踪您遇到了哪些。

Answer 5

为了效率，看你的大值：

val a = someArray.toSet.filter(_>0).toArray
java.util.Arrays.sort(a) // quicksort, mutable data structures bad :-)
res15: Array[Int] = Array(1, 2, 4, 5, 6, 9)

请注意，这是使用 qsort 对未装箱数组进行排序。

Answer 6

我无法衡量，但还有一些建议......

在转换为列表之前对数组进行适当的排序可能会更有效，您可能会考虑手动从排序列表中删除 dup，因为它们将组合在一起。在排序之前或之后删除 0 的成本也取决于它们与其他条目的比率。

Answer 7

将所有内容添加到排序集中怎么样？

val a = scala.collection.immutable.SortedSet(someArray filter (0 !=): _*)

当然，您应该对代码进行基准测试，以检查什么更快，更重要的是，这确实是一个热点。