Aşağıdaki sınıfta çok iyi performans gösteren gerçek dünya algoritmaları var mı? [kapalı]

Dün gece başka bir programcı ile tartışıyordum, bir şey O (1) olsa bile, O (n) algoritmasında büyük bir sabit varsa, O (n) olan bir işlemden daha iyi bir performans sergileyebilirdi. Kabul etmedi, ben de buraya getirdim.

Altındaki sınıftakilerden çok daha iyi performans gösteren algoritma örnekleri var mı? Örneğin, O (n) O (1) 'den hızlı veya O (n ² )' den O (n) 'dan daha hızlıdır.

Matematiksel olarak, sabit faktörleri göz ardı ettiğinizde asimptotik üst sınırlara sahip bir fonksiyon için gösterilebilir, ancak bu tür algoritmalar vahşi ortamda var mıdır? Peki bunlardan örnekleri nerede bulabilirim? Ne tür durumlar için kullanılır?

Çok küçük, sabit veri tablolarında aramalar. Optimize edilmiş bir karma tablo O (1) olabilir ve yine de karma hesaplamanın maliyeti nedeniyle ikili bir aramadan veya hatta doğrusal bir aramadan daha yavaş olabilir.

Matris çarpımı. Naif O (n ^ 3) algoritması pratikte sıklıkla küçük-ish matrisleri için Strassen'in O'sundan (n ^ 2.8) daha hızlı kullanılır; Strassen ise daha büyük matrisler için O (n ^ 2.3) Coppersmith-Winograd algoritması yerine kullanılmıştır.

Basit bir örnek, çeşitli sıralama algoritmaları arasındaki farktır. Mergesort, Heapsort ve diğerleri O (n log n) . Quicksort, O (n ^ 2) en kötü durumudur. Ancak genellikle Quicksort daha hızlıdır ve aslında O (n log n) gibi ortalama bir performans sergiler . Daha fazla bilgi .

Başka bir örnek, tek bir Fibonacci sayısının üretilmesidir. Yinelemeli algoritma O (n) , matriks tabanlı algoritma ise O (log n) 'dir . Yine de, ilk bin Fibonacci sayısı için, yinelemeli algoritma muhtemelen daha hızlıdır. Bu aynı zamanda elbette uygulanmasına da bağlı!

Daha iyi bir asimptotik performansa sahip algoritmalar, daha kötü performansa sahip bir algoritma ile gerekli olmayan, ancak daha basit işlemlere sahip olan pahalı işlemleri içerebilir. Sonunda, O- notasyonu bize sadece üzerinde çalıştığı argüman önemli ölçüde arttığında (sonsuzluğa yaklaşır) performans hakkında bir şeyler söyler.

Not: Lütfen yorumları aşağıda @ back2dos ve diğer gurular tarafından okuyun, aslında yazdıklarımdan daha fazla yardımcı oluyorlar - Tüm katkıda bulunanlar için teşekkürler.

Aşağıdaki çizelgeden bence (alınan: Big O notasyonu , "Algoritmaların karamsar doğası:" için arama yapın), O (log n) 'in her zaman daha iyi olmadığını, O (n)' nin olduğunu görebilirsiniz. Öyleyse, argüman geçerli.

Pratik değerler için n, evet. CS teorisinde bu çok fazla ortaya çıkıyor. Genellikle teknik olarak daha iyi büyük Oh performansına sahip karmaşık bir algoritma vardır, ancak sabit faktörler pratik yapamayacak kadar büyüktür.

Bir zamanlar hesaplama geometrim profesörüm bir poligonu lineer zamanda üçgenleştirmek için bir algoritmayı tanımladı, ancak “çok karmaşık. Kimsenin gerçekten uyguladığını sanmıyorum” (!!) ile bitmişti.

Ayrıca, fibonacci yığınları normal yığınlardan daha iyi özelliklere sahiptir, ancak pratikte normal yığınlar kadar iyi performans göstermedikleri için popüler değildirler . Bu, yığın kullanan diğer algoritmalara göre basamaklanabilir - örneğin, Dijkstra'nın en kısa yolları bir fibonacci yığını ile matematiksel olarak daha hızlıdır, ancak pratikte değildir.

Bağlantılı bir listeye ekleme ve yeniden boyutlandırılabilir bir diziye ekleme karşılaştırın.

Bağlantılı liste O (1) girişinin faydalı olması için veri miktarının oldukça büyük olması gerekir.

Bağlantılı bir listede, sonraki işaretçiler ve referanslar için fazladan ek yükü vardır. Yeniden boyutlandırılabilir bir dizinin etrafındaki verileri kopyalaması gerekir. Bu kopya O (n), ancak pratikte çok hızlı.

Big-Oh notasyonu bir fonksiyonun büyüme hızını tanımlamak için kullanılır, bu nedenle bir O (1) algoritmasının daha hızlı olması, ancak sadece belirli bir noktaya kadar (sabit faktör) olması mümkündür.

Ortak gösterimler:

O (1) - Yinelemelerin sayısı (bazen işlev tarafından harcanan kullanıcı zamanı olarak bahsedebilirsiniz) girişin boyutuna bağlı değildir ve gerçekte sabittir.

O (n) - Yinelemelerin sayısı girdi büyüklüğüyle doğrusal orantılı olarak artar . Anlamı - eğer algoritma herhangi bir N, 2 * N kez herhangi bir girişte yinelenirse, yine de O (n) olarak kabul edilir.

O (n ^ 2) (ikinci dereceden) - Yinelemelerin sayısı kare cinsinden girdi büyüklüğüdür.

Regex kütüphaneleri genellikle karmaşıklığı olan DFA neslinden ziyade üstel zamana sahip olan geri izlemeyi yapmak için uygulanmaktadır O(nm).

Naif geri izleme, giriş hızlı yolda kaldığında veya aşırı geri izleme gerekmeden başarısız olduğunda daha iyi bir performans olabilir.

(Bu karar sadece performansa dayalı olmasa da, referansların geri alınmasına da izin verir.)

Bir O(1)algoritma:

def constant_time_algorithm
  one_million = 1000 * 1000
  sleep(one_million) # seconds
end

Bir O(n)algoritma:

def linear_time_algorithm(n)
  sleep(n) # seconds
end

Açıktır ki, herhangi bir değeri için , örnekte verilen algoritma olacak daha hızlı daha algoritması.nn < one_millionO(n)O(1)

Bu örnek biraz karmaşık olsa da, aşağıdaki örneğe ruhu eşittir:

def constant_time_algorithm
  do_a_truckload_of_work_that_takes_forever_and_a_day
end

def linear_time_algorithm(n)
  i = 0
  while i < n
    i += 1
    do_a_minute_amount_of_work_that_takes_nanoseconds
  end
end

Sen gerekir senin içinde sabitleri ve katsayıları biliyorum Oifadesi ve gereken beklenen aralığı bellidir nbelirlemek amacıyla, önsel algoritma daha hızlı sona erecek olan.

Aksi halde, algoritmanın daha hızlı olduğu bir posteriori belirlemek için iki algoritmayı beklenen aralıktaki değerlerle karşılaştırmanız gerekir .n

Sıralama:

Ekleme sıralama O (n ^ 2), ancak az sayıdaki öğe için diğer O (n * log (n)) sıralama algoritmalarından daha iyi performans gösterir.

Çoğu sıralama uygulamasının iki algoritma kombinasyonu kullanmasının nedeni budur. Örneğin, büyük dizileri belirli bir boyuta ulaşana kadar ayırmak için birleştirme sıralaması kullanın, ardından daha küçük birimleri sıralamak ve birleştirme sıralamasıyla tekrar birleştirmek için ekleme sıralamasını kullanın.

Bu tekniği kullanan Python ve Java 7'nin geçerli varsayılan uygulamasını Timsort'a bakın .

Birleşme uygulamada kullanılan algoritma bazı patolojik girişler için, en kötü durumda üstel olduğunu.

Orada bir olan polinom birleşme algoritma , ancak pratikte çok yavaş.

Bellekteki bubblesort, program diske değiştirilirken hızlı bir şekilde daha iyi performans gösterebilir veya karşılaştırırken her öğeyi diskten okuması gerekebilir.

Bu onunla ilgili olabileceği bir örnek olmalı.

Genellikle, daha gelişmiş algoritmalar belirli miktarda (pahalı) kurulum varsaymaktadır. Yalnızca bir kez çalıştırmanız gerekirse, kaba kuvvet yöntemiyle daha iyi olabilirsiniz.

Örneğin: ikili arama ve karma tablo araması, arama başına doğrusal aramadan sonra çok daha hızlıdır , ancak sırasıyla listeyi sıralamanızı veya karma tablosunu oluşturmanızı gerektirir.

Bu sıralama size N log (N) olacak ve hash tablo en az N'ye mal olacak. Şimdi yüzlerce veya binlerce arama yapacaksanız, bu hala itfa edilmiş bir tasarruf. Ancak yalnızca bir veya iki arama yapmanız gerekiyorsa, yalnızca doğrusal aramayı yapmanız ve başlangıç ​​maliyetinden tasarruf etmeniz mantıklı olabilir.

Şifre çözme genellikle 0 (1) olur. Örneğin, DES için anahtar alan 2 ^ 56'dır, bu nedenle herhangi bir mesajın şifresini çözmek, sabit bir zaman işlemidir. Orada sadece 2 ^ 56 faktör var, bu yüzden gerçekten büyük bir sabit.

Kümelerin farklı uygulamaları aklıma geldi. En naiflerden biri, onu bir vektör üzerinde uygulamaktır; bunun anlamı removehem de containsdolayısıyla addhepsi O (N) anlamına gelir .
Bunun bir alternatifi, girdi karma değerlerini girdi değerlerine eşleyen bazı genel amaçlı karma işlemlerin üzerine uygulamaktır. İçin O (1) ile bu tür bir dizi uygulama yapar add, containsve remove.

Eğer N'nin 10 civarında olduğunu varsayarsak, ilk uygulama muhtemelen daha hızlıdır. Bir eleman bulmak için tek yapması gereken 10 değeri bir ile karşılaştırmak.
Diğer uygulama ise, 10 kıyaslama yapmaktan çok daha pahalı olabilecek her türden akıllı dönüşüme başlamak zorunda kalacak. Tüm ek yüklerinizde, önbellek kaçırmanız bile olabilir ve bu durumda çözümünüzün teoride ne kadar hızlı olduğu önemli değildir.

Bu, N'nin yeterince küçük olması halinde, aklınıza gelebilecek en kötü uygulamanın nezih bir uygulamadan daha iyi performans göstereceği anlamına gelmez. Bu, yeterince küçük bir N için, düşük ayak izi ve ek yüke sahip naif bir uygulamanın aslında daha az talimat gerektirebileceği ve ölçeklendirilebilirliği ilk koyan bir uygulamadan daha az önbellek eksikliğine neden olabileceği ve bu nedenle daha hızlı olacağı anlamına gelir.

Gerçek dünya senaryosunda bir şeyin ne kadar hızlı olduğunu bilemezsiniz, bunu bir taneye koyup ölçene kadar. Genellikle sonuçlar şaşırtıcıdır (en azından benim için).

Evet, uygun şekilde küçük N için, her zaman bir N olacak, üstünde her zaman O (1) <O (lg N) <O (N) <O (N log N) <O (N ^ c ) <O (c ^ N) (ki burada O (1) <0 (lg N), bir O (1) algoritmasında, N'nin uygun şekilde büyük olması ve c'nin 1'den büyük olan sabit bir sabit olması durumunda daha az işlem yapacağı anlamına gelir. ).

Belirli bir O (1) algoritmasının tam olarak f (N) = 10 ^ 100 (bir googol) işlemi aldığını ve bir O (N) algoritmasının tamamen g (N) = 2 N + 5 işlemi aldığını söyleyin. O (N) algoritması, N kabaca bir googol olana kadar (aslında N> (10 ^ 100 - 5) / 2), bu nedenle yalnızca N'in 1000 ila milyar arasında olmasını beklerseniz, daha yüksek performans sağlar. O (1) algoritmasını kullanarak büyük bir ceza alırdı.

Ya da gerçekçi bir karşılaştırma için, n basamaklı sayıları birlikte çarptığınızı söyleyin. Karatsuba algoritması en fazla 3 n ^ işlemleri (3 gr) (kabaca O (n ^ 1.585)) ise Schonhage-Strassen algoritması Ç (N günlük K günlüğü K) olan daha hızlı bir düzen , ancak alıntı wikipedia:

Uygulamada Schönhage-Strassen algoritması, Karatsuba ve Toom – Cook çarpımı gibi eski yöntemlerden 2 ^ 2 ^ 15 ila 2 ^ 2 ^ 17 (10.000 ila 40.000 ondalık basamak) ötesindeki yöntemler için daha iyi performans göstermeye başlar. [4] [5] [6] ]

Öyleyse birlikte 500 basamaklı sayıları çarpıyorsanız, büyük O argümanları tarafından "daha hızlı" olan algoritmayı kullanmak mantıklı değildir.

EDIT: f (N) 'yi, f (N) / g (N)' nin N-> sınırını alarak limiti g (N) 'yi bulabilirsiniz. Eğer sınır 0 ise, o zaman f (N) <g (N), limit sonsuz ise o zaman f (N)> g (N) ve limit başka bir sabit ise f (N) ~ g (N) Büyük O notasyonu açısından.

Doğrusal programlama için simpleks metot en kötü durumda üstel olabilir, nispeten yeni iç nokta algoritmaları polinom olabilir.

Bununla birlikte, pratikte simpleks metodu için üstel en kötü durum ortaya çıkmaz - simpleks metodu hızlı ve güvenilirdir, aynı zamanda erken iç nokta algoritmaları rekabet edemeyecek kadar yavaştır. (Orada daha modern iç nokta algoritmaları şimdi vardır - ... çok ama simpleks yöntemdir rekabetçi)

Ukkonen'in bina son eki denemeleri için algoritması O (n log n) 'dir. “Çevrimiçi” olma avantajına sahiptir - yani, daha fazla metin ekleyerek ekleyebilirsiniz.

Son zamanlarda, diğer daha karmaşık algoritmaların pratikte daha hızlı olduğu iddia edildi, çünkü büyük ölçüde bellek erişimi daha yüksek bir konuma sahipti, böylece işlemci önbellek kullanımını arttırdı ve CPU boru hattı duraklarından kaçınıldı. Örneğin, işlem süresinin% 70-80'inin hafıza için harcandığını iddia eden bu araştırmaya ve "wotd" algoritmasını tanımlayan bu makaleye bakınız.

Son ekleri genetikte (eşleşen gen dizileri için) ve Scrabble sözlüklerinin uygulanmasında bir şekilde daha az önemlisi önemlidir.

Herhangi bir iyi tanımlanmış problem için her zaman en hızlı ve en kısa algoritma vardır . Sadece tamamen teorik olarak (asimptotik olarak) en hızlı algoritma olsa bile.

Sorun herhangi açıklama Verilen P o sorun için ve bir örnek I , olası tüm algoritmalar sıralar A ve ispatlar Pr olsun her tür çifti için kontrol Pr geçerli bir kanıtıdır A için asimptotik en hızlı algoritmadır P . Eğer böyle bir kanıt bulursa , I üzerinde A çalıştırır .

Bu problem geçirmez çiftin aranması karmaşıklığı O (1) (sabit bir problem için P ), bu yüzden problem için her zaman asimptotik olarak en hızlı algoritmayı kullanırsınız. Bununla birlikte, bu sabit hemen hemen tüm durumlarda çok açık bir şekilde büyük olduğundan, bu yöntem pratikte tamamen işe yaramaz.

Birçok dil / çerçeve KMP yerine dizeleri eşleştirmek için naif desen eşleştirmesini kullanır . Ababaabababababaabababababab'dan ziyade Tom, New York gibi bir dize ararız.