Algoritmi di ordinamento che funzionano su grandi quantità di dati

Sto cercando algoritmi di ordinamento che possano funzionare su una grande quantità di dati, cioè che possano funzionare anche quando l'intero set di dati non può essere conservato nella memoria principale contemporaneamente.

L'unico candidato che ho trovato finora è unire l'ordinamento: è possibile implementare l'algoritmo in modo tale da scansionare il tuo set di dati ad ogni unione senza tenere tutti i dati nella memoria principale contemporaneamente. La variazione del tipo di unione che ho in mente è descritta in questo articolo nella sezione Uso con unità nastro .

Penso che questa sia una buona soluzione (con complessità O (nx log (n)) ma sono curioso di sapere se ci sono altri algoritmi di ordinamento (forse più veloci) che possono funzionare su grandi set di dati che non rientrano nella memoria principale.

MODIFICARE

Ecco alcuni dettagli in più, come richiesto dalle risposte:

• I dati devono essere ordinati periodicamente, ad esempio una volta al mese. Non è necessario inserire alcuni record e i dati devono essere ordinati in modo incrementale.
• Il mio file di testo di esempio è di circa 1 GB di testo UTF-8, ma volevo risolvere il problema in generale, anche se il file fosse, diciamo, 20 GB.
• Non si trova in un database e, a causa di altri vincoli, non può esserlo.
• I dati vengono scaricati da altri come file di testo, ho il mio codice per leggere questo file di testo.
• Il formato dei dati è un file di testo: i caratteri di nuova riga sono separatori di record.

Un possibile miglioramento che avevo in mente era quello di dividere il file in file abbastanza piccoli da essere ordinati in memoria e infine unire tutti questi file usando l'algoritmo che ho descritto sopra.

Il riferimento canonico su ordinamento e ricerca è Knuth, Vol. 3 . Inizia lì.

Il libro è stato originariamente riscritto quando i computer erano molto più piccoli e più lenti di quanto non lo siano ora, il che ha reso le tecniche di ordinamento a memoria insufficiente più importanti di quanto si pensi oggi.

L'unione R-Way esterna come nel sortcomando UNIX è una buona alternativa. Dalla tua formulazione, non sono sicuro che si tratti dell'algoritmo che intendevi con "unisci ordine" e, se non lo conosci, dai un'occhiata.

Senza ulteriori dettagli "Unisci ordinamento" è probabilmente la risposta migliore che otterrai, tuttavia puoi implementare qualcosa di molto più intelligente a seconda delle tue esigenze.

Ad esempio, puoi semplicemente creare un indice in memoria del file e quindi copiare tutti i valori contemporaneamente, memorizzando nella cache la posizione di vari valori chiave? 1/2 si adatta alla memoria contemporaneamente o 1/1000000? Se è il secondo, potresti non essere in grado di adattare un indice in memoria, se il primo è possibile ordinare entrambe le metà in modo più efficiente, quindi unirle in un unico ultimo passaggio.

Inferno, dal momento che non hai specificato che è possibile che i tuoi dati siano tutti in un database, in tal caso puoi semplicemente creare una tabella di indice e chiamarla bene (suppongo che non sia così, ma sottolineo solo che la tua situazione è fondamentale per risolvere un problema complicato come questo).

Se vuoi farlo solo una volta e stai cercando un trucco molto veloce, sembra che l'ordinamento di unione esterno sarebbe un buon inizio se stai eseguendo unix (dal momento che è apparentemente integrato)

Se devi mantenerlo in ordine e aggiungi sempre un singolo record, sarà necessario un ordinamento di inserimento (l'aggiunta di un singolo record ai dati ordinati è sempre un ordinamento di inserimento).

Puoi controllare il codice che "Legge" i dati? In tal caso, molte forme di indicizzazione (anziché l'ordinamento spostando i dati sul disco) aiuteranno A MOLTO (sarà effettivamente un requisito assoluto).

Così:

• Sul posto o più file?
• Una volta, periodicamente o tenerlo sempre ordinato?
• Quanto più grande della memoria (quanti carichi di memoria devono superare l'intero set di dati)?
• È in un database? Può essere?
• Controlli il codice che legge i dati o altri scaricheranno direttamente un file?
• Formato del file? (Testo? Record fisso?)
• Altre circostanze speciali di cui non ho chiesto?

Se vuoi davvero una soluzione scalabile dovresti dare un'occhiata a TeraSort, l'implementazione di ordinamento standard con map-riduc; maggiori dettagli su StackOverflow .

Potresti essere interessato a un tipo di bucket . Le prestazioni medie del caso sono tempi lineari.

= O (n + d) n: numero di elementi e d = lunghezza del numero più grande se hai un'intuizione sui tuoi dati, ad es. Se sai quante "cifre" sono lunghe il tuo numero più grande. Quindi se hai 2 milioni di numeri a 6 cifre => 0 (n) quindi lineari.

Utilizzare un algoritmo di ordinamento di tipo merge esterno (se i dati sono continui) o un ordinamento bucket con ordinamento conteggio come implementazione dell'ordinamento per bucket (se i dati sono discreti e distribuiti uniformemente).

Probabilmente l'approccio migliore è quello di creare il proprio file indice / mapping se l'incremento è piccolo.

1. In qualche modo ordina il tuo "database"
2. Assegna un numero intero a ogni voce (1, 2, 3, 4, ..., n) (meglio: usa alcuni indici sparsi)
3. Quando si aggiunge un incremento, basta trovare uno spazio in cui il numero a sinistra è minore o uguale e il numero a destra è maggiore o uguale (non dovrebbe essere difficile con alcune versioni modificate di una ricerca binaria)
4. Inserisci, mentre gli spazi sono sufficientemente grandi, in caso contrario: basta reindicizzare (non ordinare mai più) :-)

Ho appena costruito alcune strutture astratte chiamate big queue e big array per semplificare l'ordinamento e la ricerca di big data su una singola macchina con memoria limitata. Fondamentalmente, l'algoritmo utilizzato è simile a quello che hai menzionato sopra - ordinamento di unione esterna.

Posso ordinare 128 GB di dati (ogni elemento 100 byte) in 9 ore su una singola macchina, e quindi cercare binariamente i dati ordinati quasi senza tempo.

Ecco un post su come cercare i big data usando la mia grande coda open source e le strutture di big array.