GCD için en verimli olan nedir?

Euclid'in algoritmasının, GCD'yi (büyük ortak bölen) bir pozitif tamsayı listesinden almak için en iyi algoritma olduğunu biliyorum. Ancak pratikte bu algoritmayı çeşitli şekillerde kodlayabilirsiniz. (Benim durumumda Java kullanmaya karar verdim, fakat C / C ++ başka bir seçenek olabilir).

Programımda mümkün olan en verimli kodu kullanmam gerekiyor.

Özyinelemeli modda, şunları yazabilirsiniz:

static long gcd (long a, long b){
    a = Math.abs(a); b = Math.abs(b);
    return (b==0) ? a : gcd(b, a%b);
  }

Yinelemeli modda şöyle görünür:

static long gcd (long a, long b) {
  long r, i;
  while(b!=0){
    r = a % b;
    a = b;
    b = r;
  }
  return a;
}

GCD için basitçe şöyle kodlanabilecek İkili algoritma da vardır:

int gcd (int a, int b)
{
    while(b) b ^= a ^= b ^= a %= b;
    return a;
}

İki algoritmanız eşdeğerdir (en azından pozitif tamsayılar için, zorunlu sürümde negatif tamsayılarla olan şey, Java'nın %yürekten bilmediğim anlambilimine bağlıdır ). Özyinelemeli sürümünde, let ve ait argüman inci özyinelemeli çağrı: b ı ı bir i + 1 = b i b ı + 1 = bir ı m O d b $a_i$$b_i$$i$

Zorunlu sürümünde, let ve değişkenlerin değerleri olması ve başında döngünün inci yineleme. b ' i i , bir ' i + 1 = b ' ı b ' i + 1 = bir ' ı m O d b ' $a'_i$$b'_i$ab$i$

Bir benzerlik farkettiniz mi? Zorunlu versiyonunuz ve özyinelemeli versiyonunuz tamamen aynı değerleri hesaplıyor. Bundan başka, aynı zamanda her iki ucu, zaman (sırasıyla. ), iterasyonlar aynı sayıda gerçekleştirebilirler. Yani algoritmik olarak konuşursak, ikisi arasında bir fark yoktur. Herhangi bir fark, derleyiciye, çalıştığı donanıma ve büyük olasılıkla işletim sistemine ve diğer programların aynı anda çalıştığı duruma bağlı olarak bir uygulama meselesi olacaktır.a ′ i = $a_i=0$$a'_i=0$

Özyinelemeli sürüm sadece kuyruk özyinelemeli aramalar yapar . Zorunlu diller için çoğu derleyici bunları optimize etmemektedir ve bu nedenle ürettikleri kodun biraz zaman kaybetmesi ve her yinelemede bir yığın çerçeve oluşturmak için bellek harcaması muhtemeldir. Kuyruk çağrılarını optimize eden bir derleyici ile (neredeyse her zaman işlevsel diller için derleyiciler yapar), üretilen makine kodu her ikisi için de aynı olabilir (bu çağrıları uyumlu hale getirdiğinizi varsayarak abs).

Küçük sayılar için ikili GCD algoritması yeterlidir.

İyi korunmuş ve gerçek dünyada test edilmiş bir kütüphane olan GMP, Lehmer'in Algoritmasının genelleştirmesi olan özel bir eşiği geçtikten sonra özel bir yarı GCD algoritmasına geçecektir. Lehmer, standart Euclidian algoritmalarını geliştirmek için matris çarpımını kullanıyor. Docs göre hGCD ve GCD'nın hem asimptotik çalışan zamanıdır O(M(N)*log(N)), nerede M(N)iki N-bacak sayının çarpımı zamanıdır.

Algoritmalarıyla ilgili tüm detayları burada bulabilirsiniz .

Java'nın genel olarak kuyruk özyineleme optimizasyonunu desteklemediğini bildiğim için, ancak Java uygulamanızı bunun için test edebilirsiniz; eğer desteklemiyorsa, basit bir fordöngü daha hızlı olmalı, aksi takdirde özyineleme aynı derecede hızlı olmalıdır. Öte yandan, bunlar bit optimizasyonları, daha kolay ve daha okunaklı olduğunu düşündüğünüz kodu seçin.

Ayrıca en hızlı GCD algoritmasının Euclid'in algoritması olmadığını, Lehmer'in algoritmasının biraz daha hızlı olduğunu da belirtmeliyim .

İlk olarak, sıkı bir döngüyü değiştirmek için özyinelemeyi kullanmayın. Bu yavaş. Optimize etmek için derleyiciye güvenmeyin. İkincisi, kodunuzda, her özyinelemeli çağrıların içinde Math.abs () yöntemini çağırırsınız, bu işe yaramaz.

Döngünüzde geçici değişkenleri kolayca önleyebilir ve a ve b'yi her zaman değiştirebilirsiniz.

int gcd(int a, int b){
    if( a<0 ) a = -a;
    if( b<0 ) b = -b;
    while( b!=0 ){
        a %= b;
        if( a==0 ) return b;
        b %= a;
    }
    return a;
}

A ^ = b ^ = a ^ = b kullanarak değiştirmek, kaynağı kısaltır ancak yürütülmesi için birçok talimat alır. Geçici değişkenli sıkıcı takastan daha yavaş olacaktır.

İçin az sayıda ,% belki daha basit özyinelemeli oldukça pahalı bir işlemdir

GCD[a,b] := Which[ 
   a==b , Return[a],
   b > a, Return[ GCD[a, b-a]],
   a > b, Return[ GCD[b, a-b]]
];

daha hızlı mı? (Üzgünüz, Mathematica kodu ve C ++ değil)

Öklid Algoritması, GCD'yi hesaplamak için en etkilidir:

Statik uzun gcd (uzun a, uzun b)
{
(b == 0)
a dönüş;
Başka
gcd geri dönüşü (,% b);
}

örnek:-

A = 16, B = 10 olsun.
GCD (16, 10) = GCD (10,% 16, 10) = GCD (10, 6)
GCD (10, 6) = GCD (6,% 10 6) = GCD (6, 4)
GCD (6,4) = GCD (4,% 6 4) = GCD (4, 2)
GCD (4, 2) = GCD (2,% 4 2) = GCD (2, 0)


B = 0 olduğundan GCD (2, 0) 2 döndürür.