Що найбільш ефективно для GCD?

Я знаю, що алгоритм Евкліда є найкращим алгоритмом отримання GCD (великого загального дільника) списку натуральних чисел. Але на практиці ви можете кодувати цей алгоритм різними способами. (У моєму випадку я вирішив використовувати Java, але C / C ++ може бути іншим варіантом).

Мені потрібно використовувати найефективніший код, можливий у своїй програмі.

У рекурсивному режимі ви можете писати:

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

І в ітеративному режимі це виглядає приблизно так:

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

Існує також бінарний алгоритм для GCD, який може бути закодований просто так:

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

Ваші два алгоритми еквівалентні (принаймні, для додатних цілих чисел, те, що відбувається з негативними цілими числами в імперативній версії, залежить від семантики Java, про %яку я не знаю напам’ять). У рекурсивній версії нехай і є аргументом го рекурсивного виклику: b i i a i + 1 = b i b i + 1 = a i m o d b $a_i$$b_i$$i$

В імперативному варіанті нехай і є значеннями змінних і на початку ї ітерації циклу. b ′ i i a ′ i + 1 = b ′ i b ′ i + 1 = a ′ i m o d b ′ $a'_i$$b'_i$ab$i$

Помітили подібність? Ваша імперативна версія та ваша рекурсивна версія обчислюють абсолютно однакові значення. Крім того, вони обидва закінчуються одночасно, коли (відповідно, ), тому вони виконують однакову кількість ітерацій. Тож алгоритмічно кажучи, різниці між ними немає. Будь-яка різниця буде справою реалізації, сильно залежати від компілятора, апаратного забезпечення, на якому він працює, і, можливо, операційної системи та інших програм, які працюють одночасно.a ′ i = $a_i=0$$a'_i=0$

Рекурсивна версія здійснює лише хвостові рекурсивні дзвінки . Більшість компіляторів для імперативних мов не оптимізують їх, і тому, ймовірно, що створений ними код витратить небагато часу та пам'яті на побудову кадру стека при кожній ітерації. У компіляторі, який оптимізує хвостові дзвінки (компілятори для функціональних мов майже завжди), згенерований машинний код може бути однаковим для обох (якщо припустити, що ви узгоджуєте ці виклики abs).

Для малих чисел достатньо двійкового алгоритму GCD.

GMP, добре доглянута і перевірена в реальному світі бібліотека, перейде до спеціального половинного алгоритму GCD після проходження спеціального порогу, узагальнення алгоритму Лемера. Лемер використовує матричне множення для вдосконалення стандартних евклідових алгоритмів. Згідно з документацією, асимптотическое час роботи обох HGCD і GCD є O(M(N)*log(N)), де M(N)час для множення двох чисел N-кінцівки.

Детальну інформацію про їх алгоритм можна знайти тут .

Наскільки я знаю, Java не підтримує оптимізацію хвостової рекурсії в цілому, але ви можете протестувати свою реалізацію на Java; якщо він не підтримує, простий- forпетля повинен бути швидшим, інакше рекурсія повинна бути такою ж швидкою. З іншого боку, це бітова оптимізація, виберіть код, який, на вашу думку, простіший і читабельніший.

Слід також зазначити, що найшвидший алгоритм GCD - це не алгоритм Евкліда, алгоритм Лемера - трохи швидший.

По-перше, не використовуйте рекурсивність для заміни тугої петлі. Це повільно. Не покладайтеся на компілятор, щоб оптимізувати його. По-друге, у своєму коді ви телефонуєте на Math.abs () під час кожного рекурсивного дзвінка, що марно.

У своєму циклі ви можете легко уникнути тимчасових змінних і замінювати a і b весь час.

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 робить джерело коротшим, але виконує багато інструкцій для виконання. Це буде повільніше, ніж нудний своп з тимчасовою змінною.

Для невеликих чисел % - це досить дорога операція, можливо, простіша рекурсивна

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

швидше? (Вибачте, код Mathematica, а не C ++)

Алгоритм Евкліда є найбільш ефективним для обчислення GCD:

Статичний довгий gcd ​​(long a, long b)
{
якщо (b == 0)
повернути a;
ще
повернути gcd (,% b);
}

приклад: -

Нехай 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)


Оскільки B = 0, то GCD (2, 0) поверне 2.