Programs on Arrays in C: A Comprehensive Guide

Introduction

Welcome to this comprehensive guide on programs on arrays in C!

Arrays are an essential data structure in the C programming language that allow you to store and manipulate a collection of elements of the same type.

Also Read: C Program To Read Two Files Simultaneously

In this article, we will explore various programs on arrays in C, covering different aspects and functionalities.

Whether you’re a beginner learning C or an experienced programmer looking to enhance your skills, this guide will provide you with valuable insights and practical examples of programs on arrays in c.

Also read: C Program to Display Numbers From 1 to n Except 6 and 9

Table of Contents

1. Initializing and Accessing Elements in an Array
2. Finding the Sum of Array Elements
3. Searching for an Element in an Array
4. Sorting an Array
5. Inserting and Deleting Elements in an Array
6. Merging Two Arrays
7. Reversing an Array
8. Finding the Maximum and Minimum Elements in an Array
9. Counting the Occurrences of an Element in an Array
10. Frequently Asked Questions
11. Conclusion

Also Read: Interview Questions On C

1. Initializing and Accessing Elements in an Array

In C, you can initialize arrays with a set of values during declaration or assign values to them later using index notation.

Also Read: Armstrong Number in C Programming

For example, consider the following program that initializes an array of integers and accesses its elements:

#include <stdio.h>

int main() {
   int numbers[5] = {1, 2, 3, 4, 5};
   
   printf("The second element is: %d", numbers[1]);
   
   return 0;
}

In this program, we declare an integer array named numbers with five elements and initialize them with the values 1, 2, 3, 4, and 5.

The statement numbers[1] accesses the second element of the array, which is 2. The output of this program will be The second element is: 2.

Also Read: C Program to Find the Inverse of 2×2 Matrix

2. Finding the Sum of Array Elements

To find the sum of elements in an array, you can iterate over each element and accumulate their values.

Here’s an example program that demonstrates this:

#include <stdio.h>

int main() {
   int numbers[5] = {1, 2, 3, 4, 5};
   int sum = 0;
   
   for (int i = 0; i < 5; i++) {
       sum += numbers[i];
   }
   
   printf("The sum of array elements is: %d", sum);
   
   return 0;
}

In this program, we initialize an integer array numbers with five elements and calculate their sum using a for loop.

The variable sum is used to accumulate the values of each element. The output will be The sum of array elements is: 15.

Also read: C Program to Print Multiples of 5 using do while loop

3. Searching for an Element in an Array

To search for an element in an array, you can iterate over each element and compare it with the target value.

If you find a match, you can return the index or perform any desired action.

Here’s an example program that demonstrates this:

#include <stdio.h>

int main() {
   int numbers[5] = {10, 20, 30, 40, 50};
   int target = 30;
   int index = -1;
   
   for (int i = 0; i < 5; i++) {
       if (numbers[i] == target) {
           index = i;
           break;
       }
   }
   
   if (index != -1) {
       printf("Element found at index: %d", index);
   } else {
       printf("Element not found in the array");
   }
   
   return 0;
}

In this program, we have an array numbers and a target value of 30. We iterate over each element and check if it matches the target value.

Also Read: C Program to Copy the Contents of One File into Another File

If a match is found, we store the index in the variable index and break out of the loop. The output will be Element found at index: 2 since 30 is present at index 2 in the array.

4. Sorting an Array

Sorting an array involves arranging its elements in a specific order, such as ascending or descending.

There are several sorting algorithms available, including bubble sort, selection sort, insertion sort, and more.

Also Read: 25 Tricky Questions on Pointers in C: Explained and Answered

Here’s an example program that sorts an array using the bubble sort algorithm:

#include <stdio.h>

void bubbleSort(int array[], int size) {
   for (int i = 0; i < size - 1; i++) {
       for (int j = 0; j < size - i - 1; j++) {
           if (array[j] > array[j + 1]) {
               int temp = array[j];
               array[j] = array[j + 1];
               array[j + 1] = temp;
           }
       }
   }
}

int main() {
   int numbers[5] = {5, 3, 1, 4, 2};
   int size = sizeof(numbers) / sizeof(numbers[0]);
   
   bubbleSort(numbers, size);
   
   printf("Sorted array: ");
   for (int i = 0; i < size; i++) {
       printf("%d ", numbers[i]);
   }
   
   return 0;
}

In this program, we define a function bubbleSort that implements the bubble sort algorithm.

The main function initializes an integer array numbers and calculates its size. The bubbleSort function is then called to sort the array in ascending order.

Finally, the sorted array is printed using a loop. The output will be Sorted array: 1 2 3 4 5.

Also Read: C Program to Find the Sum of Cubes of Elements in an Array

5. Inserting and Deleting Elements in an Array

To insert or delete elements in an array, you need to shift the existing elements accordingly.

Here’s an example program that demonstrates how to insert and delete elements in an array:

#include <stdio.h>

void insertElement(int array[], int size, int position, int value) {
   for (int i = size - 1; i >= position; i--) {
       array[i + 1] = array[i];
   }
   
   array[position] = value;
}

void deleteElement(int array[], int size, int position) {
   for (int i = position; i < size - 1; i++) {
       array[i] = array[i + 1];
   }
}

int main() {
   int numbers[5] = {1, 2, 3, 4, 5};
   int size = 5;
   
   insertElement(numbers, size, 2, 10);
   size++;
   
   deleteElement(numbers, size, 3);
   size--;
   
   printf("Modified array: ");
   for (int i = 0; i < size; i++) {
       printf("%d ", numbers[i]);
   }
   
   return 0;
}

In this program, we define two functions insertElement and deleteElement to insert and delete elements in an array, respectively.

The main function initializes an integer array numbers and its size. We then insert an element with the value 10 at position 2 and increment the size.

Next, we delete the element at position 3 and decrement the size.

Finally, the above program print the modified array. The output will be Modified array: 1 2 10 4.

Also Read: C Program to Display a String in Capital Letters

6. Merging Two Arrays

Merging two arrays involves combining the elements of both arrays into a single array.

Here’s an example program that merges two arrays:

#include <stdio.h>

void mergeArrays(int array1[], int size1, int array2[], int size2, int mergedArray[]) {
   int i = 0, j = 0, k = 0;
   
   while (i < size1 && j < size2) {
       if (array1[i] < array2[j]) {
           mergedArray[k++] = array1[i++];
       } else {
           mergedArray[k++] = array2[j++];
       }
   }
   
   while (i < size1) {
       mergedArray[k++] = array1[i++];
   }
   
   while (j < size2) {
       mergedArray[k++] = array2[j++];
   }
}

int main() {
   int array1[3] = {1, 3, 5};
   int array2[4] = {2, 4, 6, 8};
   int size1 = sizeof(array1) / sizeof(array1[0]);
   int size2 = sizeof(array2) / sizeof(array2[0]);
   int mergedArray[size1 + size2];
   
   mergeArrays(array1, size1, array2, size2, mergedArray);
   
   printf("Merged array: ");
   for (int i = 0; i < size1 + size2; i++) {
       printf("%d ", mergedArray[i]);
   }
   
   return 0;
}

In this program, we define a function mergeArrays that takes two arrays (array1 and array2), their respective sizes, and a merged array (mergedArray) as parameters.

The function merges the elements of both arrays into the mergedArray in ascending order.

Also Read: Best 5 Programs on Fibonacci Series in C

The main function initializes two arrays and their sizes, and then calls the mergeArrays function to merge the arrays.

Finally, the program merged array. The output will be Merged array: 1 2 3 4 5 6 8.

7. Reversing an Array

To reverse the elements of an array, you can swap the elements from the beginning and end, moving towards the middle of the array.

Here’s an example program that reverses an array:

#include <stdio.h>

void reverseArray(int array[], int size) {
   int start = 0;
   int end = size - 1;
   
   while (start < end) {
       int temp = array[start];
       array[start] = array[end];
       array[end] = temp;
       
       start++;
       end--;
   }
}

int main() {
   int numbers[5] = {1, 2, 3, 4, 5};
   int size = sizeof(numbers) / sizeof(numbers[0]);
   
   reverseArray(numbers, size);
   
   printf("Reversed array: ");
   for (int i = 0; i < size; i++) {
       printf("%d ", numbers[i]);
   }
   
   return 0;
}

In this program, we define a function reverseArray that reverses the elements of an array.

The main function initializes an integer array numbers and calculates its size. The reverseArray function is then called to reverse the array elements.

Finally, the program reversed array.

The output will be Reversed array: 5 4 3 2 1.

Also Read: C Program to Display a String in Capital Letters

8. Finding the Maximum and Minimum Elements in an Array

To find the maximum and minimum elements in an array, you can iterate over each element and update the maximum and minimum values accordingly.

Here’s an example program that finds the maximum and minimum elements in an array:

#include <stdio.h>

void findMinMax(int array[], int size, int* min, int* max) {
   *min = array[0];
   *max = array[0];
   
   for (int i = 1; i < size; i++) {
       if (array[i] < *min) {
           *min = array[i];
       }
       
       if (array[i] > *max) {
           *max = array[i];
       }
   }
}

int main() {
   int numbers[5] = {5, 2, 8, 1, 6};
   int size = sizeof(numbers) / sizeof(numbers[0]);
   int min, max;
   
   findMinMax(numbers, size, &min, &max);
   
   printf("Minimum element: %d\n", min);
   printf("Maximum element: %d\n", max);
   
   return 0;
}

In this program, we define a function findMinMax that finds the minimum and maximum elements in an array.

The main function initializes an integer array numbers and its size. We then call the findMinMax function to find the minimum and maximum elements, storing the results in variables min and max.

Finally, the program printed minimum and maximum elements.

The output will be:

Minimum element: 1
Maximum element: 8

9. Counting the Occurrences of an Element in an Array

To count the occurrences of a specific element in an array, you can iterate over each element and compare it with the target value.

If there is a match, you increment a counter variable.

Here’s an example program that counts the occurrences of an element in an array:

#include <stdio.h>

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

int main() {
   int numbers[8] = {1, 2, 3, 2, 4, 2, 5, 2};
   int size = sizeof(numbers) / sizeof(numbers[0]);
   int target = 2;
   
   int occurrences = countOccurrences(numbers, size, target);
   
   printf("Number of occurrences of %d: %d\n", target, occurrences);
   
   return 0;
}

In this program, we define a function countOccurrences that counts the occurrences of a target element in an array.

The main function initializes an integer array numbers, its size, and the target element. We then call the countOccurrences function to count the occurrences of the target element and store the result in the occurrences variable.

Finally, the program printed number of occurrences.

The output will be Number of occurrences of 2: 4.

Frequently Asked Questions

Conclusion

Arrays in C are a fundamental data structure that allows you to store and manipulate collections of elements.

Understanding how to work with arrays is essential for writing efficient and effective C programs.

In this article, we covered various topics related to programs on arrays in C, including array declaration, initialization, accessing elements, performing operations like searching, sorting, inserting, deleting, merging, reversing, finding the maximum and minimum elements, and counting occurrences.

By mastering these concepts, you’ll be well-equipped to work with arrays in C and tackle a wide range of programming problems.

Remember to practice writing and running the code examples provided in this article to solidify your understanding.

As you gain more experience, you’ll become more proficient in working with arrays and be able to apply this knowledge to real-world programming scenarios. Happy coding!