Count Inversions in an array in Java

An array is given that contains integers. The task is to find the total count inversions in the given array. Total count inversions is a number that indicates how close or far the given array is from being sorted. For the sorted array, the inversion count is 0. If the array is sorted in the reverse order, then the inversion count is the maximum for that array. See the following examples.

Example 1:

Input

int inArr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8}

Output: 24

Explanation: The given array has the following inversions:

(7, 4), (7, 1), (7, 3), (7, 5), (7, 0), (7, 6), (7, 2), (4, 1), (4, 3), (4, 0), (4, 2), (9, 1), (9, 3), (9, 5), (9, 0), (9, 6), (9, 2), (9, 8), (1, 0), (3, 0), (3, 2), (5, 0), (5, 2), (6, 2). Thus, the total count inversion is 24.

Example 2:

Input

int inArr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

Output: 45

Explanation: All the elements are arranged in strictly decreasing order. So, this time we will have the maximum count inversion. The inversions are:

(9, 8), (9, 7), (9, 6), (9, 5), (9, 4), (9, 3), (9, 2), (9, 1), (9, 0), (8, 7), (8, 6), (8, 5), (8, 4), (8, 3), (8, 2), (8, 1), (8, 0), (7, 6), (7, 5), (7, 4), (7, 3), (7, 2), (7, 1), (7, 0), (6, 5), (6, 4), (6, 3), (6, 2), (6, 1), (6, 0), (5, 4), (5, 3), (5, 2), (5, 1), (5, 0), (4, 3), (4, 2), (4, 1), (4, 0), (3, 2), (3, 1), (3, 0), (2, 1), (2, 0), (1, 0), and their count is (9 * (9 + 1)) / 2 = 45.

Example 3:

Input

int inArr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Output: 0

Explanation: The elements are arranged in increasing order. Thus, no small elements exist on the right side, making the inversion count 0.

Example 4:

Input

int inArr[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4}

Output: 0

Explanation: All the elements of the input array are constant, i.e., of the same value. Thus, no small element exists on the right side of the input array. Hence, the inversion count is 0.

Approach: Using Nested Loop

In this approach, we will be nesting two for-loops. The outer loop picks the element from the input array (consider it as the current element). The inner loop starts from the element next to the current element and goes all the way to the end. In the inner loop, compare the elements pointed by the inner loop variable with the current element. If it is small, increase the inversion count by 1; otherwise, do not increase the inversion count.

FileName: CountInversion.java

// important import statements
import java.util.ArrayList;
import java.util.Arrays;

public class CountInversion 
{

public int computeInversionCount(ArrayList<Integer> inArr, int s) 
{   
int inversionCount = 0;

// outer loop picks the current element
for(int i = 0; i < s; i++)
{

for(int j = i + 1; j < s; j++)
{
if(inArr.get(i) > inArr.get(j))
{
// smaller element on the right side
// is found. Hence, increasing the 
// count by 1
inversionCount = inversionCount + 1;
}
}

}

return inversionCount;
}
    
// main method
public static void main(String argvs[])
{
// creating an object of the class CountInversion
CountInversion obj = new CountInversion();

// input 1
ArrayList<Integer> inArr = new ArrayList<Integer>
(
Arrays.asList(7, 4, 9, 1, 3, 5, 0, 6, 2, 8)
);

// computing the size of the 
// input array
int size = inArr.size();
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();
int ans = obj.computeInversionCount(inArr, size);

System.out.println("The total inversion count of the input array is: " + ans);

System.out.println();

// input 2
inArr = new ArrayList<Integer>
(
Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeInversionCount(inArr, size);

System.out.println("The total inversion count of the input array is: " + ans);

System.out.println();

// input 3
inArr = new ArrayList<Integer>
(
Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeInversionCount(inArr, size);

System.out.println("The total inversion count of the input array is: " + ans);

System.out.println();


// input 4
inArr = new ArrayList<Integer>
(
Arrays.asList(4, 4, 4, 4, 4, 4, 4, 4, 4, 4)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeInversionCount(inArr, size);

System.out.println("The total inversion count of the input array is: " + ans);

}

}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The total inversion count of the input array is: 24

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The total inversion count of the input array is: 45

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The total inversion count of the input array is: 0

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The total inversion count of the input array is: 0

Complexity Analysis: Since the program uses nested loops, the time complexity of the program is O(N2). The program is not using any extra space. Therefore, the space complexity of the program is constant, i.e., O(1).

Approach: Enhanced Merge Sort

The approach is to use the enhanced merge sort. In this approach, we will first split the input array into two subarrays, and then we will count the inversion in the first and the second subarrays. After that, we will count the inversions after merging the subarrays. The total count gives the answer. We will be splitting the input array into subarrays recursively. The steps to find the solution is mentioned below.

Step 1: Split the input array into two almost equal or equal halves in each recursive step unless the base case is achieved. The base case of the recursion is reached when there is only one element in the given half.

Step 2: Create a method merge() that counts the total inversions number when the two halves of the input array are merged. Create two indices j and k, j is the index of the first half, and k is the index dedicated for the second half. if inArr[j] is more than the inArr[k], then there are the (mid - j) inversions. It is because the right and the left subarrays are sorted, so in the left-subarray all of the remaining elements inArr[j + 1], inArr[j + 2] … inArr[mid]) will be more than the inArr[k].

Step 3: Also, create a recursive method for dividing the input array into two halves and computing the answer by adding the inversions number of the first half, of the second half and the inversions number by merging the two halves.

Step 4: Display the total count.

Implementation

Observe the implementation of the above steps.

FileName: CountInversion1.java

// important import statement
import java.util.Arrays;

public class CountInversion1  
{

// method for counting the inversions number
// during the process of merge
private static int mergeAndCount(int inArr[], int lt, int mid, int rt)
{

// The left subarray
int[] leftSubArr = Arrays.copyOfRange(inArr, lt, mid + 1);

// The right subarray
int[] rightSubArr = Arrays.copyOfRange(inArr, mid + 1, rt + 1);

int p = 0;
int q = 0;
int r = lt;
int swapCount = 0;

while (p < leftSubArr.length && q < rightSubArr.length) 
{
if (leftSubArr[p] <= rightSubArr[q])
{
inArr[r] = leftSubArr[p];
r = r + 1;
p = p + 1;
}
else 
{
// if the control reaches here,
// then it means we have got the inversions
// hence, we have to update the inversions count
inArr[r] = rightSubArr[q];
swapCount = swapCount + (mid + 1) - (lt + p);
r = r + 1;
q = q + 1;
}
}

// adding the remaining elements of the 
// left sub array
while (p < leftSubArr.length)
{
inArr[r] = leftSubArr[p];
r = r + 1;
p = p + 1;
}


// adding the remaining elements of the 
// right sub array
while (q < rightSubArr.length)
{
inArr[r] = rightSubArr[q];
r = r + 1;
q = q + 1;
}
return swapCount;
}

// Merge sort method for computing the inversions count
private static int mergeSortAndCount(int[] inArr, int lt, int rt)
{

// Keeping track of the inversion count at a
// specific node of the recursion tree
int cnt = 0;

if (lt < rt) 
{
int mid = (lt + rt) / 2;

// Total inversion count = count of left subarray count
// + count of right subarray + merge count

// count for the Left subarray
cnt = cnt + mergeSortAndCount(inArr, lt, mid);

// Count for the Right subarray 
cnt = cnt + mergeSortAndCount(inArr, mid + 1, rt);

// count after merge
cnt = cnt + mergeAndCount(inArr, lt, mid, rt);
}

return cnt;
}

// main method
public static void main(String[] argvs)
{
// input 1
int arr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8};

// computing the size of the input array
int n = arr.length;

// for storing the total inversions count
int ans;

// creating an object of the class CountInversion1
CountInversion1 obj = new CountInversion1();
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr[i] + " ");
}
// invoking the method mergeSortAndCount()
ans = obj.mergeSortAndCount(arr, 0, n - 1);

System.out.println();
System.out.println("The total inversions count is: " + ans);

System.out.println( );

// input 2
int arr1[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

// computing the size of the input array
n = arr1.length;


System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr1[i] + " ");
}
// invoking the method mergeSortAndCount()
ans = obj.mergeSortAndCount(arr1, 0, n - 1);

System.out.println();
System.out.println("The total inversions count is: " + ans);

System.out.println( );


// input 3
int arr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

// computing the size of the input array
n = arr2.length;


System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr2[i] + " ");
}
// invoking the method mergeSortAndCount()
ans = obj.mergeSortAndCount(arr2, 0, n - 1);

System.out.println();
System.out.println("The total inversions count is: " + ans);

System.out.println( );



// input 4
int arr3[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};

// computing the size of the input array
n = arr3.length;

System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr3[i] + " ");
}
// invoking the method mergeSortAndCount()
ans = obj.mergeSortAndCount(arr3, 0, n - 1);

System.out.println();
System.out.println("The total inversions count is: " + ans);


}

}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The total inversions count is: 24

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The total inversions count is: 45

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The total inversions count is: 0

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The total inversions count is: 0

Complexity Analysis: The merge sort takes O(n x log(n)) time. Therefore, the time complexity of the program is O(n x log(n)). The space complexity of the program is O(n), as the auxiliary arrays are used for storing the left and the right sub-array, where n is the total number of elements present in the input array.

Approach: Using Self Balancing Tree

Algorithm

Step 1: Create an AVL tree. Also, add a property in every node of the tree that each node will contain information about the size of its subtree.

Step 2: Traverse the input array from the last to the beginning.

Step 3: For each element, put that element in the self-balancing tree (AVL tree).

Step 4: The number of nodes that are larger than the current element can easily be computed by checking the size of the right sub-tree (number of right children). Thus, it is sure that the number of elements in the right subtree of the current node has an index less than the current element (as we are traversing the input array from end to beginning). Also, the right children have a larger value than the current element (property of an AVL tree). Therefore, the inversion criteria are satisfied. Hence, increase the count by the right-subtree size of the node that is currently inserted.

Step 5: Display the count.

FileName: CountInversion2.java

// important import statement
import java.util.*;

public class CountInversion2
{
int result = 0;
// An AVL tree node
static class AVLNode
{
int key;
AVLNode lft;
AVLNode rght;
int hght;

// size of the rooted tree 
int s;
};

// A method for finding the height of 
// the tree rooted with r
static int height(AVLNode r)
{
if (r == null)
{
return 0;
}
return r.hght;
}

// A method for size of the
// tree of rooted with r
static int size(AVLNode r)
{
if (r == null)
{
return 0;
}

return r.s;
}

// A Method for finding the maximum
// between p and q
static int findMax(int p, int q)
{
return (p > q) ? p : q;
}

// Helper Method for allocating the
// new node with the provided key. The method
// assigns a null value to the right and left pointers.
static AVLNode newNode(int key)
{
AVLNode nde = new AVLNode();
nde.key = key;
nde.lft = null;
nde.rght = null;

// At leaf, the new node is added at
// the beginning
nde.hght = 1;
nde.s = 1;
return(nde);
}


// A method for doing the right rotation of the 
// subtree rooted with r
static AVLNode rightRotate(AVLNode r)
{
AVLNode nde = r.lft;
AVLNode T2 = nde.rght;

// Perform rotation
nde.rght = r;
r.lft = T2;

// Update heights
r.hght = Math.max(height(r.lft), height(r.rght)) + 1;
nde.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;

// Updating the sizes
r.s = size(r.lft) + size(r.rght) + 1;
nde.s = size(nde.lft) + size(nde.rght) + 1;
// Updating the sizes
r.s = size(r.lft) + size(r.rght) + 1;
nde.s = size(nde.lft) + size(nde.rght) + 1;

// Returning the new root
return nde;
}

// A utility method for the left rotation of the 
// subtree rooted with r
public AVLNode leftRotate(AVLNode r)
{
AVLNode nde = r.rght;
AVLNode T2 = nde.lft;

// Performing the rotation
nde.lft = r;
r.rght = T2;

// Update heights
r.hght = Math.max(height(r.lft), height(r.rght)) + 1;
nde.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;

// Update sizes
r.s = size(r.lft) + size(r.rght) + 1;
nde.s = size(nde.lft) + size(nde.rght) + 1;

// Returning the new root
return nde;
}

// Getting the Balance factor of the node r
public int getBalance(AVLNode r)
{
if (r == null)
{
return 0;
}

return height(r.lft) - height(r.rght);
}

// The method inserts a new key into the AVL tree rooted with
// the node. Also, updating the count for fetching count
// of the lesser elements with the new key
public AVLNode insert(AVLNode nde, int key)
{
// Performing the rotation of the BST (normal)
if (nde == null)
{
return(newNode(key));
}

if (key < nde.key)
{
nde.lft = insert(nde.lft, key);
result = result + size(nde.rght) + 1;
}
else if(key > nde.key)
{
nde.rght = insert(nde.rght, key);
}

// the key value is the same as the nde value
// hence, that key value should not be inserted
else
{
return nde;
}


// Updating the size and the height of this ancestor node
nde.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;
nde.s = size(nde.lft) + size(nde.rght) + 1;

// Getting the balance factor of the 
// ancestor node for checking whether the
// node has become unbalanced or not
int balanceFactor = getBalance(nde);

// If the node gets unbalanced,
// then we have the 4 cases to consider

// Handling the Left-Left Case
if (balanceFactor > 1 && key < nde.lft.key)
{
return rightRotate(nde);
}

// Handling the Right-Right Case
if (balanceFactor < -1 && key > nde.rght.key)
{
return leftRotate(nde);
}
// Handling the Left-Right Case
if (balanceFactor > 1 && key > nde.lft.key)
{
nde.lft = leftRotate(nde.lft);
return rightRotate(nde);
}

// handling the Right-Left Case
if (balanceFactor < -1 && key < nde.rght.key)
{
nde.rght = rightRotate(nde.rght);
return leftRotate(nde);
}

// Returning the node pointer that is unchanged
return nde;
}

// The following method is used to update the
// cntSmaller array for containing the count of
// the smaller elements on the right side.
public int countInv(int arr[], int size)
{
AVLNode rt = null;

// Beginning from the rightmost element,
// put all of the elements one by one in
// the AVL tree 
for(int i = 0; i < size; i++)
{
rt = insert(rt, arr[i]);
}

return result;
}


// main method
public static void main(String[] argvs)
{
// input 1
int arr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8};

// computing the size of the input array
int n = arr.length;

// for storing the total inversions count
int ans;

// creating an object of the class CountInversion2
CountInversion2 obj = new CountInversion2();
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr[i] + " ");
}
// invoking the method countInv()
ans = obj.countInv(arr, n);

System.out.println();
System.out.println("The total inversions count is: " + ans);

System.out.println( );

// input 2
int arr1[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
// computing the size of the input array
n = arr1.length;
obj.result = 0;
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr1[i] + " ");
}
// invoking the method countInv()
ans = obj.countInv(arr1, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
System.out.println( );
// input 3
int arr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
// computing the size of the input array
n = arr2.length;
obj.result = 0;
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr2[i] + " ");
}
// invoking the method countInv()
ans = obj.countInv(arr2, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
System.out.println( );
// input 4
int arr3[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
// computing the size of the input array
n = arr3.length;
obj.result = 0;
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr3[i] + " ");
}
// invoking the method countInv()
ans = obj.countInv(arr3, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
}
}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The total inversions count is: 24

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The total inversions count is: 45

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The total inversions count is: 0

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The total inversions count is: 0

Complexity Analysis: The time, as well as the space complexity, of the program, is the same as the previous program.

Approach: Using Binary Indexed Tree

Using Binary Indexed Tree also, one can achieve the desired result. Observe the following algorithm.

Algorithm

Using Binary Indexed Tree also, one can achieve the desired result. Observe the following algorithm.

Step 1: Create a Binary Indexed Tree for finding the number of the lesser elements for a number. Also, create variable res = 0.

Step 2: Traverse the input array from the last to the beginning.

Step 3: For each index, find out the total number of elements that are less than the current element and update the result by adding it.

Step 4: Create a method retrieveSum() for getting the number of smaller elements.

Step 5: Add the current element to the array BIT[] by performing the update operation that updates the current element count from 0 to 1, and hence updates the current element ancestors in the Binary Indexed Tree.

FileName: CountInversion3.java

// important import statement
import java.util.*;
public class CountInversion3
{
// Returning the sum of arr[0 ... idx].
// This method makes the assumption that the
// array is already preprocessed, and the partial
// sums of the elements of the array are being stored
// in the BITTree[].
static int retrieveSum(int BITTree[], int idx)
{
// Initializing the result
int res = 0;
// Traversing the ancestors of the BITTree[idx]
while (idx > 0)
{
// Adding the current element of
// the BITree to the sum
res = res + BITTree[idx];
// Moving the index to the parent node
// in the getSretrieveSumum View
idx = idx - (idx & (-idx));
}
return res;
}
// Updating a node in the BIT
// at the provided index in the Binary Index Tree.
// The given value v is added to
// BITree[i] and all of its ancestors
// in tree.
static void updateBIT(int BITTree[], int n, int idx, int v)
{
// Traversing all of the ancestors
// and adding the value v
while (idx <= n)
{
// Adding the value v to the current
// node of the Binary Indexed Tree
BITTree[idx] = BITTree[idx] + v;

// Update index to that of
// parent in update View
idx = idx + (idx & (-idx));
}
}
// Converting the array into another array
// with the values ranging from 1 to n and
// also maintaining the relative order of the larger and
// the smaller elements still remain the same.
// For example, {7, -90, 100, 1}
// is converted to {3, 1, 4 ,2 }
static void convert(int inputArr[], int n)
{
// Creating a copy of the inputArr[] in temp
// and sort the temp array in
// increasing order
int temp[] = new int[n];
for (int k = 0; k < n; k++)
{
temp[k] = inputArr[k];
}
Arrays.sort(temp);
// Traversing all of the array elements
for (int k = 0; k < n; k++)
{
// lowerBound() is Returning a pointer
// to the first element, which is equal to or larger
// than inputArr[i]
inputArr[k] = lowerBound(temp, 0, n, inputArr[k]) + 1;
}
}
static int lowerBound(int[] arr, int l, int high, int ele)
{
while(l < high)
{
int mid = l + (high - l) / 2;
if(ele > arr[mid])
{
l = mid + 1;
}
else
{
high = mid;
}
}
return l;
}
// Returning the inversion count of the
// inputArr[0 ... n - 1]
static int getInvCount(int inputArr[], int n)
{
// Initializing the result
int inversionCount = 0;
// Converting inputArr[] to the array
// with the values from 1 to n and
// the relative order of the lesser
// and the larger elements remain the
// same. For example, {117, -900,
// 1, 300} is converted to
// {3, 1, 2, 4 }
convert(inputArr, n);

// Creating a Binary Indexed Tree with the size 
// same as the maxElement + 1 (The extra one is
// used so that the elements can be
// used directly as index)
int []BITArr = new int[n + 1];

for (int k = 1; k <= n; k++)
{
BITArr[k] = 0;
}
// Traversing all of the elements
// from the right.
for (int k = n - 1; k >= 0; k--)
{
// Getting the elements count
// that are smaller than the BITArr[k]
inversionCount = inversionCount + retrieveSum(BITArr, inputArr[k] - 1);
// Adding the current element to the BIT
updateBIT(BITArr, n, inputArr[k], 1);
}
return inversionCount;
}
// main method
public static void main(String[] argvs)
{
// input 1
int arr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8};

// computing the size of the input array
int n = arr.length;
// for storing the total inversions count
int ans;
// creating an object of the class CountInversion3
CountInversion3 obj = new CountInversion3();
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr[i] + " ");
}
// invoking the method getInvCount()
ans = obj.getInvCount(arr, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
System.out.println( );
// input 2
int arr1[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

// computing the size of the input array
n = arr1.length;
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr1[i] + " ");
}
// invoking the method getInvCount()
ans = obj.getInvCount(arr1, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
System.out.println( );
// input 3
int arr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
// computing the size of the input array
n = arr2.length;
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr2[i] + " ");
}
// invoking the method getInvCount()
ans = obj.getInvCount(arr2, n);
System.out.println();
System.out.println("The total inversions count is: " + ans);
System.out.println( );
// input 4
int arr3[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};

// computing the size of the input array
n = arr3.length;

System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr3[i] + " ");
}
// invoking the method getInvCount()
ans = obj.getInvCount(arr3, n);

System.out.println();
System.out.println("The total inversions count is: " + ans);


}

}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The total inversions count is: 24

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The total inversions count is: 45

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The total inversions count is: 0

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The total inversions count is: 0

Complexity Analysis: The time, as well as the space complexity, of the program, is the same as the previous program.

Next TopicCount Smaller Elements on The Right Side in Java

← prev next →