How to Compare Array Elements in C

Comparing array elements in C is a fundamental operation in programming. This article provides various methods to compare array elements, ranging from basic element-by-element comparison to more efficient techniques using hashing. Understanding these methods allows developers to choose the most suitable approach for their specific needs.

Methods to Compare Array Elements in C

Element-by-Element Comparison using Loops

The simplest approach involves iterating through each element of both arrays and comparing corresponding elements. This method requires nested loops and has a time complexity of O(n*m), where ‘n’ and ‘m’ represent the sizes of the arrays. This approach is suitable for small arrays or when the order of elements matters. However, for larger arrays, this method becomes inefficient.

#include <stdio.h>
#include <stdbool.h>

bool compareArrays(int arr1[], int arr2[], int n, int m) {
  if (n != m) return false;
  for (int i = 0; i < n; i++) {
    if (arr1[i] != arr2[i]) return false;
  }
  return true;
}

int main() {
  int arr1[] = {1, 2, 3};
  int arr2[] = {1, 2, 3};
  int n = sizeof(arr1) / sizeof(arr1[0]);
  int m = sizeof(arr2) / sizeof(arr2[0]);

  if (compareArrays(arr1, arr2, n, m)) {
    printf("Arrays are equaln");
  } else {
    printf("Arrays are not equaln");
  }
  return 0;
}

This code demonstrates a basic element-by-element comparison of two arrays in C.

Comparing Arrays after Sorting

When the order of elements doesn’t matter, a more efficient approach involves sorting both arrays before comparison. After sorting, a single loop can compare corresponding elements. The time complexity of this method is dominated by the sorting algorithm, typically O(n log n), which is better than the nested loop approach for larger arrays.

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}


bool compareArrays(int arr1[], int arr2[], int n, int m) {

    if (n != m)
        return false;

    qsort(arr1, n, sizeof(int), compare);
    qsort(arr2, n, sizeof(int), compare);


    for (int i = 0; i < n; i++)
        if (arr1[i] != arr2[i])
            return false;

  return true;
}
//Driver code
int main() {
    int arr1[] = {1, 2, 3,3,4,2};
    int arr2[] = {3, 2, 1,2,4,3};
    int n = sizeof(arr1) / sizeof(arr1[0]);
    int m = sizeof(arr2) / sizeof(arr2[0]);

    if (compareArrays(arr1, arr2, n, m))
        printf("Arrays are equaln");
    else
        printf("Arrays are not equaln");

  return 0;
}

This code snippet showcases how to compare two arrays after sorting them using qsort in C. This approach is efficient for comparing unsorted arrays when the order of elements is not important.

Comparing Arrays using Hashing

For even greater efficiency, especially with large arrays and when element order is irrelevant, hashing can be used. A hash table (or frequency array) can store the frequency of each element in the first array. Then, iterate through the second array, decrementing the count for each element in the hash table. If an element is not found or its count reaches zero, the arrays are not equal. This method offers a time complexity of O(n), but requires O(n) extra space for the hash table.

#include <stdio.h>
#include <stdbool.h>
#define MAX_SIZE 100

bool areEqual(int arr1[], int arr2[], int n, int m)
{

    if (n != m)
        return false;


    int hash[MAX_SIZE] = { 0 };
    for (int i = 0; i < n; i++) {
        hash[arr1[i]]++;
    }


    for (int i = 0; i < n; i++) {

        if (hash[arr2[i]] == 0)
            return false;

        hash[arr2[i]]--;
    }
    return true;
}
// Driver Code
int main()
{
    int arr1[] = { 3, 5, 2, 5, 2 };
    int arr2[] = { 2, 3, 5, 5, 2 };
    int n = sizeof(arr1) / sizeof(int);
    int m = sizeof(arr2) / sizeof(int);

    if (areEqual(arr1, arr2, n, m))
        printf("Yes");
    else
        printf("No");
    return 0;
}

This C code snippet uses a hash table to efficiently determine if two arrays have the same elements, regardless of their order. This is particularly useful for large arrays.

Conclusion

Choosing the appropriate method for comparing array elements in C depends on factors such as array size, whether element order is significant, and performance requirements. For smaller arrays or when order matters, element-by-element comparison is sufficient. When order is not important, sorting then comparing offers better performance for larger arrays. Finally, hashing provides the most efficient solution for large arrays when order is irrelevant, at the cost of additional space for the hash table. Understanding these trade-offs enables developers to write optimized code for various array comparison scenarios.