求最大公约数

暴力枚举

从较小整数的一半开始，找到一个合适的整数 i,看看这个整数能否被a和b同时整除。

int getGreatestCommonDivisor1(int a, int b)//暴力
{
	int big = a > b ? a : b;
	int small = a < b ? a : b;
	if (big%small == 0)
	{
		return small;
	}
	for (int i = small / 2; i > 1; i--)
	{
		if (small%i == 0 && big%i == 0)
		{
			return i;
		}
	}
	return 1;
}

缺点：

如果传入的整数是10000和10001，则需循环 10000/2-1 次。

 

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

定理：

两个正整数a和b(a>b) , 它们的最大公约数等于a除以b的余数c和b之间的最大公约数。

例如：

10和25，25除以10商2余5,那么10和25的最大公约数，等同于10和5的最大公约数。

可以使用递归的方法。首先，我们先计算出a除以b的余数c，把问题转化成求出b和c的最大公约数；然后计算出b除以c的余数d，把问题转化成求出c和d的最大公约数；再计算出c除以d的余数e，把问题转化成求出d和e的最大公约数......

类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或其中一个数减小到1为止。

int getGreatestCommonDivisor2(int a, int b)//辗转相除
{
	int big = a > b ? a : b;
	int small = a < b ? a : b;
	if (big%small == 0)
	{
		return small;
	}
	return getGreatestCommonDivisor2(big%small,small);
}

缺点：

当两个整数较大时，做a%b取模运算性能较差。

 

更相减损术

原理：

两个正整数a和b（a>b），它们的最大公约数等于a-b的差值c和较小数b的最大公约数。例如：

10和25，25减去10的差是15,那么10和25的最大公约数，等同于10和15的最大公约数。

可以通过递归来简化问题。首先，我们先计算出a和b的差值c（假设a>b），把问题转化成求出b和c的最大公约数；然后计算出c和b的差值d（假设c>b），把问题转化成求出b和d的最大公约数；再然后计算出b和d的差值e（假设b>d），把问题转化成求出d和e的最大公约数......

类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以相等为止，最大公约数就是最终相等的两个数。

int getGreatestCommonDivisor3(int a, int b)//更相减损
{
	if (a == b)
	{
		return a;
	}
	int big = a > b ? a : b;
	int small = a < b ? a : b;

	return getGreatestCommonDivisor3(big-small, small);
}

缺点：

运算次数肯定大于辗转相除，但是不稳定，当两数相差悬殊时，如100000和1的最大公约数，就要递归9999次。

 

更相减损术与移位结合

移位运算的性能非常快，对于给定的正整数a和b，可得到如下的结论。其中gcb(a,b)的意思是a,b的最大公约数函数：

当a和b均为偶数，gcb(a,b) = 2*gcb(a/2, b/2) = 2*gcb(a>>1, b>>1)

当a为偶数，b为奇数，gcb(a,b) = gcb(a/2, b) = gcb(a>>1, b)

当a为奇数，b为偶数，gcb(a,b) = gcb(a, b/2) = gcb(a, b>>1)

当a和b均为奇数，利用更相减损术运算一次，gcb(a,b) = gcb(b, a-b)， 此时a-b必然是偶数，又可以继续进行移位运算。

计算10和25的最大公约数的步骤如下：

1. 整数10通过移位，可以转换成求5和25的最大公约数
2. 利用更相减损法，计算出25-5=20，转换成求5和20的最大公约数
3. 整数20通过移位，可以转换成求5和10的最大公约数
4. 整数10通过移位，可以转换成求5和5的最大公约数
5. 利用更相减损法，因为两数相等，所以最大公约数是5

在两数比较小的时候，暂时看不出计算次数的优势，当两数越大，计算次数的节省就越明显。

int gcd(int a, int b)//辗转相除结合更相减损
{
	if (a == b)
	{
		return a;
	}
	if ((a & 1) == 0 && (b & 1) == 0)
	{
		return gcd(a >> 1, b >> 1) << 1;
	}
	else if ((a & 1) == 0 && (b & 1) != 0)
	{
		return gcd(a >> 1, b);
	}
	else if ((a & 1) != 0 && (b & 1) == 0)
	{
		return gcd(a , b>>1);
	}
	else
	{
		int big = a > b ? a : b;
		int small = a < b ? a : b;
		return gcd(big - small, small);
	}
}

 

上述解法时间复杂度：

1.暴力枚举法：时间复杂度是O(min(a, b)))

2.辗转相除法：时间复杂度不太好计算，可以近似为O(log(max(a, b)))，但是取模运算性能较差。

3.更相减损术：避免了取模运算，但是算法性能不稳定，最坏时间复杂度为O(max(a, b)))

4.更相减损术与移位结合：不但避免了取模运算，而且算法性能稳定，时间复杂度为O(log(max(a, b)))