Count Occurrences of Element in Sorted Array in DSA Go - Time & Space Complexity

Time Complexity: Count Occurrences of Element in Sorted Array

O(log n)

Understanding Time Complexity

We want to know how fast we can count how many times a number appears in a sorted list.

How does the time needed change when the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func countOccurrences(arr []int, target int) int {
    left := binarySearch(arr, target, true)
    if left == -1 {
        return 0
    }
    right := binarySearch(arr, target, false)
    return right - left + 1
}

func binarySearch(arr []int, target int, findFirst bool) int {
    low, high := 0, len(arr)-1
    result := -1
    for low <= high {
        mid := low + (high-low)/2
        if arr[mid] == target {
            result = mid
            if findFirst {
                high = mid - 1
            } else {
                low = mid + 1
            }
        } else if arr[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return result
}
    

This code finds the first and last position of the target using binary search, then counts how many times it appears.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The binary search loop inside binarySearch runs repeatedly.
• How many times: Each binary search runs about log₂(n) times, where n is the array size.
• We do two binary searches: one to find the first occurrence, one for the last.

How Execution Grows With Input

As the list gets bigger, the number of steps grows slowly, not directly with the size.

Input Size (n)	Approx. Operations
10	About 2 x 4 = 8 steps
100	About 2 x 7 = 14 steps
1000	About 2 x 10 = 20 steps

Pattern observation: Doubling the input size adds only a few more steps because binary search cuts the search space in half each time.

Final Time Complexity

Time Complexity: O(log n)

This means the time to count occurrences grows slowly as the list grows, making it very efficient.

Common Mistake

[X] Wrong: "Counting occurrences requires checking every element, so it must be O(n)."

[OK] Correct: Because the array is sorted, we can use binary search to jump directly to the target's positions without checking all elements.

Interview Connect

Understanding how to use binary search to count occurrences shows you can use smart searching techniques, a skill valued in many coding challenges.

Self-Check

"What if the array was not sorted? How would the time complexity change?"

Practice

1. What is the main advantage of using a binary search approach to count occurrences of an element in a sorted array?

easy

A. It counts all elements without searching.

B. It sorts the array automatically.

C. It reduces the search time to logarithmic complexity.

D. It works only on unsorted arrays.

Solution

1. Step 1: Understand binary search efficiency

   Binary search divides the search space in half each time, making it faster than linear search.

2. Step 2: Apply to counting occurrences

   By finding the first and last positions of the element, we can count occurrences efficiently.

3. Final Answer:

   It reduces the search time to logarithmic complexity. -> Option C

4. Quick Check:

   Binary search = O(log n) time [OK]

Hint: Binary search halves search space each step [OK]

Common Mistakes:

• Thinking binary search sorts the array
• Using linear search for counting in sorted array
• Assuming binary search works on unsorted arrays

2. Which Go code snippet correctly declares a function to count occurrences of an integer in a sorted slice?

easy

A. func countOccurrences(arr []int, target int) int { return 0 }

B. func countOccurrences(arr int[], target int) int { return 0 }

C. func countOccurrences(arr []int, target int) string { return "0" }

D. func countOccurrences(arr []int, target int) { return 0 }

Solution

1. Step 1: Check function signature syntax

   In Go, slices are declared as []int, and return type int is correct for count.

2. Step 2: Validate return statement matches return type

   Returning 0 as int matches the return type int.

3. Final Answer:

   func countOccurrences(arr []int, target int) int { return 0 } -> Option A

4. Quick Check:

   Correct Go function syntax [OK]

Hint: Use []int for slices and match return type [OK]

Common Mistakes:

• Using array syntax int[] instead of []int
• Mismatching return type and return value
• Omitting return type in function signature

3. What will be the output of the following Go code snippet?

func countOccurrences(arr []int, target int) int {
    left := 0
    right := len(arr) - 1
    first := -1
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            first = mid
            right = mid - 1
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    if first == -1 {
        return 0
    }
    left = 0
    right = len(arr) - 1
    last := -1
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            last = mid
            left = mid + 1
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return last - first + 1
}

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

medium

A. 2

B. 3

C. 1

D. 0

Solution

1. Step 1: Find first occurrence of 2

   Binary search finds first index of 2 at position 1.

2. Step 2: Find last occurrence of 2

   Binary search finds last index of 2 at position 3.

3. Step 3: Calculate count

   Count = last - first + 1 = 3 - 1 + 1 = 3.

4. Final Answer:

   3 -> Option B

5. Quick Check:

   Occurrences of 2 = 3 [OK]

Hint: Find first and last index, then subtract [OK]

Common Mistakes:

• Returning index instead of count
• Not updating left/right correctly in binary search
• Confusing first and last occurrence indices

4. Identify the bug in the following Go function that counts occurrences of a target in a sorted array:

func countOccurrences(arr []int, target int) int {
    left, right := 0, len(arr)-1
    count := 0
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            count++
            break
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return count
}

medium

A. It counts only one occurrence, not all.

B. It causes an infinite loop.

C. It returns the index instead of count.

D. It does not handle empty arrays.

Solution

1. Step 1: Analyze loop behavior

   The loop breaks after finding one occurrence, so count increments only once.

2. Step 2: Understand counting logic

   Counting all occurrences requires searching for first and last positions, not just one match.

3. Final Answer:

   It counts only one occurrence, not all. -> Option A

4. Quick Check:

   Loop breaks early, count = 1 [OK]

Hint: Break stops counting after first match [OK]

Common Mistakes:

• Using break instead of continuing search
• Not searching for first and last indices
• Assuming one match equals total count

5. Given a sorted array with possible duplicates, how would you modify the binary search approach to count occurrences of multiple target values efficiently? Choose the best approach.

hard

A. Perform separate binary searches for first and last occurrences of each target, then sum counts.

B. Use a linear scan for each target to count occurrences.

C. Sort the array again before counting each target.

D. Use a hash map to store counts after one full scan.

Solution

1. Step 1: Consider efficiency for multiple targets

   Binary search per target is O(k log n) for k targets, which can be costly.

2. Step 2: Use hash map after one scan

   A single linear scan builds a map of counts for all elements in O(n), allowing O(1) lookup per target.

3. Step 3: Compare approaches

   Hash map approach is more efficient for multiple queries than repeated binary searches.

4. Final Answer:

   Use a hash map to store counts after one full scan. -> Option D

5. Quick Check:

   Hash map = efficient multiple counts [OK]

Hint: Build counts once, then query fast [OK]

Common Mistakes:

• Repeating binary search for each target
• Sorting array multiple times unnecessarily
• Ignoring hash map for frequency counting