最大公约数

最新推荐文章于 2023-10-19 21:02:39 发布

归来仍是曾经

最新推荐文章于 2023-10-19 21:02:39 发布

阅读量7.1k

点赞数 3

分类专栏： java随笔

原文链接：https://blog.csdn.net/rrrrghi/article/details/88364691

版权

java随笔专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.辗转相除法（欧几里德法） C语言中用于计算两个正整数a,b的最大公约数，采用函数嵌套调用形式进行求两个数的最大公约数。其算法过程为：

前提：设两数为a,b设其中a做被除数,b做除数,temp为余数

Steps:大数放a中，小数放b中；

求a/b的余数；

若temp=0则b为最大公约数；

如果temp!=0则把b的值给a,temp的值给a；

返回第二步。

流程图：
在这里插入图片描述

2、穷举法（枚举法）

从两个数中较小数开始由大到小列举，直到找到公约数立即中断列举，得到的公约数便是最大公约数。

流程图：
在这里插入图片描述

3、更相减损法

Steps：任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步；

以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。

则第一步中约掉的若干个2与第二步中等数的乘积就是所求的最大公约数。
流程图：
在这里插入图片描述

4、Stein算法

性质：gcd(kx,ky)=k*gcd(x,y)

对两个正整数 x>y

均为偶数 gcd(x,y)=2gcd(x/2,y/2);

均为奇数 gcd(x,y)=gcd((x+y)/2,(x-y)/2);

X奇 y偶 gcd(x,y)=gcd(x,y/2);

X偶 y奇 gcd(x,y)=gcd(x/2,y)
或 gcd(x,y)=gcd(y,x/2).
流程图：
在这里插入图片描述


//C语言实现 四种方法求最大公约数 

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<math.h>

//辗转相除法 

 int gcd(int a,int b)

 { 
     if(a%b==0)
     return b;
         else;
         return gcd(b,a%b);
 }


//穷举法

 int divisor (int a, int b) //自定义函数求两数的最大公约数

 {
      int  temp;//定义整型变量
     temp=(a>b)?b:a;//采种条件运算表达式求出两个数中的最小值
     while(temp>0)

      {
              if(a%temp==0&&b%temp==0)//只要找到一个数能同时被a,b所整除，则中止循环
              break;
              temp--;//如不满足if条件则变量自减，直到能被a,b所整除 
      } 
     return (temp);//返回满足条件的数到主调函数处 
  } 

//更相减损法
 int gcd2(int m,int n)
 {
     int i=0,temp,x;
     while(m%2==0&&n%2==0)//判断m和n能被多少个2整除
    {
         m/=2;
         n/=2;
         i+=1;
    } 
     if(m<n)//m保存大的值
   {
        temp=m;
        m=n;
        n=temp;
   } 
     while(x)
   {
        x=m-n;
        m=(n>x)?n:x;
        n=(n<x)?n:x;
        if(n==(m-n))
        break;
   }
    if(i==0)
    return n;
        else
        return (int) pow(2,i)*n;
  } 

  //Stein算法
   int Stein( unsigned int x, unsigned int y )
  /* return the greatest common divisor of x and y */
   {
        int factor = 0;
        int temp;
        if ( x < y )
        {
                temp = x;
                x = y;
                y = temp;
        }
        if ( 0 == y )
        {
                return 0;
        }
        while ( x != y )
        {
                if ( x & 0x1 )
                {/* when x is odd */
                        if ( y & 0x1 )
                        {/* when x and y are both odd */
                                y = ( x - y ) >> 1;
                                x -= y;
                        }
                        else
                        {/* when x is odd and y is even */
                                y >>= 1;
                        }
                }
                else
                {/* when x is even */
                        if ( y & 0x1 )
                        {/* when x is even and y is odd */
                                x >>= 1;
                                if ( x < y )
                                {
                                        temp = x;
                                        x = y;
                                        y = temp;
                                }
                        }
                        else
                        {/* when x and y are both even */
                                x >>= 1;
                                y >>= 1;
                                ++factor;
                        }
                }
        }
        return ( x << factor );
}


int main()
{
      int i;     
      int a[30];
      for(i=0;i<30;i++)
     {
             a[i]=rand()%100 + 1;
             printf("%d ",a[i]);
      }
       printf("\n");
       int b[30];
       for(i=0;i<30;i++)
      {
         b[i]=rand()%100 + 1;
         printf("%d ",b[i]);
      }
      printf("\n");
      clock_t start,finish;
      double dur;
      start= clock();
      for(i=0;i<30;i++)
    {
        //printf("辗转相除法所得最大公约数为：%d\n",gcd(a[i],b[i]));
        //printf("穷举法所得最大公约数为：%d\n",divisor(a[i],b[i]));
          printf("更相减损法所得最大公约数为：%d\n",gcd2(a[i],b[i]));
        //printf("Stein算法所得最大公约数为：%d\n",Stein(a[i],b[i]));
    }
 finish=clock();
 dur=(double)(finish-start)/CLOCKS_PER_SEC;
 printf("运行所用的时间为：%lf s\n",dur); 
    return 0;
 }

//
辗转相除法

辗转相除法又叫欧几里得算法（Euclidean algorithm），目的是求出两个正整数的最大公约数。它是已知最古老的算法，其可追溯至公元前300年前。

这条算法基于一个定理：两个正整数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的最大公约数…

注意：当两个整数较大，做a%b取模运算的性能会变差。

function getGreatestCommonDivsor(a, b) {
    var big = a > b ? a : b;
    var smaller = a < b ? a : b;
    if (big % smaller == 0) {
        return smaller;
    }
    return getGreatestCommonDivsor(big % smaller, smaller);
}

更相减损术

出自于中国古代的《九章算术》，也是一种求最大公约数的算法。

他的原理更加简单：

两个正整数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的最大公约数…

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

function getGreatestCommonDivsor1(a, b) {
    var big = a > b ? a : b;
    var smaller = a < b ? a : b;
    if (big % smaller == 0) {
        return smaller;
    }
    return getGreatestCommonDivsor(big - smaller, smaller);
}

结合更相减损法以及辗转相除的最优算法

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

当a和b均为偶数，gcb(a,b) = 2gcb(a/2, b/2) = 2gcb(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的最大公约数的步骤如下：

整数10通过移位，可以转换成求5和25的最大公约数

利用更相减损法，计算出25-5=20，转换成求5和20的最大公约数

整数20通过移位，可以转换成求5和10的最大公约数

整数10通过移位，可以转换成求5和5的最大公约数

利用更相减损法，因为两数相等，所以最大公约数是5

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

代码如下：

/**
     * 结合辗转相除法以及更相减损法的最优算法
     * 解法：
     * 当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必然是偶数，又可以继续进行移位运算。
     * @param a
     * @param b
     * @return
     */
function getGreatestCommonDivsor2(a, b) {
    if (a == b) {
        return a;
    }
    var aIsEven = a % 2 === 0
    var bIsEven = b % 2 === 0
    // a&1 == 0说明整数a是偶数，否则为奇数
    if (aIsEven && bIsEven) {
        // 当a和b均为偶数，gcb(a,b) = 2*gcb(a/2, b/2) = 2*gcb(a>>1, b>>1)
        return getGreatestCommonDivsor2(a >> 1, b >> 1) << 1;
    } else if (aIsEven && !bIsEven) {
        // 当a为偶数，b为奇数，gcb(a,b) = gcb(a/2, b) = gcb(a>>1, b)
        return getGreatestCommonDivsor2(a >> 1, b);
    } else if (!bIsEven && bIsEven) {
        // 当a为奇数，b为偶数，gcb(a,b) = gcb(a, b/2) = gcb(a, b>>1)
        return getGreatestCommonDivsor2(a, b >> 1);
    } else {
        // 当a和b均为奇数，利用更相减损术运算一次，gcb(a,b) = gcb(b, a-b)， 此时a-b必然是偶数，又可以继续进行移位运算。
        var big = a > b ? a : b;
        var small = a < b ? a : b;
        return getGreatestCommonDivsor2(big - small, small);
    }
}

穷举法

function getGreatestCommonDivsor(a, b) {
    if (a == 0) return b;
    if (b == 0) return a;
    var small = a > b ? b : a;
    while (a % small || b % small) {
        small--;
    }
    return small;
}

归来仍是曾经

关注

3
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
最大公约数

1.辗转相除法（欧几里德法） C语言中用于计算两个正整数a,b的最大公约数，采用函数嵌套调用形式进行求两个数的最大公约数。其算法过程为：前提：设两数为a,b设其中a做被除数,b做除数,temp为余数Steps:大数放a中，小数放b中；求a/b的余数；若temp=0则b为最大公约数；如果temp!=0则把b的值给a,temp的值给a；返回第二步。流程图：2、穷举法（枚举法）从两个...
复制链接

扫一扫