Question

I have the following algorithm that determines the greatest common divisor of two numbers x and y. I need to find the big o notation that describes this algorithm and explain why, but I have no idea how to do this.

Could someone please look at my code and explain what type of big oh notation it would be?

     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

The largest complexity is the two nested for-loops that you have. Big O is order and means it is the complexity relative to the input size. Here your input size is number of divisors which you find in linear time (1 for-loop each) meaning n + n or O(n). The sorting in your example is usually of average complexity of n*log(n). Your nester for-loops are square meaning O(n^2). Your order is then the O(n^2) because this is the largest complexity in computation. We take the largest degree in the polynomial expression that we get of adding all the complexities so O(n^2 + n*log(n) + 2n) which is 2nd degree polynomial and thus ~ O(n^2).

It should be noted that the order is the larger complexity of space and time. So if memory usage complexity is larger than computational complexity then that takes over.