Question

P.S。这是我第一次进入SO，如果我做错了请告诉我，我会尽力解决。我花了很多时间试图修复这个算法的实现，而且我在我的智慧结束了！

我目前正在考虑的课程是要求3种基本上不同语言的3种相同二进制搜索算法的实现。对于他们中的一个，我决定采取艰难的方式，并在Erlang拍摄。这是我的代码：

-export(main/1).

main(_) ->
    io:format("Running trials... ~n", []),
    N = [2 bsl (2 * X + 6) || X <- lists:seq(0, 7)],
    lists:foreach(fun(X) -> io:format("~p: ~p ~n", [X, time_search(X)]) end, N).

time_search(Size) ->
    A = list_to_tuple(create_list(Size)),
    Iterations = 2000000,
    time_search(A, Size + 1, 0, Iterations) / Iterations.

time_search(_, _, Sum, 0) -> Sum;
time_search(A, Key, Sum, IterationNum) ->
    Before = now(),
    bin_search(A, Key),
    time_search(A, Key, Sum + timer:now_diff(now(), Before), IterationNum - 1).

create_list(Size) -> lists:seq(1, Size).

bin_search(A, Key) -> bin_search(A, Key, 1, tuple_size(A)).

bin_search(_, _, Lower, Upper) when Lower > Upper -> false;
bin_search(A, Key, Lower, Upper) ->
    Mid = (Upper + Lower) div 2,
    Item = element(Mid, A),
    if
        Key > Item -> bin_search(A, Key, Mid + 1, Upper);
        Key < Item -> bin_search(A, Key, Lower, Mid - 1);
        true -> true
    end.

所以这是输出：

128: 250.8094435 µs
512: 308.7264845 µs
2048: 368.5770285 µs
8192: 425.748134 µs
32768: 477.6267655 µs
131072: 533.340876 µs
524288: 601.023178 µs
2097152: 661.099404 µs

但是与我的ruby实现相比，它显然与O（lg n）相差无几。

编辑：好的，也许不是订单......它看起来非常对数，但它似乎仍然是错误的......

红宝石：

128: 10.4756 µs
512: 11.8172 µs
2048: 13.5328 µs
8192: 15.3139 µs
32768: 17.0915 µs
131072: 18.8721 µs
524288: 21.5237 µs
2097152: 21.7187 µs

以前我使用过Lists，但是我知道那些没有O（1）检索时间，所以我切换到Tuples。是什么导致我的Erlang运行得如此低效？

以防万一，这是我的Ruby实现

def p5_BinarySearch
  n = Array.new(8){ |i| 2 << (2 * i + 6) }
  n.each { |x|
    time = timeSearch x
    puts "#{x}: #{time.round 4} µs"
  }
end

def timeSearch(size)
  values = createArray size
  iterations = 2e7.to_int
  totalTime = 0
  iterations.times{
    before = Time.now
    binarySearch(values, size + 1)
    totalTime += Time.now - before
  }
  totalTime * 1e7 / iterations
end

def createArray(size)
  (1..size).to_a
end

def binarySearch(values, key, low = 0, high = values.length - 1)
  return false if low > high
  mid = (low + high) / 2
  return binarySearch(values, key, mid + 1, high) if key > values[mid]
  return binarySearch(values, key, low, mid - 1) if key < values[mid]
  true
end

if __FILE__ == $0
  puts "Running trials..."
  p5_BinarySearch
end

Answer 1

算法看起来不错，但在这种情况下使用escript解释器是个问题。使用escript -c运行escript，以便在运行之前编译脚本而不是解释，或者按照rvirding的建议创建一个Erlang模块。有了它，你可以看到它执行得非常快。

最好使用os：timestamp（）而不是使用now()来获取准确的计时值。更准确的是使用timer：tc函数。

{Time,_} = timer:tc(fun bin_search/2, [A, Key]),
time_search(A, Key, Sum + Time, IterationNum - 1).

我的机器上的结果是这样的。（没有-c需要大约450微秒）

128: 1.105
512: 1.2005
2048: 1.4015
8192: 1.5145
32768: 1.7225
131072: 1.8515
524288: 2.024
2097152: 2.188

在Erlang中实现高效的二进制搜索

1 个答案: