O (n) Karmaşıklığında Sıralama ile Kelime Sıklığı

Bir Java geliştirici pozisyonu için röportaj sırasında, bana aşağıdakiler soruldu:

İki parametre alan bir işlev yazın:

1. bir metin belgesini temsil eden bir Dize ve
2. döndürülecek öğe sayısını sağlayan bir tam sayı.

İşlevi, sözcük sıklığına göre sıralanmış bir Dizeler listesi döndürecek şekilde uygulayın. Çözümünüz işe yaramalı$O(n)$ zaman nerede $n$ belgedeki karakter sayısıdır.

Aşağıdakiler cevapladım (sözde kodda), değil $O(n)$ daha ziyade $O(n \log n)$zaman nedeniyle tür. Nasıl yapılacağını anlayamıyorum$O(n)$ saati.

wordFrequencyMap = new HashMap<String, Integer>();
words = inputString.split(' ');

for (String word : words) {
  count = wordFrequencyMap.get(word);
  count = (count == null) ? 1 : ++count;
  wordFrequencyMap.put(word, count);
}

return wordFrequencyMap.sortByValue.keys

Birisi biliyor mu veya biri bana bazı ipuçları verebilir mi?

Dağıtım sayımının bir varyasyonunu öneririm:

1. Metni okuyun ve karşılaşılan tüm kelimeleri bir üçgene yerleştirin , her bir düğümde bu düğüm tarafından temsil edilen kelimenin ne sıklıkta meydana geldiğini koruyun. Ayrıca en yüksek kelime sayımı takip edin maxWordCound. -$O(n)$
2. Bir boyut dizisi başlatın maxWordCount. Giriş türü, dizelerin listeleridir. -$O(n)$, çünkü sayı daha yüksek olamaz.
3. Üçgeni çaprazlayın ve her düğüm için sayımla belirtilen dizi girişine karşılık gelen dizeyi ekleyin. -$O(n)$, dizelerin toplam uzunluğu $n$.
4. Diziyi azalan sırada ilerletin ve istenen sayıda dize çıktısı alın. -$O(n)$, çünkü bu dizideki verilerin hem boyutuna hem de miktarına bağlıdır.

Üçgeni muhtemelen ilk aşamadaki diğer veri yapıları ile değiştirebilirsiniz.

Algoritmanız zamanında çalışmaz $O(n \log n)$; ekleme$\Theta(n)$ karma bir şey zaman alır $\Omega(n^2)$ zaten (en kötü durum).

Aşağıdakiler yanlış ; Bunu şimdilik açıklama amaçlı olarak bırakıyorum.

Aşağıdaki algoritma en kötü durumda çalışır $O(n)$ (bir alfabe varsayarsak) $\Sigma$ sabit boyutlu), $n$ metindeki karakter sayısı.

1. Örneğin Ukkonen algoritmasıyla metnin bir sonek ağacını oluşturun .

   Yapı zaten bunu yapmazsa, ulaşılabilir yaprak sayısını her (iç) düğüme ekleyin.

2. Ağacı kökten geçirin ve ilk (beyaz) boşluktaki tüm dalları kesin.

3. Ağacı gezdirin ve her düğümdeki çocukların listesini yaprak sayılarına göre sıralayın.

4. Ağacın verimi (soldan sağa yapraklar) artık tüm kelimelerin bir listesidir ve frekansa göre sıralanmıştır.

Çalışma zamanı ile ilgili:

1. Ukkonen algoritması (geliştirilmiş haliyle) zamanla çalışır $O(n)$; yaprak sayımını korumak$\Theta$- algoritmanın maliyeti.
2. Metinde meydana gelen her kelimenin karakteri başına bir düğümü geçmeliyiz. En fazla olduğu için$n$ farklı kelime karakter çiftleri, en çok ziyaret ediyoruz $n$ düğümleri.
3. En çok ziyaret ediyoruz $n$ düğümler (cf 2.) ve zaman harcamak $O(|\Sigma| \cdot \log |\Sigma|) = O(1)$ düğüm başına.
4. Verimi elde edebiliriz (ki elbette büyüklüğü $O(n)$) zaman içinde basit bir geçişle $O(n)$ (çapraz başvuru 2).

Daha kesin sınırlar, çalışma zamanının farklı kelimelerin sayısı ile parametrelenmesi ile elde edilebilir; az varsa ağaç 2'den sonra küçüktür.

Oluşum sayılarının toplanması O (n) 'dir, bu nedenle hile gerçekten sadece en üst k oluşum sayılarını bulur.

Yığın, en iyi k değerlerini toplamanın yaygın bir yoludur, ancak diğer yöntemler de kullanılabilir (bkz. Https://en.wikipedia.org/wiki/Partial_sorting ).

K'nin yukarıdaki ikinci parametre olduğunu ve sorun ifadesinde sabit olduğunu varsayarız (öyle görünüyor):

1. Her düğümde oluşum sayıları olan bir kelime dizisi oluşturun.
2. K boyutunda bir yığın başlatın.
3. Üçgen ve min-sonda / her bir (yaprak, oluşum-sayısı) çiftini üst-k yığınına yerleştirin.
4. Üst k yapraklarını ve sayılarını çıktılayın (bu aslında bir tür acıdır, çünkü her yaprağı bir kelimeye geri eşlemek için üst işaretçiler gerekir).

Yığın boyutu sabit olduğundan, yığın işlemleri O (1) olduğundan adım 3 O (n) olur.

Üçlü inşa edilirken, yığın dinamik olarak da muhafaza edilebilir.

HashMapTüm kelimeleri ve sıklıklarını toplamak için bir karma tablo (örneğin ) kullanın. Ardından, kelimeleri azalan sıklığa göre sıralamak için sayma sıralaması kullanın. Tüm frekanslar aralıktaki tamsayılar olduğundan$1..n$, sayma sıralaması alır $O(n)$saati. Toplam beklenen çalışma süresi$O(n)$(bu, tüm pratik amaçlar için fazlasıyla yeterlidir) (görüşmeci sorunuzun dışında kalan bir şeyden bahsetmedikçe). Bunun en kötü çalışma süresinden ziyade beklenen çalışma süresi olduğundan emin olun .

Bu, bir öğretmenin algoritma sınıfında arayacağı yanıt olmayabilir, çünkü beklendiği gibi $O(n)$ yerine çalışma süresi $O(n)$en kötü çalışma süresi. Röportaj sorusunda fazladan puan almak istiyorsanız, elbette bu beklenen çalışma süresinin beklendiği gibi elden olmayan bir şekilde bahsedebilirsiniz, ancak aynı zamanda$O(n)$ karma tablosunu daha karmaşık bir veri yapısı ile değiştirerek en kötü çalışma süresi - ve bunun gibi bir durumda algoritmalar arasında nasıl seçim yapacağınızı açıklamaktan memnuniyet duyarız.

Ya da, biraz daha güvenli oynamak istiyorsanız, cevap vermeden önce, ilk önce "beklenenler arasındaki farkı önemsiyor musunuz? $O(n)$ çalışma süresi ve en kötü durum $O(n)$çalışma süresi?". buna göre Ardından terzi cevap. sormaya görüşmeci hazırlıklı olun size pratikte seçerdin nasıl. (skor Eğer öyleyse! Yani basketbol sahası dışına vurmak gerekir bir soru.)

Hashtable tabanlı çözüm

Hashtable'ın karmaşıklığı neden yaptığından emin değilim $\Omega(n^2)$ Eğer $n$olduğu karakter sayısı (değil kelime).

Belgedeki her karakteri yinelerseniz ve yinelediğinizde, kelimenin karma kodunu hesaplarsanız, $n$karakter. Yani, bir harfle karşılaşır karşılaşmaz kelime başlar, bu yüzden kelime bitene kadar hash hesaplamaya başlayın (noktalama için bazı özel durumlar vardır, ancak bunlar karmaşıklığı etkilemez). Her kelime için, karma hesaplandıktan sonra, onu bir hashtable'a ekleyin. Bu, her kelimeyi iki kez gözden geçirmekten kaçınmaktır, yani ilk önce kelimeleri bulmak için belgeyi tekrarlamak ve daha sonra bunları bir karma tabloya eklemek, ancak bu durumda karmaşıklık da olabilir$\Omega(n)$.

Hashtable'daki çarpışmalar kesinlikle bir sorundur ve orijinal hashtable'ın ne kadar büyük olduğuna ve hash algoritmasının ne kadar iyi olduğuna bağlı olarak, $O(1)$ ekleme ve sayma işlemleri için ve böylece $O(n)$algoritma için, ancak bellek pahasına. Ancak, en kötü durumun nasıl ortaya çıkabileceğini hala takdir edemiyorum$O(n^2)$ Eğer $n$ karakter sayısıdır.

Varsayım, karma algoritmanın karakter sayısına göre zaman içinde doğrusal olmasıdır.

Radix sıralama tabanlı çözüm

Alternatif olarak, İngilizce varsayarsak, kelimelerin uzunluğu iyi bilindiği için, bunun yerine bir ızgara oluşturur ve $O(kN)$ nerede $k$ İngilizcedeki bir kelimenin maksimum uzunluğu ve $N$toplam kelime sayısıdır. verilmiş$n$ belgedeki karakter sayısıdır ve $k$ bir sabittir, asimptotik olarak bu miktarlar $O(n)$.

Şimdi her kelimenin sıklığını sayın. Kelimeler sıralandığından, aynı veya farklı olup olmadığını görmek için her kelimeyi bir önceki kelimeyle karşılaştıracağız. Aynı ise, kelimeyi kaldırır ve öncekine bir sayı ekleriz. Farklıysa, sadece 1 sayısını yapın ve devam edin. Bu gerektirir$2n$ karşılaştırmalar nerede $n$ karakter sayısı ve dolayısıyla $O(n)$ bir bütün olarak karmaşıklık içinde.

İngilizce'deki en uzun birkaç kelime gülünç derecede uzundur , ancak daha sonra kelime uzunluğu makul bir sayı (30 veya daha küçük gibi) ile sınırlanabilir ve beraberinde gelebilecek hata payını kabul eden sözcükleri kısaltabilir.