Count Inversions in Array in DSA C++ - Build from Scratch

Count Inversions in Array

📖 Scenario: You have a list of numbers representing the order of books on a shelf. Sometimes, the books are not in the correct order. We want to find out how many pairs of books are out of order. This count is called the number of inversions.

🎯 Goal: Build a program that counts how many pairs of numbers in an array are out of order. This helps understand how far the list is from being sorted.

📋 What You'll Learn

Create an array with exact values

Add a variable to count inversions

Use nested loops to find all pairs where the first number is greater than the second

Print the total count of inversions

💡 Why This Matters

🌍 Real World

Counting inversions helps understand how far a list is from being sorted, useful in sorting algorithms and measuring disorder in data.

💼 Career

Understanding inversion counting is important for software engineers working with sorting, optimization, and data analysis.

1

Create the array of numbers

Create an integer array called arr with these exact values: 2, 4, 1, 3, 5

DSA C++

int arr[] = {2, 4, 1, 3, 5};
// Your code here

Hint

Use curly braces to list the numbers inside the array.

2

Add a variable to count inversions

Add an integer variable called inversionCount and set it to 0

DSA C++

int arr[] = {2, 4, 1, 3, 5};
int inversionCount = 0;  // Your code here

Hint

Initialize the count variable to zero before counting.

3

Count the inversions using nested loops

Use two for loops with variables i and j to check all pairs where i < j. Inside the inner loop, if arr[i] > arr[j], increase inversionCount by 1

DSA C++

int arr[] = {2, 4, 1, 3, 5};
int inversionCount = 0;
// Your code here

Hint

Use nested loops to compare each pair only once.

4

Print the total number of inversions

Print the value of inversionCount using std::cout

DSA C++

int arr[] = {2, 4, 1, 3, 5};
int inversionCount = 0;
int n = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i  arr[j]) {
            inversionCount++;
        }
    }
}
// Your code here

Hint

Use std::cout << inversionCount << std::endl; to print the count.

Practice

1. What does the term inversion mean in the context of an array?

easy

A. The sum of all elements in the array

B. A pair of elements where the first is smaller than the second and appears before it

C. The total number of elements in the array

D. A pair of elements where the first is greater than the second and appears before it

Solution

1. Step 1: Understand the definition of inversion

   An inversion is a pair (i, j) such that i < j and array[i] > array[j].

2. Step 2: Compare options with definition

   A pair of elements where the first is greater than the second and appears before it matches the definition exactly, others describe different concepts.

3. Final Answer:

   A pair of elements where the first is greater than the second and appears before it -> Option D

4. Quick Check:

   Inversion = pair with first > second [OK]

Hint: Inversion means earlier element is bigger than a later one [OK]

Common Mistakes:

• Confusing inversion with sorted pairs
• Thinking inversion counts total elements
• Mixing up greater and smaller conditions

2. Which of the following C++ code snippets correctly declares a function to count inversions in an array?

easy

A. int countInversions(vector<int>& arr);

B. void countInversions(vector<int> arr);

C. int countInversions(int arr[]);

D. int countInversions(vector<int> arr);

Solution

1. Step 1: Check function return type and parameter passing

   The function should return an integer count and take array by reference for efficiency.

2. Step 2: Analyze each option

   int countInversions(vector<int>& arr); returns int and takes vector by reference, correct. void countInversions(vector<int> arr); returns void, wrong. int countInversions(int arr[]); uses raw array without size info, less preferred. int countInversions(vector<int> arr); passes vector by value, inefficient.

3. Final Answer:

   int countInversions(vector<int>& arr); -> Option A

4. Quick Check:

   Return int, pass vector by reference [OK]

Hint: Count returns int; pass vector by reference to avoid copying [OK]

Common Mistakes:

• Using void return type
• Passing vector by value causing copies
• Using raw arrays without size info

3. What is the output of the following C++ code snippet?

std::vector<int> arr = {2, 4, 1, 3, 5};
int count = 0;
for (int i = 0; i < arr.size(); i++) {
  for (int j = i + 1; j < arr.size(); j++) {
    if (arr[i] > arr[j]) count++;
  }
}
std::cout << count << std::endl;

medium

A. 2

B. 4

C. 3

D. 5

Solution

1. Step 1: Identify all inversion pairs in the array

   Pairs where first > second and first index < second index are: (2,1), (4,1), (4,3).

2. Step 2: Count these pairs

   There are exactly 3 such pairs.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Inversions = 3 [OK]

Hint: Count pairs where earlier element is bigger than later [OK]

Common Mistakes:

• Counting pairs where first is smaller
• Missing some inversion pairs
• Confusing index order

4. Find the error in this C++ function to count inversions using a brute force approach:

int countInversions(std::vector<int> arr) {
  int count = 0;
  for (int i = 0; i < arr.size(); i++) {
    for (int j = 0; j < arr.size(); j++) {
      if (arr[i] > arr[j]) count++;
    }
  }
  return count;
}

medium

A. Function should return void, not int

B. Inner loop should start from j = i + 1, not 0

C. Comparison should be arr[i] < arr[j]

D. Count variable should be initialized outside the function

Solution

1. Step 1: Analyze loop ranges for counting inversions

   Inversion pairs require i < j, so inner loop must start from j = i + 1.

2. Step 2: Identify the error in the given code

   Inner loop starts from 0, counting pairs twice and including invalid pairs where j < i.

3. Final Answer:

   Inner loop should start from j = i + 1, not 0 -> Option B

4. Quick Check:

   Inner loop from i+1 to end [OK]

Hint: Inner loop must start after outer index to avoid double count [OK]

Common Mistakes:

• Starting inner loop from 0 causing double counting
• Wrong comparison direction
• Incorrect return type

5. Given the array {8, 4, 2, 1}, what is the number of inversions using an efficient merge sort based approach?

hard

A. 6

B. 4

C. 5

D. 3

Solution

1. Step 1: Understand inversions in the array

   All pairs where first > second and first index < second index are: (8,4), (8,2), (8,1), (4,2), (4,1), (2,1).

2. Step 2: Count inversions carefully

   There are 6 pairs total, but merge sort counts inversions during merging. The efficient approach counts 6 inversions.

3. Step 3: Verify merge sort inversion count

   Merge sort counts 6 inversions for this array.

4. Final Answer:

   6 -> Option A

5. Quick Check:

   Inversions = 6 [OK]

Hint: Count pairs where left element is bigger during merge [OK]

Common Mistakes:

• Under-counting inversions by missing pairs
• Confusing brute force and merge sort counts
• Miscounting pairs with equal elements