Count Inversions in Array in DSA Go

Mental Model

Count how many pairs of numbers are out of order in an array. Each pair where a bigger number comes before a smaller one is an inversion.

Analogy: Imagine a line of people waiting by height. Every time a taller person stands before a shorter person, it counts as a mix-up or inversion.

Array: [2, 4, 1, 3, 5]
Inversions: (2,1), (4,1), (4,3)
Visual:
2 -> 4 -> 1 -> 3 -> 5
↑    ↑    ↑    ↑    ↑

Dry Run Walkthrough

Input: array: [2, 4, 1, 3, 5]

Goal: Count all pairs where a bigger number appears before a smaller number

Step 1: Split array into two halves: left=[2,4,1], right=[3,5]

left: 2 -> 4 -> 1
right: 3 -> 5

Why: Divide to conquer smaller parts for easier counting

Step 2: Split left half again: left_left=[2,4], left_right=[1]

left_left: 2 -> 4
left_right: 1

Why: Keep dividing until subarrays have one or two elements

Step 3: Count inversions in left_left: compare 2 and 4, no inversion

left_left sorted: 2 -> 4

Why: Two elements sorted, no inversion found

Step 4: Merge left_left and left_right: compare 2 and 1, 1 is smaller, count 2 inversions (2>1 and 4>1)

merged left: 1 -> 2 -> 4

Why: Smaller element from right half causes inversions with remaining left elements

Step 5: Count inversions in right half: [3,5] no inversion

right sorted: 3 -> 5

Why: Right half already sorted, no inversions

Step 6: Merge left and right halves: compare 1 and 3, no inversion; 2 and 3, no inversion; 4 and 3, inversion found

final sorted: 1 -> 2 -> 3 -> 4 -> 5

Why: 4 > 3 causes one inversion during merge

Result:

Sorted array: 1 -> 2 -> 3 -> 4 -> 5
Total inversions: 3

Annotated Code

DSA Go

package main

import "fmt"

func merge(arr []int, temp []int, left int, mid int, right int) int {
    i := left
    j := mid + 1
    k := left
    invCount := 0

    for i <= mid && j <= right {
        if arr[i] <= arr[j] {
            temp[k] = arr[i]
            i++
            k++
        } else {
            temp[k] = arr[j]
            invCount += (mid - i + 1) // count inversions
            j++
            k++
        }
    }

    for i <= mid {
        temp[k] = arr[i]
        i++
        k++
    }

    for j <= right {
        temp[k] = arr[j]
        j++
        k++
    }

    for idx := left; idx <= right; idx++ {
        arr[idx] = temp[idx]
    }

    return invCount
}

func mergeSort(arr []int, temp []int, left int, right int) int {
    invCount := 0
    if left < right {
        mid := (left + right) / 2
        invCount += mergeSort(arr, temp, left, mid)       // sort left half
        invCount += mergeSort(arr, temp, mid+1, right)    // sort right half
        invCount += merge(arr, temp, left, mid, right)   // merge and count inversions
    }
    return invCount
}

func countInversions(arr []int) int {
    temp := make([]int, len(arr))
    return mergeSort(arr, temp, 0, len(arr)-1)
}

func main() {
    arr := []int{2, 4, 1, 3, 5}
    inversions := countInversions(arr)
    fmt.Printf("Sorted array: %v\n", arr)
    fmt.Printf("Total inversions: %d\n", inversions)
}

if arr[i] <= arr[j] {

compare elements to decide which goes first in merged array

invCount += (mid - i + 1) // count inversions

count how many elements left in left half are greater than arr[j]

invCount += mergeSort(arr, temp, left, mid) // sort left half

recursively count inversions in left half

invCount += mergeSort(arr, temp, mid+1, right) // sort right half

recursively count inversions in right half

invCount += merge(arr, temp, left, mid, right) // merge and count inversions

merge two halves and count cross inversions

Output

Sorted array: [1 2 3 4 5]

Total inversions: 3

Complexity Analysis

Time: O(n log n) because the array is repeatedly split and merged, counting inversions during merges

Space: O(n) due to temporary array used for merging

vs Alternative: Naive approach is O(n^2) by checking all pairs, which is much slower for large arrays

Edge Cases

empty array

returns 0 inversions without error

DSA Go

if left < right {

array with one element

returns 0 inversions as no pairs exist

DSA Go

if left < right {

array with all equal elements

returns 0 inversions since no element is greater than another

DSA Go

if arr[i] <= arr[j] {

When to Use This Pattern

When asked to count how many pairs are out of order in an array, use the merge sort inversion counting pattern because it efficiently counts while sorting.

Common Mistakes

Mistake: Counting inversions only when elements are strictly greater, missing equal elements condition
Fix: Use <= in comparison to avoid counting equal elements as inversions

Mistake: Not merging sorted halves properly, leading to incorrect inversion counts
Fix: Ensure merge step correctly merges and counts cross inversions

Summary

Counts how many pairs in an array are out of order by using a modified merge sort.

Use it when you need to find how 'unsorted' an array is efficiently.

The key insight is counting inversions during the merge step while sorting.

Practice

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

easy

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

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

C. The total number of elements in the array

D. The sum of all elements in the array

Solution

1. Step 1: Understand the definition of inversion

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

2. Step 2: Identify the correct description

   A pair of elements where the first is greater than the second and appears before it correctly describes this condition as the first element being greater and appearing before the second.

3. Final Answer:

   A -> Option B

4. Quick Check:

   Inversion = pair where first > second and first appears earlier [OK]

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

Common Mistakes:

• Confusing inversion with sorted order
• Thinking inversion counts equal or smaller pairs
• Mixing up element positions

2. Which of the following Go code snippets correctly declares a function to count inversions in an integer slice?

easy

A. func countInversions(arr []int) int { return 0 }

B. func countInversions(arr int[]) int { return 0 }

C. func countInversions(arr []int) void { return 0 }

D. func countInversions(arr []int) int { return "0" }

Solution

1. Step 1: Check function signature syntax in Go

   In Go, a function with an integer slice parameter and integer return type is declared as func name(arr []int) int.

2. Step 2: Validate return statement type

   func countInversions(arr []int) int { return 0 } returns an integer 0, matching the return type. Other options have syntax errors or wrong return types.

3. Final Answer:

   C -> Option A

4. Quick Check:

   Correct Go function syntax returns int [OK]

Hint: Go slices use []int, return type after params [OK]

Common Mistakes:

• Using wrong slice syntax like int[]
• Returning wrong type like string instead of int
• Using void instead of int for return type

3. What is the output of the following Go code snippet?

func main() {
    arr := []int{2, 4, 1, 3, 5}
    fmt.Println(countInversions(arr))
}

func countInversions(arr []int) int {
    count := 0
    for i := 0; i < len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i] > arr[j] {
                count++
            }
        }
    }
    return count
}

medium

A. 4

B. 5

C. 2

D. 3

Solution

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

   Array: [2, 4, 1, 3, 5]. Inversions are (2,1), (4,1), (4,3). Total = 3.

2. Step 2: Confirm count from nested loops

   Loops check all pairs i

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Inversions counted = 3 [OK]

Hint: Count pairs where earlier number is bigger [OK]

Common Mistakes:

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

4. The following Go function is intended to count inversions but has a bug. What is the bug?

func countInversions(arr []int) int {
    count := 0
    for i := 0; i <= len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i] > arr[j] {
                count++
            }
        }
    }
    return count
}

medium

A. The outer loop uses <= causing index out of range error

B. The inner loop starts from wrong index

C. The comparison operator should be < instead of >

D. The count variable is not initialized

Solution

1. Step 1: Analyze loop boundaries

   The outer loop runs with i <= len(arr), which means i can equal len(arr), causing arr[i] to be out of range.

2. Step 2: Identify correct loop condition

   The loop should use i < len(arr) to avoid accessing invalid index.

3. Final Answer:

   The outer loop uses <= causing index out of range error -> Option A

4. Quick Check:

   Loop index must be less than length [OK]

Hint: Loop index must be less than length, not less or equal [OK]

Common Mistakes:

• Using <= instead of < in loops
• Starting inner loop at wrong index
• Wrong comparison operator

5. Given the array [8, 4, 2, 1], which approach is the most efficient to count inversions and what is the inversion count?

hard

A. Use bubble sort swaps count; inversion count is 4

B. Use brute force nested loops; inversion count is 6

C. Use merge sort based method; inversion count is 6

D. Use quicksort partition count; inversion count is 3

Solution

1. Step 1: Understand efficient inversion counting

   Merge sort based method counts inversions in O(n log n) time, more efficient than brute force O(n²).

2. Step 2: Calculate inversion count for [8,4,2,1]

   Inversions: (8,4), (8,2), (8,1), (4,2), (4,1), (2,1) = 6 total.

3. Final Answer:

   Use merge sort based method; inversion count is 6 -> Option C

4. Quick Check:

   Merge sort counts 6 inversions efficiently [OK]

Hint: Use merge sort for fast inversion count [OK]

Common Mistakes:

• Using slow brute force for large arrays
• Miscounting inversion pairs
• Confusing inversion count with swap count