最大公约数问题

package com.demo;


/**
 * 写一个程序，求两个正整数的最大公约数(Greatest Common Divisor,GCD)。如果两个正整数都很大，有什么简单的算法吗？
 * 例如，给定两个数1100100210001,120200021，求去其最大公约数
 * @author ying
 *
 */
public class GreatestCommonDivisor {
/**
* method1的问题在于计算复杂的大整数除法运算，而method2虽然将大整数的除法运算转
* 换成了减法运算，降低了计算的复杂度，但它的问题在于减法的迭代次数太多，那么
* 能否结合method1和method2从而使其成为一个最佳的算法呢？答案的肯定的
* 
* 对于y和x来说，如果y=k*y1,x=k*x1。那么有f(y,x) = k*f(y1,x1)。
* 另外，如果x=p*x1，假设p是素数，并且y%p！=0(即y不能被p整除)，那么
* f(x,y) = f(p*x1,y) = f(x1,y)。
* 注意到以上两点之后，我们就可以利用这两点对算法进行改进。
* 
* 最简单的方法是，我们知道，2是一个素数，同时对于二进制表示的大整数而言，可以
* 很容易地将除以2和乘以2的运算转换成移位运算，从而避免大整数除法，由此就可
* 以利用2这个数字来进行分析。
* 
* 取p = 2
* 若x,y均为偶数，f(x,y) = 2*f(x/2,y/2) = 2*f(x>>1,y>>1)
* 若x为偶数，y为奇数，f(x,y) = f(x/2,y) = f(x>>1,y)
* 若x为奇数，y为偶数，f(x,y) = f(x,y/2) = f(x,y>>1)
* 若x,y均为奇数，f(x,y) = f(y,x-y)，
* 那么在f(x,y) = f(y,x-y)之后，(x-y)是一个偶数，下一步一定就会有除以2的操作。
* 
*因此，最坏的情况下的时间复杂度是O(log2(max(x,y)))。
*考虑如下的情况：
*发
*f(42,30) = (101010,11110)
*         = 2*(10101,1111)
*         = 2*(1111,110)
*         = 2*(1111,11)
*         = 2*(1100,11)
*         = 2*(11,11)
*         = 2*(0,11)
*         = 2*11
*         = 6
* @param x
* @param y
* @return
*/
public long method3(long x,long y){
if(x < y)
return method3(y,x);
if(y == 0)
return x;
else{
if(isEven(x)){
if(isEven(y))
return (method3(x>>1,y>>1)<<1);
else
return method3(x>>1,y);
}else{
if(isEven(y))
return method3(x,y>>1);
else
return method3(y,x-y);
}
}
}
/**
* 判断是否为偶数，如果x为偶数，则返回true，否则放回false。
* @param x
* @return
*/
public boolean isEven(long x){
if(x % 2 == 0)
return true;
else
return false;
}
/**
* 在method1中，我们用到了取模运输。但对于大整数而言，取模运算（其中用到除法）
* 是非常昂贵的开销，将成为整个算法的瓶颈。有没有办法能够不用取模运算呢？
* 
* 采用类似前面辗转相除法的分析，如果一个数能够同时整除x和y，则必能同时整除
* x-y和y；而能够同时整除x-y和y的数也必能同时整除x和y，即x和y的公约数
* 与x-y和y的公约数是相同的，其最大公约数也是相同的，即f(x,y) = f(x-y,y),那么
* 就可以不再需要进行大整数的取模运算，而转换成简单得多的大整数的减法。
* 
* 在实际操作中，如果x<y，可以先交换(x,y)(因为f(x,y) = f(y,x))，从而避免求
* 一个正数和一个负数的最大公约数情况的出现。一直迭代下去，知道其中一个数为0。
* 
*示例如下：
*f(42,30) = f(30,12) = f(12,18) = f(18,12) = f(12,6) = f(6,6) = f(6,0) = 6
*
*注意：当x、y两个数太大而且相差太远的情况，例如(10000000000000,1)，就要进行多次递归，
*如果递归太深了，会出现Exception in thread "main" java.lang.StackOverflowError异常，
*即栈溢出，因为递归的数据都是存放在栈中 
* @param x
* @param y
* @return
*/
public long method2(long x,long y){
if(x < y)
return method2(y,x);
if(y == 0)
return x;
else
return method2(x - y,y);
}
/**
* 最简单的方法，就是直接用代码来实现辗转相除。下面方法是使用递归来实现
* f(42,30) = f(30,12) = f(12,6) = f(6,0) = 6
* @param x
* @param y
* @return
*/
public long method1(long x,long y){
return (long) ((y == 0)?x:method1(y,x%y));
}


}