Devo deduplicare un ampio elenco di parole. Ho provato diversi comandi e ho fatto alcune ricerche qui e qui in cui spiegano che il modo più veloce per deduplicare un elenco di parole sembra usare awk.

awk -> O (n)? ordina -> O (n registro n)?

Tuttavia ho scoperto che questo sembra non essere vero. Ecco i miei risultati dei test:

sort -u input.txt -o output.txt 

reale 0m12.446s
utente 0m11.347s
sys 0m0.906s

awk '!x[$0]++' input.txt > output.txt

reale 0m47.221s
utente 0m45.419s
sys 0m1.260s

Quindi usare sort -u è 3,7 volte più veloce. Perchè è questo? esiste un metodo ancora più veloce per eseguire la deduplicazione?

*********** Aggiornare ********

Come qualcuno ha sottolineato nei commenti, potrebbe essere che la mia lista di parole fosse già stata ordinata in una certa misura. Per escludere questa possibilità ho generato due liste di parole usando questo script Python .

Elenco1 = 7 Mb
Elenco2 = 690 Mb

Risultati AWK:
List1
real 0m1.643s
user 0m1.565s
sys 0m0.062s

List2
reali 2m6.918s
utente 2m4.499s
sys 0m1.345s

ORDINA risultati:
List1
real 0m0.724s
user 0m0.666s
sys 0m0.048s

List2
reali 1m27.254s
utente 1m25.013s
sys 0m1.251s

Stai ponendo la domanda sbagliata, o ponendo la domanda in modo errato e nello stack sbagliato, questa è una domanda migliore da porre nella programmazione / stack-overflow affinché le persone possano darti risposte basate sugli algoritmi utilizzati all'interno di awk e sort.

PS: fai anche il necessario con nawk, mawk e gawk per darci qualche dettaglio in più in "zona in";) e esegui le corse come 100 volte ciascuna con la deviazione minima, massima, media e standard.

Comunque sia, torniamo alla domanda attuale, da CompSci 210, riguarda gli algoritmi utilizzati. L'ordinamento fa uso di diversi, a seconda delle dimensioni e dei vincoli di memoria che colpisce per salvare i file sul disco in file temporanei da unire in ordine una volta esaurita la memoria, e dovrai guardare nel codice sorgente per vedere cosa lo specifico comando sort (1) utilizza sul sistema operativo specifico su cui lo stai eseguendo, ma per esperienza sta caricando nella memoria il più possibile, esegui un rapido ordinamento su di esso, scrivi sul disco, risciacqua ripetizione e al alla fine eseguirà una fusione-ordinamento dei piccoli file ordinati. Quindi qui avrai O (n * log2 (N)) per le parti, quindi un'operazione di fusione O (n * log (n)) approssimativa

awk: il meccanismo x [$ 0] ++ è "supponiamo" di utilizzare l'hash. MA il problema con l'hash, una presunta operazione di "ricerca" O (1), è la collisione e la gestione delle collisioni. Ciò potrebbe causare un problema quando i dati non sono ben distribuiti, né riempire i secchi ecc. E in elenchi di grandi dimensioni, l'hash potrebbe essere un grosso problema di memoria se la gestione delle collisioni non viene eseguita correttamente (e potrebbe essere necessario ottimizzare gli algoritmi di hashing per i dati previsti), quindi è necessario esaminare le prestazioni delle funzioni di hashing effettive e quindi O (1) potrebbe essere più vicino a una O (log (n)) per gli inserti (Ie. O (1) per la prima ricerca, e se NON esiste aggiungilo che potrebbe essere O (log (n))), e che quindi n * O (1) diventa un * O (log (n)) = > O (n * log (n)), per non parlare del fatto che stai anche facendo le cose in modo "interpretato" :)

La differenza di velocità è perché 'sort' è un comando ( link ), mentre 'awk' è un linguaggio di programmazione ( link ).

Il comando 'sort' prende input e restituisce output. Considerando che 'awk' è un linguaggio di programmazione, che prima interpreta il codice (comando terminale), quindi inizia l'elaborazione su di esso. Semplice come quella.