Java 最大公约数挑战（欧几里德算法）

每个人我都试图解决最大公约数，它似乎运行良好，但我认为它的代码很长，我是java新手，我需要一些建议，我可以用代码改进什么

    public static void main(String[] args) {
        System.out.println(GCD(888,54));
    }
    public static int GCD(int a, int b){
        int r = a % b;
        if(r != 0){
        int rem = b % r;
        if (rem > 10){
                int aRem = r % rem;
                if (aRem < 10){
                    return aRem;
                }else {
                    int bRem = rem % aRem;
                    return bRem;
                }
            }else {
                return rem;
            }
        }else {
            return r;
        }
    }
}

publicstaticvoidmain（字符串[]args）{
系统输出打印LN（GCD（888,54））；
}
公共静态整数GCD（整数a、整数b）{
int r=a%b；
如果（r！=0）{
int rem=b%r；
如果（雷姆>10）{
int aRem=r%rem；
如果（aRem<10）{
返回aRem；
}否则{
int bRem=rem%aRem；
返回布雷姆；
}
}否则{
返回rem；
}
}否则{
返回r；
}
}
}

您只需使用for循环即可

示例代码

public static int GCD(int a, int b){
  int gcd = 1;
  for(int i = 1; i <= a && i <= b; i++){
      if(a%i==0 && b%i==0)
         gcd = i;
  }
  return gcd;
}

publicstaticintgcd（inta，intb）{
int-gcd=1；
for（inti=1；i您可以使用for循环

示例代码

public static int GCD(int a, int b){
  int gcd = 1;
  for(int i = 1; i <= a && i <= b; i++){
      if(a%i==0 && b%i==0)
         gcd = i;
  }
  return gcd;
}

publicstaticintgcd（inta，intb）{
int-gcd=1；
对于（inti=1；i，也可以使用递归来实现。
尝试在方法中使用此代码

public static int GCD(int a, int b){
        if(b == 0){
            return a;
        }
        return GCD(b, a%b);
    }

您也可以使用递归来实现这一点。
尝试在方法中使用此代码

public static int GCD(int a, int b){
        if(b == 0){
            return a;
        }
        return GCD(b, a%b);
    }

在Java中实现GCD的迭代方法如下：

public static int GCD(int a, int b) {
    while (b != 0) {
        int temp = a;
        a = b;
        b = temp%b;
    }
    return a;
}

这是Peter的递归解决方案的替代方案。其优点是，不会使用太多的
堆栈
空间。它具有相同的时间复杂度，但内存复杂度更好（
O（1）
）并且将适用于所有有效数据，不会危及堆栈溢出错误
在Java中实现GCD的迭代方法如下：

public static int GCD(int a, int b) {
    while (b != 0) {
        int temp = a;
        a = b;
        b = temp%b;
    }
    return a;
}

这是Peter的递归解决方案的替代方案。其优点是，不会使用太多的
堆栈
空间。它具有相同的时间复杂度，但内存复杂度更好（
O（1）
）并且将适用于所有有效数据，而不会危及
StackOverflowerr
欧几里德算法可以递归或迭代方式实现。你的算法既不是一个，也不是另一个。换句话说，你要么需要一个循环，要么需要从
GCD
中调用
GCD
。我投票决定结束这个问题被认为是离题的，因为它属于某个网站，在什么时候使用它。感谢@csabinho的建议，我会尝试编辑我的代码。@RickSanMateo，被接受的答案是低效的。对于
a==b
，它需要
a
循环，而不仅仅是一个循环。欧几里德算法可以在递归或迭代过程中实现y、 你的问题既不是一个，也不是另一个。换句话说，你要么需要一个循环，要么你需要从
GCD
中调用
GCD
。我投票结束这个问题，因为它属于非主题，这是在什么时候使用的网站。谢谢你的建议@csabinho我会尝试编辑我的代码。@RickSanMateo接受答案是低效的。对于
a==b
它需要
a
循环而不是一个循环。