计算最大公约数和最小公倍数的五种算法

最新推荐文章于 2021-12-06 20:44:12 发布

三·枪·八·路

最新推荐文章于 2021-12-06 20:44:12 发布

阅读量5.1k

点赞数 6

分类专栏：算法文章标签： c++ 算法 c算法

本文链接：https://blog.csdn.net/lizongti/article/details/115035757

版权

算法专栏收录该内容

1 篇文章 1 订阅

订阅专栏

计算最大公约数和最小公倍数的五种算法

1 短除法

1.1 方法

短除法求最小公倍数，先用这几个数的公约数去除每个数，再用部分数的公约数去除，并把不能整除的数移下来，一直除到所有的商中每两个数都是互质的为止，然后把所有的除数和商连乘起来，所得的积就是这几个数的最小公倍数，例如，求12、15、18的最小公倍数。

1.1 C代码


#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
  int big = fmax(a, b);
  int small = fmin(a, b);
  int divisor = 1;
  for (int i = 2; i < small; ++i) {
    while (big % i == 0 && small % i == 0) {
      big /= i;
      small /= i;
      divisor *= i;
    }
  }
  return divisor;
}


int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}

2 穷举法

2.1 算法

穷举法求两个正整数的最大公约数的解题步骤：从两个数中较小数开始由大到小列举，直到找到公约数立即中断列举，得到的公约数便是最大公约数。
图示：
在这里插入图片描述

2.2 C代码

#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
  int big = fmax(a, b);
  int small = fmin(a, b);
  int divisor = small;
  while (big % divisor || small % divisor) {
    --divisor;
  }
  return divisor;
}

int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}

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

3.1 算法

定义： gcd(a,b) 为整数 a 与 b 的最大公约数
引理：gcd(a,b)=gcd(b,a%b)
证明：
设 r=a%b , c=gcd(a,b)
则 a=xc , b=yc , 其中x , y互质
r=a%b=a-pb=xc-pyc=(x-py)c
而b=yc
可知：y 与 x-py 互质
证明：
假设 y 与 x-py 不互质
设 y=nk , x-py=mk , 且 k>1 （因为互质）
将 y 带入可得
x-pnk=mk
x=(pn+m)k
则 a=xc=(pn+m)kc , b=yc=nkc
那么此时 a 与 b 的最大公约数为 kc 不为 k
与原命题矛盾，则 y 与 x-py 互质
因为 y 与 x-py 互质，所以 r 与 b 的最大公约数为 c
即 gcd(b,r)=c=gcd(a,b)
得证。
当a%b=0时，gcd(a,b)=b
算法过程为：
1. 前提：设两数为a,b设其中a 做被除数,b做除数，temp为余数
2. 大数放a中、小数放b中；
3. 求a/b的余数；
4. 若temp=0则b为最大公约数；
5. 如果temp!=0则把b的值给a、temp的值给a；
6. 返回第二步；
图示:

3.2 C代码

#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
  int big = fmax(a, b);
  int small = fmin(a, b);
  int remainder = big % small;
  while (remainder) {
    big = small;
    small = remainder;
    remainder = big % small;
  }
  return small;
}

int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}

更精简的算法,使用了异或:

#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
	if (a > b) {
		while(b^=a^=b^=a%=b);
		return a;
	} else {
		while(a^=b^=a^=b%=a);
		return b;
	}
}

int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}

4 辗转相减法 (更相减损法，九章算术，尼考曼彻斯法)

4.1 方法

更相减损术，是出自《九章算术》的一种求最大公约数的算法，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。《九章算术》是中国古代的数学专著，其中的“更相减损术”可以用来求两个数的最大公约数，即“可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。”
翻译成现代语言如下：
第一步：任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步。
第二步：以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。
则第一步中约掉的若干个2与第二步中等数的乘积就是所求的最大公约数。
其中所说的“等数”，就是最大公约数。求“等数”的办法是“更相减损”法。所以更相减损法也叫等值算法。

4.2 C代码

#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
  int big = fmax(a, b);
  int small = fmin(a, b);
  int divisor = 1;
  while (big % 2 == 0 && small % 2 == 0) {
    big >>= 1;
    small >>= 1;
    divisor <<= 1;
  }
  int delta;
  delta = big - small;
  while (delta != small) {
    big = fmax(delta, small);
    small = fmin(delta, small);
  }
  divisor *= delta;
  return divisor;
}

int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}

5 Stein算法（辗转相减优化版）

5.1 方法

欧几里德算法是计算两个数最大公约数的传统算法，无论从理论还是从实际效率上都是很好的。但是却有一个致命的缺陷，这个缺陷在素数比较小的时候一般是感觉不到的，只有在大素数时才会显现出来：一般实际应用中的整数很少会超过64位（当然现在已经允许128位了），对于这样的整数，计算两个数之间的模是很简单的。对于字长为32位的平台，计算两个不超过32位的整数的模，只需要一个指令周期，而计算64位以下的整数模，也不过几个周期而已。但是对于更大的素数，这样的计算过程就不得不由用户来设计，为了计算两个超过64位的整数的模，用户也许不得不采用类似于多位数除法手算过程中的试商法，这个过程不但复杂，而且消耗了很多CPU时间。对于现代密码算法，要求计算128位以上的素数的情况比比皆是，比如说RSA加密算法至少要求500bit密钥长度，设计这样的程序迫切希望能够抛弃除法和取模。
Stein算法很好的解决了欧几里德算法中的这个缺陷，Stein算法只有整数的移位和加减法。下面就来说一下Stein算法的原理：
1. 若a和b都是偶数，则记录下公约数2，然后都除2（即右移1位）；
2. 若其中一个数是偶数，则偶数除2，因为此时2不可能是这两个数的公约数了
3. 若两个都是奇数，则a = |a-b|，b = min(a,b)，因为若d是a和b的公约数，那么d也是|a-b|和min(a,b)的公约数。

5.2 C代码


#include <math.h>
#include <stdio.h>

int greatestCommonDivisor(int a, int b) {
  int divisor = 1;
  while (a || b) {
    if (a % 2 == 0 && b % 2 == 0) {
      a >>= 1;
      divisor <<= 1;
    } else if (a % 2 == 0) {
      a >>= 1;
    } else if (b % 2 == 0) {
      b >>= 1;
    } else {
      a = abs(a - b);
      b = fmin(a, b);
    }
  }

  return divisor;
}

int lowestCommonMutiply(int a, int b) {
  return a * b / greatestCommonDivisor(a, b);
}

int main() {
  printf("%d %d", greatestCommonDivisor(6, 4), lowestCommonMutiply(6, 4));
}