CODEWITHSUNDEEP
javadata-structures
cris
cris

Reputation: 275

What is the specific runtime complexity of insertion sort?

Im just going over some basic sorting algorithms. I implemented the below insertion sort.

  public static int[] insertionSort(int[] arr){
      int I = 0;
      for(int i = 0; i < arr.length; i++){
          for(int j = 0; j < i; j++){
              if(arr[i] < arr[j]){
                  int temp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = temp;
                  
              }
              I++;
          }
      }
      System.out.println(I);
      return arr;
  }

I prints out 4950 for a sized 100 array with 100 randomly generated integers.

I know the algorithm is considered O(n^2), but what would be the more arithmetically correct runtime? If it was actually O(N^2) Iim assuming, would print out 10,000 and not 4950.

Upvotes: 0

Views: 52

Answers (2)

Joni
Joni

Reputation: 111289

You can make the following observations: On the ith iteration of the outer loop, the inner loop runs i times, for i from 0 to n-1 where n is the length of the array.

In total over the entire algorithm the inner loop runs T(n) times where

T(n) = 0 + 1 + 2 + ... + (n-1)

This is an arithmetic series and it's easy to prove the sum is equal to a second degree polynomial on n:

T(n) = n*(n-1)/2 = .5*n^2 - .5*n

For n = 100, the formula predicts the inner loop will run T(100) = 100*99/2 = 4950 times which matches what you calculated.

Upvotes: 1

Code-Apprentice
Code-Apprentice

Reputation: 83537

Big-Oh notation gives us how much work an algorithm must do as the input size grows bigger. A single input test doesn't give enough information to verify the theoretical Big-Oh. You should run the algorithm on arrays of different sizes from 100 to a million and graph the output with the size of the array as the x-variable and the number of steps that your code outputs as the y-variable. When you do this, you will see that the graph is a parabola.

You can use algebra to get an function in the form y = a*x^2 + b*x +c that fits as close as possible to this data. But with Big-Oh notation, we don't care about the smaller terms because they grow insignificant compared to the x^2 part. For example, when x = 10^3, then x^2 = 10^6 which is much larger than b*x + c. If x = 10^6 then x^2 = 10^12 which again is so much larger than b*x + c that we can ignore these smaller terms.

Upvotes: 1

Related Questions