Grande O degli array JavaScript

Gli array in JavaScript sono molto facili da modificare aggiungendo e rimuovendo elementi. In qualche modo maschera il fatto che la maggior parte degli array di lingue sono di dimensioni fisse e richiedono operazioni complesse per il ridimensionamento. Sembra che JavaScript renda facile scrivere codice array con prestazioni scadenti. Questo porta alla domanda:

Quali prestazioni (in termini di grande complessità del tempo O) posso aspettarmi dalle implementazioni JavaScript per quanto riguarda le prestazioni dell'array?

Presumo che tutte le implementazioni JavaScript ragionevoli abbiano al massimo le seguenti grandi O.

• Accesso - O (1)
• Aggiunta - O (n)
• Anteprime - O (n)
• Inserimento - O (n)
• Cancellazione - O (n)
• Scambio - O (1)

JavaScript ti consente di precompilare un array fino a una certa dimensione, utilizzando la new Array(length)sintassi. (Domanda bonus: sta creando un array in questo modo O (1) o O (n)) Questo è più simile a un array convenzionale e, se usato come array pre-dimensionato, può consentire l'aggiunta di O (1). Se viene aggiunta la logica del buffer circolare, è possibile ottenere O (1) anteposto. Se viene utilizzato un array in espansione dinamica, O (log n) sarà il caso medio per entrambi.

Posso aspettarmi prestazioni migliori per alcune cose rispetto alle mie ipotesi qui? Non mi aspetto che nulla sia delineato in nessuna specifica, ma in pratica potrebbe essere che tutte le principali implementazioni utilizzino array ottimizzati dietro le quinte. Ci sono array in espansione dinamica o altri algoritmi che migliorano le prestazioni al lavoro?

PS

Il motivo per cui mi chiedo questo è che sto ricercando alcuni algoritmi di ordinamento, la maggior parte dei quali sembra presumere che l'aggiunta e l'eliminazione siano operazioni O (1) quando descrivo la loro O grande complessiva.

_{NOTA: sebbene questa risposta fosse corretta nel 2012, i motori utilizzano oggi rappresentazioni interne molto diverse sia per gli oggetti che per gli array. Questa risposta può o non può essere vera.}

A differenza della maggior parte dei linguaggi, che implementano array con, beh, array, in Javascript gli array sono oggetti e i valori sono memorizzati in una tabella hash, proprio come i normali valori degli oggetti. Come tale:

• Accesso - O (1)
• Aggiunta - Amortized O (1) (a volte è necessario ridimensionare la tabella hash; di solito è richiesto solo l'inserimento)
• Prepending - O (n) via unshift, poiché richiede la riassegnazione di tutti gli indici
• Inserimento - Ammortizzato O (1) se il valore non esiste. O (n) se si desidera spostare i valori esistenti (ad esempio, utilizzando splice).
• Cancellazione - Ammortizzato O (1) per rimuovere un valore, O (n) se si desidera riassegnare gli indici tramite splice.
• Scambio - O (1)

In generale, l'inserimento o il disinserimento di qualsiasi chiave in un dict viene ammortizzato con O (1), e lo stesso vale per gli array, indipendentemente da quale sia l'indice. Qualsiasi operazione che richiede la rinumerazione dei valori esistenti è O (n) semplicemente perché è necessario aggiornare tutti i valori interessati.

garanzia

Non esiste una garanzia di complessità temporale specificata per qualsiasi operazione su array. Le prestazioni degli array dipendono dalla struttura dati sottostante scelta dal motore. I motori potrebbero anche avere rappresentazioni diverse e passare da una all'altra a seconda di determinate euristiche. La dimensione dell'array iniziale potrebbe o non potrebbe essere tale euristica.

la realtà

Ad esempio, V8 utilizza (ad oggi) sia tabelle hash che elenchi di array per rappresentare gli array. Ha anche varie rappresentazioni differenti per gli oggetti, quindi gli array e gli oggetti non possono essere confrontati. Pertanto l'accesso all'array è sempre migliore di O (n) e potrebbe anche essere veloce come l'accesso all'array C ++. L'aggiunta è O (1), a meno che non si raggiunga la dimensione della struttura dati e questa debba essere scalata (che è O (n)). La preparazione è peggio. La cancellazione può essere anche peggiore se fai qualcosa come delete array[index](non!), Poiché ciò potrebbe costringere il motore a cambiare la sua rappresentazione.

consigli

Usa array per strutture dati numeriche. Ecco a cosa sono destinati. È per questo che i motori li ottimizzeranno. Evita gli array sparsi (o, se devi, aspettati prestazioni peggiori). Evita gli array con tipi di dati misti (poiché ciò rende le rappresentazioni interne più complesse ).

Se vuoi davvero ottimizzare per un determinato motore (e versione), controlla il suo codice sorgente per la risposta assoluta.