【问题标题】:data structures: iterating over two arrays vs converting to sets and performing intersect operation in ruby数据结构:遍历两个数组与转换为集合并在 ruby​​ 中执行相交操作
【发布时间】:2012-02-24 19:17:54
【问题描述】:

假设我有a1 和a2:

a1 = [1,2,3]
a2 = [4,2,5]

要查看a1 是否与a2 共享任何元素,我可以遍历每个元素并比较每个元素:

def intersect?(x,y)
  a1.each do |x|
    a2.each do |y|
      if x == y return true
    end
  end
  false
end

但更简单的是,(a1.to_set & a2.to_set).present? 给了我同样的答案。

我假设设置操作更快更高效?如果这是真的,考虑到每个阵列上的.to_set 操作的开销(如果有的话)是否仍然正确?

tia

【问题讨论】:

  • 你为什么要把它转换成 to_set 。您可以立即使用 a1 & a2 并将返回一个包含两个数组之间所有公共元素的数组
  • 但是对数组使用 & 运算符是否会将其转换为一个集合,或者只是有效地在每个数组中执行每个循环?如果是第一个,它与每个循环一样低效(且缓慢)。
  • Array的&方法是用C实现的。

标签: ruby arrays set


【解决方案1】:

steenslag 的回答有一个有趣的观察结果,即 array & array 比 set & set 更快。看起来大部分惩罚似乎是从要枚举的第一组的底层哈希中获取密钥的费用。将数组用于左侧操作并设置用于右侧的混合方法更快。如果你只想知道有没有交叉点,同样的方法#any?会更快:

#!/usr/bin/env ruby

require 'set'
require 'benchmark'

f = 10_000
ar1 = (1..(10*f)).to_a # 100_000 elements
ar2 = ((5*f)..(15*f)).to_a # also 100_000 elements
set1 = ar1.to_set
set2 = ar2.to_set
n = 10

Benchmark.bm(10) do |testcase|
  testcase.report('Array'){ n.times{ ar1 & ar2 } }
  testcase.report('Set'){ n.times{ set1 & set2 } }
  testcase.report('Set2'){ n.times{ ar1.select{ |element| set2.include? element } } }
  testcase.report('Set2present'){ n.times{ ar1.any?{ |element| set2.include? element } } }
end


$ ruby -v => ruby 1.9.2p290 (2011-07-09 revision 32553) [x86_64-darwin10.8.0]

                user     system      total        real
Array       0.680000   0.030000   0.710000 (  0.720882)
Set         1.130000   0.020000   1.150000 (  1.150571)
Set2        0.430000   0.000000   0.430000 (  0.434957)
Set2present  0.210000   0.010000   0.220000 (  0.220990)

【讨论】:

  • “从要枚举的第一组的底层哈希中获取密钥的费用。”反对这一点:set1 & ar2 比set1 & set2 版本更快。我认为 Set 比预期的要慢,因为它是在 Ruby 中实现的——在你到达散列之前,Ruby 太多了。有趣的研究,+1。
  • 是的,我是在猜测而不是看代码。 Set 被实现为 c 实现的 Hash 上的薄红宝石单板。 perf sink 似乎是 Set#& github.com/ruby/ruby/blob/trunk/lib/set.rb#L338 的实现,它枚举右侧 arg 并 #adds 到一个新集合,如果它包含在左侧 arg 中,而不是使用 c 实现的 select,这将避免一些额外的簿记和 ruby级别方法调度github.com/ruby/ruby/blob/trunk/hash.c#L1004github.com/ruby/ruby/blob/trunk/hash.c#L194
  • 我希望我能投票两次!左侧使用数组,右侧设置和任何优化?方法很棒。值得指出的是,对于较小的集合,结果会翻转(使用集合比使用数组更快),所以如果你真的很在意,总是值得根据你的实际数据集进行一些优化
【解决方案2】:

对于相当大的集合,Array 的 & 方法比 Set 的方法更快:

require 'set'
require 'benchmark'
f = 10_000
ar1 = (1..(10*f)).to_a # 100_000 elements
ar2 = ((5*f)..(15*f)).to_a # also 100_000 elements
set1 = ar1.to_set
set2 = ar2.to_set
n = 10

Benchmark.bm(10) do |testcase|
  testcase.report('Array'){ n.times{ ar1 & ar2 } }
  testcase.report('Set'){ n.times{ set1 & set2 } }
end

结果:

                 user     system      total        real
Array        1.380000   0.030000   1.410000 (  1.414634)
Set          2.310000   0.020000   2.330000 (  2.359317)

【讨论】:

【解决方案3】:

对于大型数组应该更快。您的方法在 O(m*n) 时间内运行,因为它必须遍历两个数组。对于每个包含 3 个元素的表格,这基本上可以忽略不计,但对于较大的表格,它可能非常昂贵。

第二种方法将使用更快的哈希查找,但首先必须将数组放入集合中。

您应该做的是使用您希望在应用程序中看到的大小数组尝试这两种方法,看看哪种方法更快。如果它们的大小大致相同,您可以选择您认为更清晰的一个。

【讨论】:

    【解决方案4】:

    我只想详细说明 steenslag 和 dbenhur 的出色答案。具体来说,我想知道SortedSet 是否会表现得更好。最初让我感到惊讶的是,Ruby Set 类型没有实现为排序集,因为我来自 C++; STL 默认使用有序集,如果您不想排序,通常必须指定 unordered_set。

    我还想知道集合的大小是否会产生影响,正如其他一些答案中所建议的那样。

    require 'set'
    require 'benchmark'
    
    f = 20 # 10_000
    ar1 = (1..(10*f)).to_a # 100_000 elements
    ar2 = ((5*f)..(15*f)).to_a # also 100_000 elements
    set1 = ar1.to_set
    set2 = ar2.to_set
    sset1 = SortedSet.new(ar1)
    sset2 = SortedSet.new(ar2)
    n = 20000 # 10
    
    Benchmark.bm(10) do |testcase|
      testcase.report('Array'){ n.times{ ar1 & ar2 } }
      testcase.report('Set'){ n.times{ set1 & set2 } }
      testcase.report('SortedSet') { n.times{ sset1 & sset2 } }
      testcase.report('Set2'){ n.times{ ar1.select{ |element| set2.include? element } } }
      testcase.report('Set2present'){ n.times{ ar1.any?{ |element| set2.include? element } } }
    
      testcase.report('SortedSet2'){ n.times{ ar1.select{ |element| sset2.include? element } } }
      testcase.report('SortedSet2present'){ n.times{ ar1.any?{ |element| sset2.include? element } } }
    end
    

    这是f=20; n=20000 的结果:

    $ ruby set.rb
                     user     system      total        real
    Array        1.950000   0.010000   1.960000 (  1.963030)
    Set          3.330000   0.040000   3.370000 (  3.374105)
    SortedSet    3.810000   0.040000   3.850000 (  3.860340)
    Set2         1.410000   0.010000   1.420000 (  1.427221)
    Set2present  0.760000   0.000000   0.760000 (  0.759447)
    SortedSet2   1.420000   0.000000   1.420000 (  1.446559)
    SortedSet2present  0.770000   0.010000   0.780000 (  0.770939)
    

    这是f=10000; n=10的结果:

    $ ruby set.rb
                     user     system      total        real
    Array        0.910000   0.020000   0.930000 (  0.939325)
    Set          1.270000   0.010000   1.280000 (  1.293581)
    SortedSet    1.220000   0.010000   1.230000 (  1.229650)
    Set2         0.550000   0.000000   0.550000 (  0.552708)
    Set2present  0.290000   0.010000   0.300000 (  0.291845)
    SortedSet2   0.550000   0.000000   0.550000 (  0.561049)
    SortedSet2present  0.330000   0.000000   0.330000 (  0.339950)
    

    因此,对于大型集合,看起来 Set 比 SortedSet 做得更好;对于较小的集合,SortedSet 比Set 做得更好。当使用 & 表示法时,Array 比任何一个都快。看起来SortedSet2present 处理大集合的效率明显更高,而Set2present 处理小集合的效率更高。

    而Set 是使用Hash 实现的,SortedSet 是RBTree(用C 实现)。在这两种情况下,& 都是用 Ruby 而不是 C 实现的。

    【讨论】:

    • 简短说明:我重新阅读了Set 和SortedSet 的源代码,显然SortedSet 仅在调用require 'rbtree' 时才使用RBTree结果为LoadError。否则它会退回到Set 使用的任何东西。所以这可能对我的基准测试产生了不利影响,因为当时我没有安装rbtree。我尝试使用已经需要的rbtree 重新运行它,但没有发现显着差异,但我不确定我的 Ruby 安装是否正确加载它。
    【解决方案5】:

    事实上,对于这么小的数组,它们要么基本相同,要么列表比集合快。

    一个体面的集合实现将比您执行列表操作更快地执行集合操作,但有一些开销。如果您想知道您的实现将做什么,请使用大集合/列表并进行测试。

    【讨论】:

    • 在微基准测试中,我观察到 Set#include?总是比 Array#include?即使对于基数 == 1。由于 Set 实现的枚举数选择,这种优势并不总是转化为联合和交集操作。
    • 我投了反对票,因为它实际上与基准相反。
    猜你喜欢
    • 2016-02-02
    • 1970-01-01
    • 1970-01-01
    • 2017-06-28
    • 1970-01-01
    • 1970-01-01
    • 2017-10-27
    • 2017-04-08
    • 2011-11-10
    相关资源
    最近更新 更多