Counting the occurrence of a specific element in an array is a common task in C programming. This operation helps you understand how data is stored, accessed, and processed in arrays. By learning to count elements, you gain insights into loops, conditional statements, and efficient ways to traverse arrays.
In this tutorial, we will write a complete C program to count how many times a given number appears in an array. By the end of this article, you will be able to count occurrences of any element in an array confidently and apply this knowledge to more complex programs.
Understanding the Problem
The problem is simple: given an array of numbers and a target value, determine how many times the target appears in the array. For example, if the array is [1, 2, 3, 2, 4, 2] and the target is 2, the program should return 3 because 2 appears three times.
This problem reinforces fundamental concepts in C such as arrays, loops, and conditional checks. It also prepares you for more advanced topics like searching, sorting, and frequency analysis.
Program 1: Using a Simple Loop
We will start with a straightforward approach using a for loop. The idea is to traverse the array element by element and increment a counter whenever we find a match.
#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 2, 4, 2};
int size = sizeof(arr) / sizeof(arr[0]);
int target = 2;
int count = 0;
for (int i = 0; i < size; i++) {
if (arr[i] == target) {
count++;
}
}
printf("The element %d appears %d times in the array.\n", target, count);
return 0;
}In this program, we first declare an array with some numbers and calculate its size using sizeof(arr)/sizeof(arr[0]). The target variable holds the number we want to count. We initialize a counter count to zero. The for loop iterates through each element, and the if statement checks if the current element matches the target. If it does, we increment count. Finally, we print the result using printf().
Program 2: Using a Function for Reusability
It is often a good practice to use functions for tasks like counting occurrences. This makes your code reusable and organized.
#include <stdio.h>
int countOccurrence(int arr[], int size, int target) {
int count = 0;
for (int i = 0; i < size; i++) {
if (arr[i] == target) {
count++;
}
}
return count;
}
int main() {
int arr[] = {1, 3, 5, 3, 7, 3};
int size = sizeof(arr) / sizeof(arr[0]);
int target = 3;
int result = countOccurrence(arr, size, target);
printf("The element %d appears %d times in the array.\n", target, result);
return 0;
}Here, we define a function countOccurrence that takes an array, its size, and the target element. The logic inside the function is the same as before: we iterate through the array, check for matches, and increment the counter. The main function calls this reusable function and prints the result. Using functions makes your code cleaner and easier to maintain.
Program 3: Using Pointers
For learners who want to understand pointers, counting occurrences can also be done using pointer arithmetic instead of array indexing.
#include <stdio.h>
int main() {
int arr[] = {4, 5, 6, 4, 7, 4};
int size = sizeof(arr) / sizeof(arr[0]);
int target = 4;
int count = 0;
int *ptr = arr; // pointer to the first element of the array
for (int i = 0; i < size; i++) {
if (*(ptr + i) == target) { // access i-th element using pointer arithmetic
count++;
}
}
printf("The element %d appears %d times in the array.\n", target, count);
return 0;
}In this version, we use a pointer ptr to refer to the array. The expression *(ptr + i) accesses the i-th element of the array, similar to arr[i]. This demonstrates how pointers and arrays are closely related in C. The counting logic remains the same.
In C, the name of the array itself is already a pointer to the first element. That means you don’t actually need ptr—you can use arr directly with pointer arithmetic.
So instead of:
int *ptr = arr; // pointer to the first element of the array
for (int i = 0; i < size; i++) {
if (*(ptr + i) == target) { // access i-th element using pointer arithmetic
count++;
}
}You can just write:
for (int i = 0; i < size; i++) {
if (*(arr + i) == target) { // access i-th element using pointer arithmetic
count++;
}
}Both do the same thing: move i elements from the start of the array and get the value there.
In short: arr already “is a pointer”, so a separate pointer variable isn’t required.
Performance Comparison
All three methods discussed are simple and effective. The main difference lies in readability and reusability. The simple loop is easiest to understand, the function method is best for reusable code, and the pointer method is slightly more advanced but demonstrates a deeper understanding of C.
| Method | Time Complexity | Space Complexity | Notes |
|---|---|---|---|
| Simple Loop | O(n) | O(1) | Easy for beginners to understand |
| Function Approach | O(n) | O(1) | Reusable, good for modular programming |
| Pointer Approach | O(n) | O(1) | Shows use of pointers, slightly advanced |
FAQs
1. Can this program work for arrays of characters or strings?
Yes. You can use the same logic to count occurrences of characters in a char array. For strings, you need to use functions like strcmp() to compare elements.
2. What if the array is very large?
All methods have O(n) time complexity. They are efficient even for large arrays, but you may consider more advanced data structures if you need to count multiple elements frequently.
3. Can I count occurrences of multiple elements at once?
Yes. You can use a loop over target elements or use a frequency array or hash table to store counts for each element.
Conclusion
Counting the occurrence of an element in an array is a fundamental programming task that helps you understand loops, conditional statements, and array manipulation in C. You have learned three approaches: using a simple loop, a reusable function, and pointers. Each approach has its advantages depending on the context and your learning goals.
By practicing these methods, you will strengthen your understanding of arrays and improve your problem-solving skills. Start experimenting with different arrays and targets to gain confidence in applying these techniques in real programs.
References & Additional Resources
A curated collection of textbooks and tutorials to understand arrays, their operations, and pointers in C.
- Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd Edition, Prentice Hall, 1988 – The foundational textbook covering C syntax, arrays, pointers, and essential programming concepts.
- GeeksforGeeks: Count Occurrences in Array – Explains how to count how many times each element appears in an array, with examples and variations.
- Cprogramming.com: C Tutorial – Beginner-friendly tutorial covering arrays, loops, and basic operations.
- Tutorialspoint: C Arrays – Comprehensive overview of arrays, including declaration, initialization, and common operations in C.
- cplusplus.com: Pointers – Introduction to pointers in C, including syntax, usage, and examples with arrays.
