LeetCode题解:求两个数的最大公约数

求两个数的最大公约数

  • 暴力枚举法
  • 辗转相除法
  • 更相减损法
  • 更相减损法与移位相结合
  • 四种方法对比
  • 代码:

暴力枚举法

原理:从较小整数的一半开始,试图找到一个合适的整数i,看这个整数是否被a和b同时整除

缺点:如果传入的整数数值很大但是相差很小,则计算的循环次数会很大,时间复杂度相对较高

辗转相除法

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

  • 例如:
    10和25,
    25/10 = 2 ----5
    那么10和25的最大公约数,等同于 10 和 5 的最大公约数

  • 把两个较大整数之间的运算简化成两个较小整数之间的运算,直到两个数可以整除,或者其中一个数减小到1为止

缺点:当两个整数较大时,做a%b取模运算的性能会比较差

更相减损法

原理:两个正整数a和b(a>b),他们的最大公约数等于a-b的差值c和较小数b的最大公约数

  • 例如:
    10和25,
    25 - 10 = 15
    那么10和25的最大公约数,等同于 10 和 15 的最大公约数
  • 把两个较大整数之间的运算简化成两个较小整数之间的运算,直到两个数可以相等为止,最大公约数就是最终相等的这两个数的值

缺点:更相减损法依靠两数求差的方式递归,运算次数远大于辗转相除法的取模运算
当两数相差悬殊时,如计算1000和1的最大公约数则要计算999次

更相减损法与移位相结合

原理
当a和b都是偶数的时候,gcb(a,b) = 2gcb(a/2,b/2) = 2gb(a>>1,b>>1)
当a是偶数,b是奇数的时候,gcb(a,b) = gcb(a/2,b) = 2gb(a>>1,b)
当a是奇数,b是偶数的时候,gcb(a,b) = gcb(a,b/2) = 2
gb(a,b>>1)
当a和b都是奇数的时候,先利用更相减损术运算一次,gcb(a,b) = gcb(b,a-b),此时a-b必然是偶数,可以继续移位运算

  • 判断整数就行的方法是让整数和1进行与运算,如果(a&1)==0,则说明整数a是偶数,如果(a&1)!=0,则说明整数a是奇数

四种方法对比

暴力枚举法:时间复杂度O(min(a,b))
辗转相除法:时间复杂度O(log(max(a,b))),但是取模运算性能比较差
更相减损法:避免了取模运算,但是算法性能不稳定,最坏时间复杂度为O(max(a,b))
更相减损法与移位相结合:不但避免了取模运算,而且算法性能稳定,时间复杂度为O(log(max(a,b)))

代码:

package some_problem;/**
 * Copyright (C), 2019-2020
 * author  candy_chen
 * date   2020/7/19 22:12
 * version 1.0
 * Description: 求两个整数的最大公约数
 */

/**
 *
 */
public class GreatestCommonDivisor {
     
    /**
     * 普通暴力枚举解法求最大公约数
     *
     * 从较小整数的一半开始,试图找到一个合适的整数i,看这个整数是否被a和b同时整除
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisor(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;
                //这个整数 i 从2开始循环累加,一直累加到numberA和numberB中较小参数的一半为止。
                //循环结束后,上一次寻找到的能够被两数整除的最大 i 值,就是两数的最大公约数。
            }
        }
        return 1;
    }

    /**
     * 辗转相除法
     *
     * 两个正整数a 和 b(a>b),他们的最大公约数等于a除以b的余数c和b之间的最大公约数
     * 把两个较大整数之间的运算简化成两个较小整数之间的运算,直到两个数可以整除,或者其中一个数减小到1为止
     *
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisorV2(int a,int b){
     
        int big = a>b?a:b;
        int small = a<b?a:b;
        if (big%small == 0){
     
            return small;
        }
        return getGreatestCommonDivisorV2(big%small,small);
    }

    /**
     * 更相减损法
     * 两个正整数a和b(a>b),他们的最大公约数等于a-b的差值c和较小数b的最大公约数
     * 把两个较大整数之间的运算简化成两个较小整数之间的运算,直到两个数可以相等为止,最大公约数就是最终相等的这两个数的值
     * @param a
     * @param b
     * @return
     */

    public static int getGreatestCommonDivisorV3(int a,int b){
     
        if (a == b){
     
            return a;
        }
        int big = a>b?a:b;
        int small = a<b?a:b;
        return getGreatestCommonDivisorV3(big-small,small);
    }

    /**
     * 移位运算
     *
     * 当a和b都是偶数的时候,gcb(a,b) = 2*gcb(a/2,b/2) = 2*gb(a>>1,b>>1)
     * 当a是偶数,b是奇数的时候,gcb(a,b) = gcb(a/2,b) = 2*gb(a>>1,b)
     * 当a是奇数,b是偶数的时候,gcb(a,b) = gcb(a,b/2) = 2*gb(a,b>>1)
     * 当a和b都是奇数的时候,先利用更相减损术运算一次,gcb(a,b) = gcb(b,a-b),此时a-b必然是偶数,可以继续移位运算
     *
     * 判断整数就行的方法是让整数和1进行与运算,如果(a&1)==0,则说明整数a是偶数,如果(a&1)!=0,则说明整数a是奇数
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisorV4(int a,int b){
     
        if (a == b){
     
            return a;
        }
        if ((a&1)==0 && (b&1) == 0){
     
            return getGreatestCommonDivisorV4(a>>1,b>>1)<<1;
        }else if ((a&1)==0 && (b&1) != 0){
     
            return getGreatestCommonDivisorV4(a>>1,b);
        }else if ((a&1)!=0 && (b&1) == 0){
     
            return getGreatestCommonDivisorV4(a,b>>1);
        }else{
     
            int big = a>b ? a:b;
            int small = a<b ? a:b;
            return getGreatestCommonDivisorV4(big-small,small);
        }
    }



    public static void main(String[] args) {
     
        System.out.println(getGreatestCommonDivisor(25,5));
        System.out.println(getGreatestCommonDivisor(100,80));
        System.out.println(getGreatestCommonDivisor(27,14));
    }
}


说明:作者根据网络资料《漫画算法》进行搜索学习,理解整理 若有侵权联系作者

你可能感兴趣的:(LeetCode,算法,java,算法,leetcode)