Count Occurrences of Element in Sorted Array in DSA C++ - Build from Scratch

Count Occurrences of Element in Sorted Array

📖 Scenario: You have a sorted list of product IDs representing items sold in a store. You want to find out how many times a specific product ID appears in this list.

🎯 Goal: Build a program that counts how many times a given product ID appears in a sorted array of product IDs.

📋 What You'll Learn

Create an array called product_ids with the exact values: {101, 102, 102, 102, 103, 104, 104, 105}

Create an integer variable called target_id and set it to 102

Write a function called countOccurrences that takes the array product_ids, its size, and target_id as parameters and returns the count of target_id in the array

Print the count returned by countOccurrences

💡 Why This Matters

🌍 Real World

Counting how many times a product appears in sales data helps stores understand product popularity and manage inventory.

💼 Career

This skill is useful for software developers working with data analysis, inventory management systems, and any application needing frequency counts in sorted data.

1

Create the sorted array of product IDs

Create an integer array called product_ids with these exact values: {101, 102, 102, 102, 103, 104, 104, 105}

DSA C++

// Your code here

Hint

Use C++ array syntax to create product_ids with the given values.

2

Set the target product ID to count

Create an integer variable called target_id and set it to 102

DSA C++

int product_ids[] = {101, 102, 102, 102, 103, 104, 104, 105};
// Your code here

Hint

Declare target_id as an integer and assign it the value 102.

3

Write the function to count occurrences

Write a function called countOccurrences that takes three parameters: an integer array called arr, an integer size, and an integer target. The function should return the number of times target appears in arr. Use a for loop with variable i to iterate from 0 to size - 1 and count matches.

DSA C++

int product_ids[] = {101, 102, 102, 102, 103, 104, 104, 105};
int target_id = 102;

// Your code here

Hint

Use a loop to check each element and increase count when you find target.

4

Print the count of the target product ID

Print the result of calling countOccurrences with product_ids, the size of product_ids (which is 8), and target_id. Use std::cout to display the count.

DSA C++

int product_ids[] = {101, 102, 102, 102, 103, 104, 104, 105};
int target_id = 102;

int countOccurrences(int arr[], int size, int target) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            count++;
        }
    }
    return count;
}

// Your code here

Hint

Use std::cout to print the count returned by countOccurrences.

Practice

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

easy

A. It reduces the search time from linear to logarithmic

B. It sorts the array automatically

C. It uses less memory than linear search

D. It works only for unsorted arrays

Solution

1. Step 1: Understand linear vs binary search time

   Linear search checks each element one by one, taking O(n) time. Binary search divides the search space in half each time, taking O(log n) time.

2. Step 2: Apply binary search to counting occurrences

   Using binary search to find the first and last occurrence of the element reduces the total search time significantly compared to scanning the whole array.

3. Final Answer:

   It reduces the search time from linear to logarithmic -> Option A

4. Quick Check:

   Binary search = faster search [OK]

Hint: Binary search halves search space, speeding up counting [OK]

Common Mistakes:

• Thinking binary search sorts the array
• Confusing memory usage with speed
• Assuming binary search works on unsorted arrays

2. Which of the following C++ function signatures is correct for finding the first occurrence of an element in a sorted array using binary search?

easy

A. int firstOccurrence(int arr[], int x)

B. void firstOccurrence(int arr[], int n, int x)

C. int firstOccurrence(int arr, int n, int x)

D. int firstOccurrence(int arr[], int n, int x)

Solution

1. Step 1: Check parameter types and count

   The function needs the array (int arr[]), its size (int n), and the target element (int x).

2. Step 2: Check return type

   It should return an int index of the first occurrence, so return type is int.

3. Final Answer:

   int firstOccurrence(int arr[], int n, int x) -> Option D

4. Quick Check:

   Correct parameters and return type [OK]

Hint: Function returns index, needs array, size, and target [OK]

Common Mistakes:

• Missing array size parameter
• Wrong return type (void instead of int)
• Incorrect array parameter type

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

int arr[] = {1, 2, 2, 2, 3, 4, 5};
int n = 7;
int x = 2;

int countOccurrences(int arr[], int n, int x) {
    int first = -1, last = -1;
    int low = 0, high = n - 1;
    // Find first occurrence
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) {
            first = mid;
            high = mid - 1;
        } else if (arr[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    if (first == -1) return 0;
    low = first; high = n - 1;
    // Find last occurrence
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) {
            last = mid;
            low = mid + 1;
        } else if (arr[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return last - first + 1;
}

std::cout << countOccurrences(arr, n, x) << std::endl;

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Find first occurrence of 2

   Binary search finds first 2 at index 1.

2. Step 2: Find last occurrence of 2

   Binary search finds last 2 at index 3.

3. Step 3: Calculate count

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

4. Final Answer:

   3 -> Option A

5. Quick Check:

   Occurrences of 2 = 3 [OK]

Hint: Count = last index - first index + 1 [OK]

Common Mistakes:

• Returning last index instead of count
• Not updating low and high correctly
• Returning 0 when element exists

4. Identify the bug in the following code for counting occurrences of an element in a sorted array:

int countOccurrences(int arr[], int n, int x) {
    int first = -1, last = -1;
    int low = 0, high = n - 1;
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) {
            first = mid;
            high = mid - 1;
        } else if (arr[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    if (first == -1) return 0;
    low = first; high = n - 1;
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) {
            last = mid;
            low = mid + 1;
        } else if (arr[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return last - first + 1;
}

medium

A. Returning last - first instead of last - first + 1

B. Using 'while (low < high)' instead of 'while (low <= high)' causes missing last element

C. Incorrect calculation of mid index

D. Not initializing 'first' and 'last' to zero

Solution

1. Step 1: Analyze loop condition

   The loops use 'while (low < high)', which misses checking when low equals high, possibly skipping the last element.

2. Step 2: Correct loop condition

   Changing to 'while (low <= high)' ensures all elements are checked, including the last one.

3. Final Answer:

   Using 'while (low < high)' instead of 'while (low <= high)' causes missing last element -> Option B

4. Quick Check:

   Loop condition must include equality [OK]

Hint: Use <= in binary search loops to include all elements [OK]

Common Mistakes:

• Using < instead of <= in loops
• Not updating first and last correctly
• Miscomputing mid index

5. Given a sorted array with possible duplicates, how would you modify the binary search approach to count occurrences of multiple different elements efficiently without repeating the search for each element separately?

hard

A. Sort the array again before each search

B. Run binary search separately for each element to find counts

C. Precompute a frequency map using a single pass, then query counts in O(1)

D. Use linear search for each element to count occurrences

Solution

1. Step 1: Understand repeated binary search cost

   Running binary search for each element separately costs O(m log n) for m queries, which can be expensive.

2. Step 2: Use frequency map for efficiency

   A single pass over the sorted array can build a frequency map (element to count) in O(n). Then queries are O(1) each.

3. Final Answer:

   Precompute a frequency map using a single pass, then query counts in O(1) -> Option C

4. Quick Check:

   Frequency map = fast multiple queries [OK]

Hint: Build frequency map once, then answer queries instantly [OK]

Common Mistakes:

• Running binary search repeatedly for each query
• Sorting array multiple times unnecessarily
• Using linear search for each query