Question

我有以下算法确定两个数字x和y的最大公约数。我需要找到描述这个算法的大概念并解释原因，但我不知道如何做到这一点。

有人可以查看我的代码并解释它会是什么类型的大字符？

     public void question1(int x, int y){
            ArrayList divisorx = new ArrayList(); //the list of divisors of number x
            ArrayList divisory = new ArrayList();//divisors of number y
            ArrayList answerSet = new ArrayList();//the common divisors from both   
            //divisorx and divisory

            for(int i=1; i<=x; i++){//this loop finds the divisors of number x and 
                                    //adds them to divisorx
                    double remainder = x%i;
                    if(remainder==0){
                        //i is a divisor
                        divisorx.add(i);
                    }
            }
            for(int i2=1; i2<=y; i2++){//this loop finds the divisors of number y 
                                       //and adds them to divisory
                    double remainder2 = y%i2;
                    if(remainder2==0){
                        //i2 is a divisor
                        divisory.add(i2);
                    }
            }
      int xsize = divisorx.size();
      int ysize = divisory.size();

            for(int i=0; i<xsize; i++){//this massive loop compares each element of 
        //divisorx to those of divisory to find common divisors. It adds those common
        //divisors to the arraylist answerSet
               for(int j=0; j<ysize; j++){
                   if(divisorx.get(i)==divisory.get(j)){
                       //common divisor has been found
                       //add it to an answer array

                       answerSet.add(divisorx.get(i));

                   }
                }
            }
    Collections.sort(answerSet);//sorts the answerSet from smallest to greatest

    Object gcd = answerSet.get(answerSet.size()-1);//get the last element of the
                                                   //arraylist, which is the gcd       
    System.out.print("Your Answer: "+gcd);//print out the greatest common divisor
 }

Answer 1

前两个循环的成本分别为 O（X）和 O（Y）。

N的除数是O（sqrt（N））（见注释），因此xsize和ysize是O（sqrt（X））和O（sqrt（Y））。

您的上一个循环因此花费 O（sqrt（X）.sqrt（Y））。

answerSet的大小为O（min（sqrt（X），sqrt（Y））），因为它是divisorx和divisory的交集。

您对answerSet执行排序， O（min（sqrt（X），sqrt（Y））log（min（sqrt（X），sqrt（Y）））

所有这些都是O（X + Y），所以总复杂度 O（X + Y）。

Answer 2

最大的复杂性是您拥有的两个嵌套for循环。 Big O 是 order ，意味着它是相对于输入大小的复杂性。在这里，您的输入大小是您在线性时间（每个1循环）中找到的除数的数量，表示n + n或O(n)。您的示例中的排序通常具有n*log(n)的平均复杂度。你的nester for循环是方括号O(n^2)。您的订单是O(n^2)，因为这是计算中最大的复杂性。我们在多项式表达式中取最大程度，我们得到了所有复杂性，因此O(n^2 + n*log(n) + 2n)是二次多项式，因此〜O(n^2)。

应该注意的是，顺序是空间和时间的复杂性。因此，如果内存使用复杂性大于计算复杂性，则接管。

Answer 3

第一次循环完成X次第二次循环Y次第三个循环肯定少于(X/2 + 1) * (Y/2 + 1)次（因为数字N最多可以有N/2 + 1个除数。所以最糟糕的情况是O(XY/4) = O(XY) 列表answerSet的大小相同，最多可包含XY/4个元素。最后，在O(nlogn)（根据javadoc）中进行排序，即在您的情况下，O(XYlog(XY))。所以最终的复杂性是O(X + Y + XY + XYlog(XY)) = O(XYlog(XY)) 如果您只想使用通用N来表达复杂性，那么它是O((N^2)logN)，其中N = max(X, Y)。

Big O某种算法的表示法？

3 个答案: