Nhận chỉ mục của phần tử mảng nhanh hơn O (n)

Cho trước tôi có một mảng HUGE và một giá trị từ nó. Tôi muốn lấy chỉ mục của giá trị trong mảng. Có cách nào khác, thay vì sau đó gọi Array#indexđể lấy nó? Vấn đề xuất phát từ nhu cầu giữ một mảng thực sự lớn và gọi Array#indexsố lần khổng lồ.

Sau một vài lần thử, tôi nhận thấy rằng bộ nhớ đệm lập chỉ mục bên trong các phần tử bằng cách lưu trữ cấu trúc với (value, index)các trường thay vì giá trị của chính nó mang lại một bước tiến lớn về hiệu suất (chiến thắng gấp 20 lần).

Tôi vẫn tự hỏi liệu có cách nào thuận tiện hơn để tìm chỉ mục của phần tử en mà không cần bộ nhớ đệm (hoặc có một kỹ thuật bộ nhớ đệm tốt sẽ tăng hiệu suất).

Chuyển mảng thành hàm băm. Sau đó, hãy tìm chìa khóa.

array = ['a', 'b', 'c']
hash = Hash[array.map.with_index.to_a]    # => {"a"=>0, "b"=>1, "c"=>2}
hash['b'] # => 1

Tại sao không sử dụng index hoặc rindex?

array = %w( a b c d e)
# get FIRST index of element searched
puts array.index('a')
# get LAST index of element searched
puts array.rindex('a')

chỉ mục: http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-index

rindex: http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-rindex

Các câu trả lời khác không tính đến khả năng một mục nhập được liệt kê nhiều lần trong một mảng. Thao tác này sẽ trả về một hàm băm trong đó mỗi khóa là một đối tượng duy nhất trong mảng và mỗi giá trị là một mảng chỉ số tương ứng với vị trí của đối tượng:

a = [1, 2, 3, 1, 2, 3, 4]
=> [1, 2, 3, 1, 2, 3, 4]

indices = a.each_with_index.inject(Hash.new { Array.new }) do |hash, (obj, i)| 
    hash[obj] += [i]
    hash
end
=> { 1 => [0, 3], 2 => [1, 4], 3 => [2, 5], 4 => [6] }

Điều này cho phép tìm kiếm nhanh các mục nhập trùng lặp:

indices.select { |k, v| v.size > 1 }
=> { 1 => [0, 3], 2 => [1, 4], 3 => [2, 5] }

Có lý do chính đáng để không sử dụng hàm băm không? Tra cứu O(1)so O(n)với mảng.

Nếu đó là một mảng được sắp xếp, bạn có thể sử dụng thuật toán tìm kiếm Binary ( O(log n)). Ví dụ: mở rộng lớp Mảng với chức năng này:

class Array
  def b_search(e, l = 0, u = length - 1)
    return if lower_index > upper_index

    midpoint_index = (lower_index + upper_index) / 2
    return midpoint_index if self[midpoint_index] == value

    if value < self[midpoint_index]
      b_search(value, lower_index, upper_index - 1)
    else
      b_search(value, lower_index + 1, upper_index)
    end
  end
end

Kết hợp câu trả lời của @ sawa và nhận xét được liệt kê ở đó, bạn có thể triển khai chỉ mục và rindex "nhanh" trên lớp mảng.

class Array
  def quick_index el
    hash = Hash[self.map.with_index.to_a]
    hash[el]
  end

  def quick_rindex el
    hash = Hash[self.reverse.map.with_index.to_a]
    array.length - 1 - hash[el]
  end
end

Nếu mảng của bạn có thứ tự tự nhiên, hãy sử dụng tìm kiếm nhị phân.

Sử dụng tìm kiếm nhị phân.

Tìm kiếm nhị phân có O(log n)thời gian truy cập.

Đây là các bước về cách sử dụng tìm kiếm nhị phân,

• Thứ tự của bạn mảng là gì? Ví dụ, nó có được sắp xếp theo tên không?
• Sử dụng bsearchđể tìm các phần tử hoặc chỉ số

Mã ví dụ

# assume array is sorted by name!

array.bsearch { |each| "Jamie" <=> each.name } # returns element
(0..array.size).bsearch { |n| "Jamie" <=> array[n].name } # returns index

Tôi vẫn tự hỏi liệu có cách nào thuận tiện hơn để tìm chỉ mục của phần tử en mà không cần bộ nhớ đệm (hoặc có một kỹ thuật bộ nhớ đệm tốt sẽ tăng hiệu suất).

Bạn có thể sử dụng tìm kiếm nhị phân (nếu mảng của bạn có thứ tự và các giá trị bạn lưu trữ trong mảng có thể so sánh được theo một cách nào đó). Để điều đó hoạt động, bạn cần có khả năng cho tìm kiếm nhị phân biết liệu nó nên tìm kiếm "bên trái" hay "bên phải" của phần tử hiện tại. Nhưng tôi tin rằng không có gì sai khi lưu trữ indextại thời điểm chèn và sau đó sử dụng nó nếu bạn đang lấy phần tử từ cùng một mảng.