Qual è la più efficiente per GCD?

So che l'algoritmo di Euclide è l'algoritmo migliore per ottenere il GCD (grande divisore comune) di un elenco di numeri interi positivi. Ma in pratica puoi codificare questo algoritmo in vari modi. (Nel mio caso, ho deciso di utilizzare Java, ma C / C ++ potrebbe essere un'altra opzione).

Devo usare il codice più efficiente possibile nel mio programma.

In modalità ricorsiva, puoi scrivere:

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

E in modalità iterativa, assomiglia a questo:

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

Esiste anche l'algoritmo binario per GCD, che può essere codificato semplicemente in questo modo:

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

I tuoi due algoritmi sono equivalenti (almeno per gli interi positivi, ciò che accade con gli interi negativi nella versione imperativa dipende dalla semantica di Java per la %quale non lo so a memoria). Nella versione ricorsiva, permetta e b i essere l'argomento della i esima chiamata ricorsiva: un i + 1 = b i b i + 1 = un i m o d b $a_i$$b_i$$i$

$a'_i$$b'_i$ab$i$

$a_i=0$$a'_i=0$

La versione ricorsiva effettua solo chiamate ricorsive di coda . La maggior parte dei compilatori per i linguaggi imperativi non li ottimizza, quindi è probabile che il codice che generano sprecherà un po 'di tempo e memoria costruendo un frame stack ad ogni iterazione. Con un compilatore che ottimizza le chiamate di coda (compilatori per linguaggi funzionali quasi sempre lo fanno), il codice macchina generato potrebbe essere lo stesso per entrambi (supponendo che si armonizzino quelle chiamate abs).

Per numeri piccoli, l'algoritmo binario GCD è sufficiente.

GMP, una libreria ben mantenuta e testata nel mondo reale, passerà a uno speciale algoritmo a metà GCD dopo aver superato una soglia speciale, una generalizzazione dell'algoritmo di Lehmer. Lehmer's utilizza la moltiplicazione di matrici per migliorare gli algoritmi euclidi standard. Secondo i documenti, il tempo di esecuzione asintotico di entrambi HGCD e GCD è O(M(N)*log(N)), dove M(N)è il tempo per moltiplicare due numeri N-arto.

I dettagli completi sul loro algoritmo sono disponibili qui .

Come so, Java non supporta l'ottimizzazione della ricorsione della coda in generale, ma è possibile testarne l'implementazione; se non lo supporta, un semplice for-loop dovrebbe essere più veloce, altrimenti la ricorsione dovrebbe essere altrettanto veloce. D'altra parte, si tratta di ottimizzazioni di bit, scegli il codice che ritieni sia più facile e più leggibile.

Dovrei anche notare che l'algoritmo GCD più veloce non è l'algoritmo di Euclide, l'algoritmo di Lehmer è un po 'più veloce.

Innanzitutto, non utilizzare la ricorsività per sostituire un circuito chiuso. È lento. Non fare affidamento sul compilatore per ottimizzarlo. Secondo, nel tuo codice, chiami Math.abs () all'interno di ogni chiamata ricorsiva, il che è inutile.

Nel tuo ciclo, puoi facilmente evitare variabili temporanee e scambiare aeb continuamente.

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;
}

Lo scambio usando a ^ = b ^ = a ^ = b rende la fonte più breve ma richiede molte istruzioni per l'esecuzione. Sarà più lento dello scambio noioso con una variabile temporanea.

Per piccoli numeri ,% è un'operazione piuttosto costosa, forse la più semplice ricorsiva

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

è più veloce? (Siamo spiacenti, codice Mathematica e non C ++)

Euclid Algorithm è il più efficace per il calcolo del GCD:

Gcd lungo statico (lungo a, lungo b)
{
if (b == 0)
restituire a;
altro
restituisce gcd (, a% b);
}

esempio:-

Sia A = 16, B = 10.
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)


Poiché B = 0, quindi GCD (2, 0) restituirà 2.