计算两个正整数的最大公约数

题目：计算两个正整数的最大公约数
一．题目分析
1.辗转相除法
辗转相除法（又名欧几里德法）C语言中用于计算两个正整数a,b的最大公约数和最小公倍数，实质它依赖于下面的定理：

根据这一定理可以采用函数嵌套调用和递归调用形式进行求两个数的最大公约数和最小公倍数,现分别叙述如下：
其算法过程为： 前提：设两数为a,b设其中a 做被除数,b做除数，temp为余数
1、大数放a中、小数放b中；
2、求a/b的余数；
3、若temp=0则b为最大公约数；
4、如果temp!=0则把b的值给a、temp的值给a；
5、返回第二步；
2.穷举法（利用数学定义）
穷举法（也叫枚举法）穷举法求两个正整数的最大公约数的解题步骤：从两个数中较小数开始由大到小列举，直到找到公约数立即中断列举，得到的公约数便是最大公约数 。
3. 更相减损法
更相减损术，是出自《九章算术》的一种求最大公约数的算法，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。《九章算术》是中国古代的数学专著，其中的“更相减损术”可以用来求两个数的最大公约数，即“可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。”
翻译成现代语言如下：
第一步：任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步。
第二步：以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。
则第一步中约掉的若干个2与第二步中等数的乘积就是所求的最大公约数。
其中所说的“等数”，就是最大公约数。求“等数”的办法是“更相减损”法。所以更相减损法也叫等值算法。
4.Stein算法
对于两个正整数 x>y ：
1.均为偶数 gcd( x,y ) =2gcd( x/2,y/2 )；
2.均为奇数 gcd( x,y ) = gcd( (x+y)/2,(x-y)/2 )；
3.x奇y偶 gcd( x,y ) = gcd( x,y/2 )；
4.x偶y奇 gcd( x,y ) = gcd( x/2,y ) 或 gcd( x,y )=gcd( y,x/2 )
有函数非递归调用和递归调用两种。
二．算法实现

#include<stdio.h>
#include"math.h"
#include"time.h"
#include"stdlib.h"
#include"windows.h"

1.辗转相除法
①函数嵌套调用

int divisor1 (int a,int b)    /*自定义函数求两数的最大公约数*/
{
  int  temp;          /*定义整型变量*/
  if(a<b)             /*通过比较求出两个数中的最大值和最小值*/
    { temp=a;a=b;b=temp;} /*设置中间变量进行两数交换*/
   while(b!=0)           /*通过循环求两数的余数，直到余数为0*/
    {
      temp=a%b;
      a=b;              /*变量数值交换*/
      b=temp;
    }
  return (a);            /*返回最大公约数到调用函数处*/ 
}

②函数递归调用

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

2.穷举法

int divisor2 (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); /*返回满足条件的数到主调函数处*/
}

3. 更相减损法

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;
}

4.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 gcd3(int u,int v)
{
    if (u == 0) return v;
    if (v == 0) return u;
    // look for factors of 2
    if (~u & 1) // u is even
    {
        if (v & 1) // v is odd
            return gcd(u >> 1, v);
        else // both u and v are even
            return gcd(u >> 1, v >> 1) << 1;
    }
     if (~v & 1) // u is odd, v is even
        return gcd(u, v >> 1);
     // reduce larger argument
    if (u > v)
        return gcd((u - v) >> 1, v);
     return gcd((v - u) >> 1, u);
}

主要调用实现计算最大公约数各种算法的运行时间

void main()
{
	unsigned int m[10000],n[10000];
	int i,x;
	double run_time;					//定义运行时间
	_LARGE_INTEGER time_start;		//定义开始时间
	_LARGE_INTEGER time_over;		//定义结束时间
	double dqFreq;				//计时器频率
	LARGE_INTEGER f;			//计时器频率
	QueryPerformanceFrequency(&f);
	dqFreq=(double)f.QuadPart;

    srand(time(NULL));
	printf("请输入计算最大公约数的测试组数：");
	scanf("%d",&x);
	for(i=0;i<x;i++)
	{
		m[i]=rand()%1000;
		n[i]=rand()%1000;
	}
	QueryPerformanceCounter(&time_start);	//计时开始
	for(i=0;i<x;i++)
	{
		divisor1 (m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over); //计时结束
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq; //乘以1000000把单位由秒化为微秒，精度为1000 000/（cpu主频）微秒
	printf("辗转相除法的函数嵌套调用时间是：%.f微秒\n",run_time);
	
	QueryPerformanceCounter(&time_start);
	for(i=0;i<x;i++)
	{
		gcd1(m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over);
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	printf("辗转相除法的函数递归调用时间是：%.f微秒\n",run_time);

	QueryPerformanceCounter(&time_start);
	for(i=0;i<x;i++)
	{
		divisor2(m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over);
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	printf("穷举法时间是：%.f微秒\n",run_time);

	QueryPerformanceCounter(&time_start);
	for(i=0;i<x;i++)
	{
		gcd2(m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over);
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	printf("更相减损法时间是：%.f微秒\n",run_time);

	QueryPerformanceCounter(&time_start);
	for(i=0;i<x;i++)
	{
		Stein(m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over);
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	printf("Stein算法的函数非递归调用时间是：%.f微秒\n",run_time);

	QueryPerformanceCounter(&time_start);
	for(i=0;i<x;i++)
	{
		gcd3(m[i],n[i]);
	}
	QueryPerformanceCounter(&time_over);
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	printf("Stein算法的函数递归调用时间是：%.f微秒\n",run_time);
}

三．经验归纳
这次的学习让我学到实用的算法，这些算法有的是我从没接触过的，相信以后可以给自己在编程方面带来新的思路和方法。
这次也碰上了一些困难，在测算程序运行时间上有些问题，测量毫秒级时间时经常看不出来运行效率，有时都为0，测量组数够多又容易崩溃，因此我找到能够测量微秒级时间的算法，这样在时间上就能看出各种算法的差别了。