Điều gì là hiệu quả nhất cho GCD?

Tôi biết rằng thuật toán của Euclid là thuật toán tốt nhất để có được GCD (ước số chung lớn) của danh sách các số nguyên dương. Nhưng trong thực tế, bạn có thể mã hóa thuật toán này theo nhiều cách khác nhau. (Trong trường hợp của tôi, tôi đã quyết định sử dụng Java, nhưng C / C ++ có thể là một tùy chọn khác).

Tôi cần sử dụng mã hiệu quả nhất có thể trong chương trình của mình.

Trong chế độ đệ quy, bạn có thể viết:

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

Và trong chế độ lặp, nó trông như thế này:

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

Ngoài ra còn có thuật toán nhị phân cho GCD, có thể được mã hóa đơn giản như thế này:

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

%$a_i$$b_i$$i$

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

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

Phiên bản đệ quy chỉ thực hiện các cuộc gọi đệ quy đuôi . Hầu hết các trình biên dịch cho các ngôn ngữ bắt buộc không tối ưu hóa các ngôn ngữ này và do đó, có khả năng mã mà chúng tạo ra sẽ lãng phí một ít thời gian và bộ nhớ xây dựng một khung ngăn xếp ở mỗi lần lặp. Với trình biên dịch tối ưu hóa các cuộc gọi đuôi (trình biên dịch cho các ngôn ngữ chức năng hầu như luôn luôn làm như vậy), mã máy được tạo có thể giống nhau cho cả hai (giả sử bạn hài hòa các cuộc gọi đó abs).

Đối với các số nhỏ, thuật toán GCD nhị phân là đủ.

GMP, một thư viện được thử nghiệm và duy trì tốt trong thế giới thực, sẽ chuyển sang một thuật toán GCD nửa đặc biệt sau khi vượt qua một ngưỡng đặc biệt, khái quát về Thuật toán của Lehmer. Lehmer's sử dụng phép nhân ma trận để cải thiện các thuật toán Euclidian tiêu chuẩn. Theo các tài liệu, thời gian chạy tiệm cận của cả hai HGCD và GCD là O(M(N)*log(N)), nơi M(N)là thời gian để nhân hai số N-chi.

Chi tiết đầy đủ về thuật toán của họ có thể được tìm thấy ở đây .

Như tôi biết Java không hỗ trợ tối ưu hóa đệ quy đuôi nói chung, nhưng bạn có thể kiểm tra việc triển khai Java của mình cho nó; nếu nó không hỗ trợ nó, một đơn giản for-loop sẽ nhanh hơn, nếu không thì đệ quy cũng phải nhanh như vậy. Mặt khác, đây là những tối ưu hóa bit, chọn mã bạn nghĩ là dễ dàng và dễ đọc hơn.

Tôi cũng cần lưu ý rằng thuật toán GCD nhanh nhất không phải là thuật toán của Euclid, thuật toán của Lehmer nhanh hơn một chút.

Đầu tiên, không sử dụng đệ quy để thay thế một vòng lặp chặt chẽ. Nó chậm. Đừng dựa vào trình biên dịch để tối ưu hóa nó. Thứ hai, trong mã của bạn, bạn gọi Math.abs () trong mỗi cuộc gọi đệ quy, điều này là vô ích.

Trong vòng lặp của bạn, bạn có thể dễ dàng tránh các biến tạm thời và hoán đổi a và b mọi lúc.

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

Trao đổi bằng cách sử dụng a ^ = b ^ = a ^ = b làm cho nguồn ngắn hơn nhưng cần nhiều hướng dẫn để thực thi. Nó sẽ chậm hơn so với trao đổi nhàm chán với một biến tạm thời.

Đối với số lượng nhỏ ,% là một hoạt động khá tốn kém, có lẽ là đệ quy đơn giản hơn

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

nhanh hơn (Xin lỗi, mã Mathicala chứ không phải C ++)

Thuật toán Euclid hiệu quả nhất để tính GCD:

Gcd dài tĩnh (dài a, dài b)
{
nếu (b == 0)
trả lại a;
khác
trả về gcd (, a% b);
}

thí dụ:-

Đặt 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)


Vì B = 0 nên GCD (2, 0) sẽ trả về 2.