Apa yang paling efisien untuk GCD?

Saya tahu bahwa algoritma Euclid adalah algoritma terbaik untuk mendapatkan GCD (pembagi umum yang hebat) dari daftar bilangan bulat positif. Namun dalam praktiknya Anda dapat membuat kode algoritma ini dengan berbagai cara. (Dalam kasus saya, saya memutuskan untuk menggunakan Java, tetapi C / C ++ mungkin merupakan pilihan lain).

Saya perlu menggunakan kode seefisien mungkin dalam program saya.

Dalam mode rekursif, Anda dapat menulis:

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

Dan dalam mode berulang, tampilannya seperti ini:

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

Ada juga algoritma Biner untuk GCD, yang mungkin dikodekan seperti ini:

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

Kedua algoritma Anda adalah setara (setidaknya untuk bilangan bulat positif, apa yang terjadi dengan bilangan bulat negatif dalam versi imperatif tergantung pada semantik Java %yang saya tidak hafal). Dalam versi rekursif, biarkan dan b i menjadi argumen dari saya th panggilan rekursif: a i + 1 = b i b i + 1 = a i m o d b $a_i$$b_i$$i$

Dalam versi imperatif, biarkan danb ' i menjadi nilai-nilai variabeldanpada awalith iterasi dari loop. a ′ i + 1 = b ′ i b ′ i + 1 = a ′ i m o d b ′ $a'_i$$b'_i$ab$i$

Perhatikan kemiripan? Versi imperatif Anda dan versi rekursif Anda menghitung nilai yang persis sama. Selain itu, mereka berdua akhirnya pada saat yang sama, ketika (resp. A ' i = 0 ), sehingga mereka melakukan jumlah yang sama iterasi. Jadi secara algoritmik, tidak ada perbedaan di antara keduanya. Perbedaannya adalah masalah implementasi, sangat tergantung pada kompiler, perangkat keras yang dijalankannya, dan sangat mungkin sistem operasi dan program apa yang dijalankan secara bersamaan.$a_i=0$$a'_i=0$

Versi rekursif hanya membuat panggilan rekursif ekor . Sebagian besar kompiler untuk bahasa imperatif tidak mengoptimalkannya, sehingga kemungkinan kode yang mereka hasilkan akan menghabiskan sedikit waktu dan memori membangun kerangka tumpukan pada setiap iterasi. Dengan kompiler yang mengoptimalkan panggilan ekor (kompiler untuk bahasa fungsional hampir selalu melakukannya), kode mesin yang dihasilkan mungkin sama untuk keduanya (dengan asumsi Anda menyelaraskan panggilan tersebut dengan abs).

Untuk angka yang kecil, algoritma GCD biner sudah cukup.

GMP, sebuah perpustakaan yang teruji dengan baik dan nyata, akan beralih ke setengah algoritma GCD khusus setelah melewati ambang khusus, generalisasi dari Algoritma Lehmer. Lehmer menggunakan perkalian matriks untuk meningkatkan algoritma Euclidian standar. Menurut dokumen, waktu berjalan asimtotik dari HGCD dan GCD adalah O(M(N)*log(N)), di mana M(N)waktu untuk mengalikan dua nomor N-tungkai.

Detail lengkap tentang algoritme mereka dapat ditemukan di sini .

Seperti yang saya tahu Java tidak mendukung optimasi rekursi ekor secara umum, tetapi Anda dapat menguji implementasi Java Anda untuk itu; jika tidak mendukungnya, forsimplo-simpangan seharusnya lebih cepat, jika tidak rekursi harus sama cepatnya. Di sisi lain, ini adalah optimasi bit, pilih kode yang Anda pikir lebih mudah dan lebih mudah dibaca.

Saya juga harus mencatat bahwa algoritma GCD tercepat bukan algoritma Euclid, algoritma Lehmer sedikit lebih cepat.

Pertama, jangan gunakan recursivity untuk mengganti loop ketat. Itu lambat. Jangan mengandalkan kompiler untuk mengoptimalkannya. Kedua, dalam kode Anda, Anda memanggil Math.abs () dalam setiap panggilan rekursif, yang tidak berguna.

Dalam loop Anda, Anda dapat dengan mudah menghindari variabel sementara dan bertukar a dan b sepanjang waktu.

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

Bertukar menggunakan a ^ = b ^ = a ^ = b membuat sumber lebih pendek tetapi membutuhkan banyak instruksi untuk dieksekusi. Ini akan lebih lambat daripada swap membosankan dengan variabel sementara.

Untuk angka kecil ,% adalah operasi yang cukup mahal, mungkin rekursif yang lebih sederhana

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

lebih cepat? (Maaf, kode Mathematica dan bukan C ++)

Algoritma Euclid paling efisien untuk menghitung GCD:

Gcd panjang statis (panjang a, panjang b)
{
jika (b == 0)
mengembalikan a;
lain
return gcd (, a% b);
}

contoh:-

Misalkan 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)


Karena B = 0 maka GCD (2, 0) akan mengembalikan 2.