# Inversions in array

Let A[0…n – 1] be an array of n distinct positive integers. If `i < j` and `A[i] > A[j]` then the pair (i, j) is called an inversion of A. Given n and an array A, find the number of inversions in array A. For example: First array has two inversions (2,1) and (5,1) where as second array has 3 inversions, (2,1), (4,1) and (4,3)  How many inversion can be in a sorted array? There is no inversion in sorted array and nC2 inversions in completely inverted array.

## Inversions in array : Thought process

What first thing which comes to mind? For each index i, check all j where j > i and see if A[j] < A[i]?
If A[j] is greater than current element A[i], increase inversion count. Implementation is given below.

```package com.company;

/**
* Created by sangar on 6.4.18.
*/
public class Inversions {
public static int findInversions(int[] a){
int count = 0;
for(int i=0; i<a.length; i++){
for(int j=i+1;  j<a.length; j++){
if(a[i] > a[j]) count++;
}
}
return count;
}

public static void main(String[] args) {
int a[] = new int[]{90, 20, 30, 40, 50};
int inversions = findInversions(a);
System.out.print("Inversions : " + inversions);
}
}
```

Worst case complexity of this method to find inversions in array is O(n2).

Can we use the information that a sorted array does not have any inversion? Let’s ask this question again with a tweak, how many inversions will there be if only one element is out of place for a completely sorted array? There will one. What if there are two elements out of place? Of course, there will be 2 inversion. Are we getting somewhere? Effectively, we have to count, how many swaps we need to completely sort array from it’s original state. If you noticed, the brute force algorithm, is nothing but selection sort, instead of swapping elements, count inversions.

What if we use any other sort algorithm like Merge sort algorithm? Complexity of merge sort is much better than selection sort, then it is possible that merge sort identifies inversions much efficiently than selection sort.
Let’s use merge step of merge sort algorithm with a bit modification. Divide part will remains the same. While merging two sorted subarrays, count number of times element on right part is put on result array before element on left side.
Every time `A[i]` is appended to the output of merge sort, no new inversions are encountered, since `A[i]` is smaller than everything left in array B.  If `B[j]` is appended to the output, then it is smaller than all the remaining items in A, we increase the number of count of inversions by the number of elements remaining in A.
Overall inversions will be inversion in left part + inversions of right part and inversion which are in merge step.

Let’s see how inversions in merge steps are counted and then we will see the overall algorithm.    Total number of inversions is 6.

Overall, algorithm looks like below. ## Algorithm to count inversions in array

First, let’s write an algorithm to count inversions in merge step. When we are at merge steps, there are two sorted arrays with us:  A and B

1. Initialize i as start position of A and j as start position of B. These pointers will reference to currently compared indices in both arrays.
2. While there are elements in both arrays, i.e. i < length(A) && j < length(B)
1.  If B[j] < A[i], all elements from i to length(A) are greater than B[j],
count += number of elements remaining in A. Increment j
2. Else increment i
3. Return count

Replace merge part of merge sort with this piece of algorithm and return sum of inversions in left + inversions in right + inversions in merge from function.

MergeSortAndCount(L):

1. If L has one element return 0
2. Divide L into A, B
1. inversionsLeft = MergeSortAndCount(A)
2. inversionRight = MergeSortAndCount(B)
3. inversionMerge = MergeAndCount(A,B)
3. return inversionLeft + inversionRight + inversionMerge

## Inversions in array implementation

```package com.company;

/**
* Created by sangar on 6.4.18.
*/
public class Inversions {
public  static int mergeAndCount(int[] a, int low, int mid, int high){
int count  =  0;
int[] temp = new int[high-low+1];

int i = low;
int j = mid+1;
int k = 0;
/*
There are elements on both side of array
*/
while(i<=mid && j<=high){

if(a[i] > a[j]){
//Number of elements remaining on left side.
count+= (mid - i + 1);
temp[k++] = a[j++];
}
else{
temp[k++] = a[i++];
}
}
while(i<=mid){
temp[k++] = a[i++];
}
while(j<=high) {
temp[k++] = a[j++];
}

for(i=low; i<k+low; i++){
a[i] = temp[i-low];
}

return count;
}

public static int countInversions(int[] a, int low, int high){
if(low >= high) return 0;

int mid = low + (high - low) / 2;

int inversionsLeft = countInversions(a, low, mid);
int inversionsRight = countInversions(a, mid+1, high);
int inversionsMerge = mergeAndCount(a, low, mid, high);

return inversionsLeft + inversionsRight + inversionsMerge;
}

public static void main(String[] args) {
int a[] = new int[]{90, 20, 30, 40, 50};
int inversions = countInversions(a, 0, a.length-1);
System.out.print("Inversions : " + inversions);
}
}
```

Complexity of finding inversions in arrays using merge sort method is  O(n log n).