Ottieni l'indice dell'elemento dell'array più velocemente di O (n)

Dato che ho una matrice ENORME e un valore da essa. Voglio ottenere l'indice del valore in array. C'è un altro modo, piuttosto che chiamare Array#indexper ottenerlo? Il problema deriva dalla necessità di mantenere un array davvero enorme e chiamare Array#indexun'enorme quantità di volte.

Dopo un paio di tentativi ho scoperto che la memorizzazione nella cache degli indici all'interno degli elementi memorizzando strutture con (value, index)campi invece del valore stesso dà un enorme passo in avanti nelle prestazioni (20 volte la vittoria).

Tuttavia mi chiedo se ci sia un modo più conveniente per trovare index of en element senza caching (o se c'è una buona tecnica di caching che aumenterà le prestazioni).

Converti l'array in un hash. Quindi cerca la chiave.

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

Perché non utilizzare index o 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')

indice: 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

Altre risposte non tengono conto della possibilità di una voce elencata più volte in una matrice. Questo restituirà un hash in cui ogni chiave è un oggetto univoco nell'array e ogni valore è un array di indici che corrisponde a dove risiede l'oggetto:

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] }

Ciò consente una rapida ricerca di voci duplicate:

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

C'è una buona ragione per non usare un hash? Le ricerche sono O(1)rispetto O(n)all'array.

Se è un array ordinato, potresti usare un algoritmo di ricerca binaria ( O(log n)). Ad esempio, estendendo la classe Array con questa funzionalità:

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

Prendendo una combinazione della risposta di @ sawa e del commento qui elencato, potresti implementare un indice "rapido" e un rindex sulla classe dell'array.

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

Se il tuo array ha un ordine naturale usa la ricerca binaria.

Usa la ricerca binaria.

La ricerca binaria ha O(log n)tempo di accesso.

Ecco i passaggi su come utilizzare la ricerca binaria,

• Qual è l'ordine del tuo array? Ad esempio, è ordinato per nome?
• Da utilizzare bsearchper trovare elementi o indici

Esempio di codice

# 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

Tuttavia mi chiedo se ci sia un modo più conveniente per trovare index of en element senza caching (o se c'è una buona tecnica di caching che aumenterà le prestazioni).

È possibile utilizzare la ricerca binaria (se l'array è ordinato ei valori memorizzati nell'array sono in qualche modo confrontabili). Affinché funzioni, devi essere in grado di dire alla ricerca binaria se deve guardare "a sinistra" o "a destra" dell'elemento corrente. Ma credo che non ci sia nulla di sbagliato nel memorizzare il indexmomento dell'inserimento e quindi utilizzarlo se si ottiene l'elemento dallo stesso array.