Düşük bellek yükü ile kopyaları verimli bir şekilde kaldırma

Ben sadece sonuç kümesi saklanması gereken bir şekilde kopyalar için bir tamsayı listesi verimli bir şekilde filtre istiyorum.

Bunun bir yolu görülebilir:

• bir dizi tamsayı var $S = \{1, \dots{}, N\}$ ile $N$ büyük $2^{40}$)
• bir fonksiyonumuz var $f : S \to S$ sözde birçok çarpışma ile (görüntüler $S$)
• o zaman depolamamız gerek $f[S]$, yani $\{f(x) | x \in S\}$

Ne hakkında oldukça doğru (olasılıklı) bir tahminim var $|f[S]|$ bu nedenle veri yapılarını önceden tahsis edebilir ( $|f[S]| \approx 2^{30}$).

Birkaç fikrim oldu, ama en iyi yaklaşımın ne olacağından emin değilim:

• giriş kümesi belleğe sığmadığı için bir bit kümesi söz konusu değildir.
• karma tablo, ancak (1) bellekte bir miktar ek yük gerektirir, örneğin% 150 $|f[S]|$ ve (2) bellek ek yükü nedeniyle ek zaman gerektiren tablo oluşturulduğunda araştırılmalıdır.
• bir "anında" tür, tercihen ile $O(N)$karmaşıklık (karşılaştırma olmayan sıralama). Bununla ilgili olarak, kova sıralama ve flashsort arasındaki en büyük farkın ne olduğundan emin değilim .
• ikili arama ağacına sahip basit bir dizi, ancak bu $O(N \log |f[S]|)$ saati.
• belki Bloom filtreleri veya benzer bir veri yapısı kullanmak problemin gevşemesinde (yanlış pozitiflerle) faydalı olabilir.

Stackoverflow ile ilgili bazı soruların bu tür şeylerle başa çıktığı görülüyor ( /programming/12240997/sorting-array-in-on-run-time , /programming/3951547/java -array-find-duplicates ), ancak hiçbiri gereksinimlerimle eşleşmiyor gibi görünüyor.

Neden çöp kutusu ve zincir değil?

Fikir, temsil edebilecek pozitif tamsayıları saklamaktır $n = k+m$ bir dizideki bit sayısı $A$ nın-nin $2^k$ değer aralıklarını temsil eden girişler: giriş $A[y]$, $y \ge 0$, aralığı temsil eder $[2^m y, 2^m(y+1)-1]$. Herhangi$1 \le x \lt 2^n$ yazabiliriz $x = 2^m y + z$ nerede $y$ vardır $k$ bit ve $z$ vardır $m$bit. Depolamaya çalışın$z$ (değil $x$!) konumunda $y$:

• Ne zaman $A[y]=z$ zaten hiçbir şey yapma: $x$ bir kopya.

• Ne zaman $A[y]$ başlatılmamış, mağaza $z$ en $A[y]$.

• Aksi takdirde, dizini zincirlemek için kullanılan ayrı bir dizide saklayın $z$adlı kişinin ( $y$) bağlı listelerde. Başlıklı listede doğrusal olarak arama yapmanız gerekecek$A[y]$ ve aramanın ne ortaya çıkardığına bağlı olarak, potansiyel olarak $z$ listeye girin.

Sonunda, $f(S)$ başlatılan girişler arasında döngü yaparak kurtarması kolaydır $A$ ve - sadece iki bit dizisini birleştirerek - her birini yeniden birleştirerek $z$ konumda bulundu $y$ (doğrudan veya orada referans verilen bir zincir içinde) orijinal değere $x = 2^m y + z$.

Dağıtım tekdüze olduğunda ve $2^k$ aşan $N$, çok fazla zincirleme olmayacak (bu olağan yollarla değerlendirilebilir) ve zincirler kısa olma eğilimindedir. Dağıtım tekdüze olduğunda, algoritma hala çalışır, ancak ikinci dereceden zamanlamaya ulaşabilir. Bu bir olasılıksa, zincirlerden daha verimli bir şey kullanın (ve depolama için biraz ek yük ödeyin).

Gerekli depolama alanı en fazla $2^n$ için bit $A$ ve $2^{2k}$ zincirler için bitler (varsayarak) $m \le k$). Bu tam olarak depolamak için gereken alandır$2^k$ değerleri $n$her biri bit. Tekdüzelikten eminseniz, zincirler için depolama alanının yerini değiştirebilirsiniz. Tekdüzelik bir olasılık ise, artırmak isteyebilirsiniz$k$ ve zincir deposunu tamamen savunmak.

Bu çözeltinin düşünmeye alternatif yolu olmasıdır olduğunu özellikle güzel bir hash fonksiyonu ile bir karma tablo (almak$k$ en önemli bitler) ve bu nedenle yalnızca en az anlamlı olanı $m=n-k$ bitleri tablo.

Zincirler için depolamayı, $A$ ama zahmete değmez, çünkü fazla tasarruf etmeyecek (varsayarak) $m$ daha küçük $k$) ve kodun geliştirilmesini, hata ayıklamasını ve bakımını zorlaştırır.