求最大公约数的几种方法

不多说，直接粘程序：

#include "stdafx.h"
#include <iostream>
using namespace  std;
#include<time.h>
#include<math.h>
const int Max = 10;
//采用连续整数检测   ，   利用求最大公约数的性质解题，有点意思。
void gcd1(int a, int b)
{
    int t;
    int count = 0;
    t = b;
    while(1)

    {
        count++;
        if (a%t == 0)
      {
          if (b%t==0)
          {
              break;
          }
          else
          {
            t = t - 1;
          }
       }
       else
       {
            t = t - 1;
       }
    }
    cout << "采用连续整数检测算法输出的结果是："<< endl;
    cout << "输出最大公约数是："<< t << endl;
    cout << "最大迭代次数是："<< count << endl;

}

//采用欧几里得算法   ，   又叫辗转相除算法
void gcd2(int a, int b)
{
   int r = a % b;
   int count = 0;
   while(r != 0)
   {
       count++;
       a = b;
       b = r;
       r = a % b;
   }
   cout << "采用欧几里得算法输出的结果是："<< endl;
   cout << "输出最大公约数是："<< b << endl;
   cout << "最大迭代次数是："<< count << endl;
}

//采用分解质因数法
void gcd3(int a, int b)
{
   int x[Max]={0},y[Max]={0},z[Max]={0};
   int count1 = 0, count2 = 0, count3 = 0, count = 0;
   // 将a分解质因数，并将质因数放入x数组中
   for (int i = 2; i<=a/2; i++)//从2一直往下试
   {
       count++;
       while(a != i )
       {
           if (a%i == 0)
           {
               a = a / i;
               x[count1] = i;
               count1++;
               count++;
           }
           else
           {
               break;
               count++;
           }
       }
   }
   x[count1] = a;
 // 将b分解质因数，并将质因数放入y数组中
   for (int i = 2; i<=b/2; i++)//从2一直往下试
   {
        count++;
       while(b != i )
       {
           if (b%i == 0)
           {
               b = b / i;
               y[count2] = i;
               count2++;
                count++;
           }
           else
           {
               break;
           }
       }
   }
   y[count2] = b;
   int key = 0;
   //在两个数组中寻找相同的元素的算法中，采取控制变量法，保持一个数组不变，用
   //另一个数组中的每一个值与第二个数组中的值一个个比较，相同的保存到z中。
  for (int m=0; m <= count1; m++)
  {
      key = x[m];
       count++;
      for (int n=0; n <= count2; n++)
      {
          if (key==y[n])
          {
               count++;
              z[count3] = key;
              count3++;
              break;
          }
      }
  }
  int max = 1;
  for (int j = 0; j < count3; j++) //这里不要用 <= 不然，会出错。上面的count最后的数字有具体的值，此数组中对应的数据为0
  {
      max = max * z[j];
      count++;
  }
  cout << "采用分解质因数算法输出的结果是："<< endl;
  cout << "输出最大公约数是："<< max << endl;
  cout << "最大迭代次数是："<< count << endl;
}


int main()
{
    while(1)
{
    clock_t start,stop;
    int a,b;
    cout << "请输入所要求最大公约数的两个数值：" <<endl;
    scanf("%d,%d",&a,&b);
    if (a < b)
    {
       int temp = a;
       a = b;
       b = temp;
    }
    start = clock();
    gcd1(a,b);
    stop = clock();
    cout << "执行时间是："<< stop - start << endl;

    start = clock();
    gcd2(a,b);
    stop = clock();
    cout << "执行时间是："<< stop - start << endl;

    start = clock();
    gcd3(a,b);
    stop = clock();
    cout << "执行时间是："<< stop - start << endl;
}
    return 0;
}

实验结果：

实验总结：

方法一当中，根据代码考虑最坏情况他们的最大公约数是1，循环做了t-1次，最好情况是只做了1次，可以得出O（n）=n/2;

方法二当中，根据代码辗转相除得到欧几里得的O(n)= log n

方法三当中，根据代码分解质因子算法O(n)=n²+n/2

但从我的实验结果来看，从时间复杂度来看，欧几里得算法的是最优算法，分解质因数算法其次，最后是连续整除法。从执行次数来看，欧几里得算法的是最优算法，连续整除法其次，最多的是分解质因数算法。再从代码运行的计数器和计算的时间来看，从执行次数上来分析，与理论分析结果一致，但从时间复杂度来看，结果不太一致。但我们可以得出结论的是：欧几里得算法最优。