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 ' I + 1 = B ' 난 ㄴ ' 나는 + 1 = ' 나는 해요 O D B ' $a'_i$$b'_i$ab$i$

닮은가? 명령 버전과 재귀 버전은 정확히 동일한 값을 계산합니다. 또한 (예 : ) 일 때 둘 다 동시에 종료 되므로 동일한 반복 횟수를 수행합니다. 알고리즘 적으로 말하면, 둘 사이에는 차이가 없습니다. 차이점은 구현의 문제이며, 컴파일러, 실행되는 하드웨어 및 운영 체제 및 다른 프로그램이 동시에 실행되는 것에 크게 의존합니다.a ′ i = $a_i=0$$a'_i=0$

재귀 버전은 꼬리 재귀 호출 만 수행 합니다 . 명령형 언어를위한 대부분의 컴파일러는이를 최적화하지 않으므로, 생성하는 코드가 각 반복마다 스택 프레임을 구성하는 데 약간의 시간과 메모리가 낭비 될 수 있습니다. 테일 호출 (함수 언어를위한 컴파일러는 거의 항상)을 최적화하는 컴파일러를 사용하면 생성 된 머신 코드가 두 코드에서 동일 할 수 있습니다 (이러한 호출을로 조정한다고 가정 abs).

작은 숫자의 경우 이진 GCD 알고리즘으로 충분합니다.

잘 관리되고 실제 테스트 된 라이브러리 인 GMP는 Lehmer 알고리즘의 일반화 인 특수 임계 값을 통과 한 후 특수 절반 GCD 알고리즘으로 전환됩니다. Lehmer는 행렬 곱셈을 사용하여 표준 유클리드 알고리즘을 개선합니다. 문서에 따르면, HGCD와 GCD의 점근 적 실행 시간은입니다 O(M(N)*log(N)). 여기서 M(N)두 개의 N- 림 숫자를 곱하는 시간입니다.

알고리즘에 대한 자세한 내용은 여기를 참조하십시오 .

알다시피 Java는 일반적으로 꼬리 재귀 최적화를 지원하지 않지만 Java 구현을 테스트 할 수 있습니다. 그것을 지원하지 않으면 간단한 for루프가 더 빠르고 그렇지 않으면 재귀도 빨라야합니다. 반면에, 이것은 비트 최적화이며, 더 쉽고 읽기 쉬운 코드를 선택하십시오.

또한 가장 빠른 GCD 알고리즘은 Euclid의 알고리즘이 아니며 Lehmer의 알고리즘 은 약간 빠릅니다.

첫째, 타이트한 루프를 대체하기 위해 재귀를 사용하지 마십시오. 느립니다. 컴파일러를 사용하여 최적화하지 마십시오. 둘째, 코드에서 모든 재귀 호출 내에서 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)
{
if (b == 0)
a를 반환;
그밖에
리턴 gcd (, a % 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를 반환합니다.