Effizientes Entfernen von Duplikaten mit geringem Speicheraufwand

Ich möchte eine Liste von Ganzzahlen effizient nach Duplikaten filtern, sodass nur die resultierende Menge gespeichert werden muss.

Ein Weg dies kann gesehen werden:

wir haben einen Bereich von ganzen Zahlen mit groß (sagen wir ) $S = \{1, \dots{}, N\}$ $N$ $2^{40}$
wir haben eine Funktion mit angeblich vielen Kollisionen (die Bilder sind gleichmäßig in ) $f : S \to S$ $S$
wir müssen dann speichern , das heißt $f[S]$ $\{f(x) | x \in S\}$

Ich habe eine ziemlich genaue (probabilistische) Schätzung dessen, was ist und kann daher Datenstrukturen im Voraus zuweisen (sagen wir ). $|f[S]|$ $|f[S]| \approx 2^{30}$

Ich hatte einige Ideen, bin mir aber nicht sicher, was der beste Ansatz wäre:

Ein Bitset kommt nicht in Frage, da der Eingabesatz nicht in den Speicher passt.
eine Hash-Tabelle, aber (1) es erfordert etwas Speicher-Overhead, sagen wir 150% von und (2) die Tabelle muss beim Erstellen untersucht werden, was aufgrund des Speicheraufwands zusätzliche Zeit erfordert. $|f[S]|$
eine "on the fly" -Sorte, vorzugsweise mit -Komplexität (Nichtvergleichssortierung). In Bezug darauf bin ich mir nicht sicher, was der Hauptunterschied zwischen Bucket Sort und Flashsort ist . $O(N)$
Ein einfaches Array mit einem binären Suchbaum, für das jedoch erforderlich ist . $O(N \log |f[S]|)$
Möglicherweise kann die Verwendung von Bloom-Filtern oder einer ähnlichen Datenstruktur hilfreich sein, um das Problem zu lösen (mit falsch positiven Ergebnissen).

Einige Fragen zu Stackoverflow scheinen sich mit solchen Dingen zu befassen ( /programming/12240997/sorting-array-in-on-run-time , /programming/3951547/java) -array-find-duplicates ), aber keines scheint meinen Anforderungen zu entsprechen.

algorithms data-structures sorting

— doc
quelle

Müssen Sie f [S] aufzählen (was auch immer es ist) oder schnell erkennen können, ob sich ein x darin befindet?

— Gilles 'SO - hör auf böse zu sein'

@ Gilles: Ich glaube, da in f [S] keine offensichtliche Struktur gefunden werden kann, sind die beiden Lösungen äquivalent.

— Doc

Ihre Zahlen summieren sich nicht. Das erwartete Bild einer Zufallsfunktion in einer Domäne der Größe

ist in etwa

. Ein weiteres Problem ist, dass das Durchlaufen von

zu lange dauern wird, es sei denn, Sie verfügen über einen Supercomputer oder einen großen Cluster.

N

$N$

(1 - 1 / e) N

$(1-1/e)N$

2^{56}

$2^{56}$

— Yuval Filmus

Die Zeit für den binären Suchbaum wäre

, was in der Praxis nahe an

kann oder nicht, aber immer noch genauer ist.

O (N \log | f [S] |)

$O(N \log |f[S]|)$

O (N \log N)

$O(N\log N)$

— jmad

ein linearer Zeitalgorithmus mit

nicht auch unerschwinglich? (Nach meinen Berechnungen würden Sie gut 2 Jahre brauchen, selbst wenn Sie ein Element von

in 1 Nanosekunde betrachten!).

N \sim 2^{56}

$N \sim 2^{56}$

S

$S$

— Aryabhata

Warum nicht Mülleimer und Kette?

Die Idee besteht darin, positive ganze Zahlen, die durch Bits darstellbar sind, in einem Array von Einträgen zu speichern, die Wertebereiche darstellen: Eintrag , , repräsentiert den Bereich . Für jede wir schreiben $n = k+m$ $A$ $2^k$ $A[y]$ $y \ge 0$ $[2^m y, 2^m(y+1)-1]$ $1 \le x \lt 2^n$ , wo hat Bits und hat Bits. Versuchen Sie, (nicht !) An Position zu speichern: $x = 2^m y + z$ $y$ $k$ $z$ $m$ $z$ $x$ $y$

Wenn bereits ist, tun Sie nichts: ist ein Duplikat. $A[y]=z$ $x$
Wenn nicht initialisiert ist, speichern Sie bei . $A[y]$ $z$ $A[y]$
Andernfalls speichert einen Index in eine separate Anordnung zur Ketten des ‚s (die bei kollidiert ist ) in verknüpften Listen. Sie müssen die Liste mit der Überschrift linear durchsuchen und je nachdem, was die Suche aufdeckt, möglicherweise in die Liste einfügen . $z$ $y$ $A[y]$ $z$

Am Ende, ist leicht durch Einschleifen durch die initialisierten Einträge zu erholen und - lediglich durch zwei Bitstrings Verketten - Zusammenbauen jeden an der Stelle gefunden (entweder direkt oder innerhalb einer Kette referenzierten dort) in die ursprünglichen Wert . $f(S)$ $A$ $z$ $y$ $x = 2^m y + z$

Wenn die Verteilung nahezu gleichmäßig ist und überschreitet , kommt es zu keiner starken Verkettung (dies kann auf die übliche Weise beurteilt werden), und die Ketten sind tendenziell kurz. Wenn die Verteilung ungleichmäßig ist, funktioniert der Algorithmus immer noch, kann jedoch ein quadratisches Timing erreichen. Wenn dies möglich ist, verwenden Sie etwas Effizienteres als Ketten (und zahlen Sie ein wenig Overhead für die Lagerung). $2^k$ $N$

Der benötigte Speicher beträgt höchstens Bits für und Bits für die Ketten (unter der Annahme von ). Dies ist genau der Speicherplatz, der zum Speichern von Werten mit jeweils Bits benötigt wird. Wenn Sie von der Einheitlichkeit überzeugt sind, können Sie den Speicher für die Ketten zu wenig zuordnen. Wenn eine Ungleichmäßigkeit möglich ist, möchten Sie möglicherweise erhöhen und die Kettenspeicherung vollständig befürworten. $2^n$ $A$ $2^{2k}$ $m \le k$ $2^k$ $n$ $k$

Eine alternative Art, über diese Lösung nachzudenken, besteht darin, dass es sich um eine Hash-Tabelle mit einer besonders schönen Hash-Funktion handelt (nehmen Sie die höchstwertigen Bits), und aus diesem Grund müssen wir nur die niedrigstwertigen Bits in speichern Der Tisch. $k$ $m=n-k$

Es gibt Möglichkeiten, Speicher für die Ketten mit dem Speicher für zu überlagern, aber es scheint die Mühe nicht wert zu sein, da dies nicht viel Platz spart (vorausgesetzt, ist viel kleiner als ) und die Entwicklung des Codes erschwert. debuggen und pflegen. $A$ $m$ $k$

— whuber
quelle

Ich denke, der vorletzte Absatz ist hier der zentrale und sollte wahrscheinlich ganz oben stehen (als Idee). Ich kenne den Begriff "bin and chain" nicht (obwohl er nach dem Lesen des Beitrags sinnvoll ist). Diese Idee kann auf Versuche ausgedehnt werden .

— Raphael

Dies ist also

bei schlecht verteilten Eingängen. Ich sehe nicht, wie effizient das ist.

Θ (n^{2})

$\Theta(n^2)$

— Einpoklum

@einpoklum Diese Antwort beschreibt explizit die Bedingungen, unter denen die Lösung effizient ist.

— Whuber