求最大公约数与最小公倍数 （辗转相除法+更相减损法+Stein算法）

辗转相除法与更相减损法对比：

（1）两者都是求最大公因数的方法，计算上辗转相除法以除法为主，更相减损术以减法为主，计算次数上辗转相除法计算次数相对较少，特别当两个数字大小区别较大时计算次数的区别较明显。

（2）从结果体现形式来看，辗转相除法体现结果是以相除余数为0则得到，而更相减损术则以减数与差相等而得到。

更相损减法在两数相差较大时，时间复杂度容易退化成O(N)，而辗转相除法可以稳定在O(logN)。但辗转相除法需要试商，这就使得在某些情况下，使用更相损减法比使用辗转相除法更加简单。

辗转相除法（欧几里得算法）：

最大公约数

方法一：（一行代码简洁明了）

int GCD(int a,int b)
 
{
     
return b==0?a:GCD(b,a%b);
 
}

 

方法二（递归转为循环）：

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

 

最小公倍数:

a*b/GCD(a,b);

或

a*b/gcd(a,b);

求N个数的最大公约数：

#include <stdio.h>
#include <stdlib.h>

int gcd(int a, int b)
{
    if(a < b) a = a^b, b = b^a, a = a^b;
    int c = a%b;
    while(a%b != 0){
        a = b, b = c, c = a % b;
    }
    return b;
}


int main()
{
    int num[20], n;
    scanf("%d",&n);
    for(int i = 1; i <= n; i++)
        scanf("%d",&num[i]);
    int ans = num[1];
    for(i = 2; i <= n; i++)
        ans = gcd(ans, num[i]);
    printf("%d",ans);
    return 0;

}

同理也可求N个数的最小公倍数，学会举一反三.

更相减损法：

int GCD(int a, int b) {
    while (a != b) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }
    return a;
}

stein算法（重点）：

欧几里德算法是计算两个数最大公约数的传统算法，无论从理论还是从实际效率上都是很好的。但是却有一个致命的缺陷，这个缺陷在素数比较小的时候一般是感觉

不到的，只有在大素数时才会显现出来：一般实际应用中的整数很少会超过64位（当然现在已经允许128位了），对于这样的整数，计算两个数之间的模是很简单的。对于字长为32位的平台，计算两个不超过32位的整数的模，只需要一个指令周期，而计算64位以下的整数模，也不过几个周期而已。但是对于更大的素数，这样的计算过程就不得不由用户来设计，为了计算两个超过64位的整数的模，用户也许不得不采用类似于多位数除法手算过程中的试商法，这个过程不但复杂，而且消耗了很多CPU时间。对于现代密码算法，要求计算128位以上的素数的情况比比皆是，比如说RSA加密算法至少要求500bit密钥长度，设计这样的程序迫切希望能够抛弃除法和取模。

Stein算法很好的解决了欧几里德算法中的这个缺陷，Stein算法只有整数的移位和加减法。下面就来说一下Stein算法的原理：

• 若a和b都是偶数，则记录下公约数2，然后都除2（即右移1位）；
• 若其中一个数是偶数，则偶数除2，因为此时2不可能是这两个数的公约数了
• 若两个都是奇数，则a = |a-b|，b = min(a,b)，因为若d是a和b的公约数，那么d也是|a-b|和min(a,b)的公约数。

• 代码实现：

  int SteinGCD(int a, int b) {
      if (a < b) { int t = a; a = b; b = t; }
      if (b == 0) return a;
      if ((a & 1) == 0 && (b & 1) == 0)
          return SteinGCD(a >> 1, b >> 1) << 1;
      else if ((a & 1) == 0 && (b & 1) != 0)
          return SteinGCD(a >> 1, b);
      else if ((a & 1) != 0 && (b & 1) == 0)
          return SteinGCD(a, b >> 1);
      else
          return SteinGCD(a - b, b);
  }

  递归转循环：

• int SteinGCD(int a, int b) {
      int acc = 0;
      while ((a & 1) == 0 && (b & 1) == 0) {
          acc++;
          a >>= 1;
          b >>= 1;
      }
      while ((a & 1) == 0) a >>= 1;
      while ((b & 1) == 0) b >>= 1;
      if (a < b) { int t = a; a = b; b = t; }
      while ((a = (a - b) >> 1) != 0) {
          while ((a & 1) == 0) a >>= 1;
          if (a < b) { int t = a; a = b; b = t; }
      }
      return b << acc;
  }

  想要深入了解的话可以看一下大佬的博客，里面讲的挺详细的（附链接）：

• https://blog.csdn.net/Holmofy/article/details/76401074#%E4%BB%A3%E7%A0%81%E5%AE%9E%E7%8E%B0-1