# Time complexity of insertion sort when there are O(n) inversions?

What is an inversion?
Given an array arr[], a pair arr[i] and arr[j] forms an inversion if arr[i] j. For example, the array {1, 3, 2, 5} has one inversion (3, 2) and array {5, 4, 3} has inversions (5, 4), (5, 3) and (4, 3). We have discussed a merge sort based algorithm to count inversions

What is the time complexity of Insertion Sort when there are O(n) inversions?
Consider the following function of insertion sort.

 `/* Function to sort an array using insertion sort*/` `void` `insertionSort(``int` `arr[], ``int` `n) ` `{ ` `   ``int` `i, key, j; ` `   ``for` `(i = 1; i < n; i++) ` `   ``{ ` `       ``key = arr[i]; ` `       ``j = i-1; ` `  `  `       ``/* Move elements of arr[0..i-1], that are ` `          ``greater than key, to one position ahead ` `          ``of their current position */` `       ``while` `(j >= 0 && arr[j] > key) ` `       ``{ ` `           ``arr[j+1] = arr[j]; ` `           ``j = j-1; ` `       ``} ` `       ``arr[j+1] = key; ` `   ``} ` `}`

If we take a closer look at the insertion sort code, we can notice that every iteration of while loop reduces one inversion. The while loop executes only if i > j and arr[i] 2).