{"post":"

Array operations in C – Part 2

The next set of array operations are:

Insertion
Deletion
Searching
Merging

Insertion of an element into the array:

Insertion of an element in the array, could either be at the start , at the end or anywhere in between as well.
We take the location at which the user wants to insert the element into the array.
Next, we check if the position entered is valid or not. For the user the position would start from number 1. Thus in terms of array index, actual array index position is position – 1
If the position is invalid same is communicated to the user and program is terminated.
The position is invalid if position is < 1 i.e. less than starting of array and position > n+1 , i.e. if your array has 4 elements; the user might want to insert element at 4th position which is nth position, else also insert it as the n+1th element i.e. 5th element or after the current arrays end.
If position is valid, the element is inserted at required location and resultant array is displayed.

Code:

#include <stdio.h>\nint main()
\n{
\n  int array[100], position, i, n, value;
\n  printf(\"Enter number of elements in array\\n\");
\n  scanf(\"%d\", &n);
\n  printf(\"Enter array elements:\\n\", n);
\n  for (i = 0; i < n; i++)
\n     scanf(\"%d\", &array[i]);
\n  printf(\"Enter the location where you wish to insert an element\\n\");
\n  scanf(\"%d\", &position);
\n  
\n  if(position > n+1 || position < 1)
\n  {
\n     printf(\"The position entered is invalid\\n\");
\n  }
\n   else
\n   {
\n  printf(\"Enter the value to insert\\n\");
\n  scanf(\"%d\", &value);
\n  for (i = n - 1; i >= position - 1; i--)
\n     array[i+1] = array[i];
\n  array[position-1] = value;  //inserting value at the required location
\n  printf(\"Resultant array is:\\n\");
\n  for (i = 0; i <= n; i++)
\n     printf(\"%d\\n\", array[i]);
\n   }
\n  return 0;
\n}

Output:

Case 1: Insertion location valid

Enter number of elements in array\n6 \nEnter array elements: \n12 \n13 \n14 \n15 \n16 \n17 \nEnter the location where you wish to insert an element \n3 \nEnter the value to insert \n20 \nResultant array is: \n12 \n13 \n20 \n14 \n15 \n16 \n

17

Case 2: Insertion location is invalid

Enter number of elements in array\n4 \nEnter array elements: \n10 \n11 \n12 \n13 \nEnter the location where you wish to insert an element \n6 \n

The position entered is invalid

Deletion of an element from the array:

For deletion of an element from the array, we need to accept the location from which user wishes to delete the element.
When the location is entered by user, we store it in a variable – position.
For user location starts from position : 1. However array index starts from 0. Hence, when we delete the element we need to delete element present at location = position -1.
What we essentially do is, shift the element next to the element to be deleted to the location = position -1, i.e. the next element is placed in position of deleted element and so on we keep shifting the remaining elements by one position to the left.
If an invalid location is entered, deletion is not possible an the same is conveyed to the user.

Code:

#include <stdio.h>\nint main()
\n{
\n  int array[100], position, i, n, num;
\n  printf(\"Enter number of elements in array\\n\");
\n  scanf(\"%d\", &n);
\n  printf(\"Enter array elements:\\n\");
\n   for (i = 0; i < n; i++)
\n     scanf(\"%d\", &array[i]);
\n  printf(\"Enter the location from where you wish to delete the element:\\n\");
\n  scanf(\"%d\", &position);
\n  
\n  num = array[position-1];
\n   if (position >= n+1 || position < 0)         /*n+1, since user will count element as position 1
\n    onwards. Internally though indexing starts from 0,
\n    which user would not know.*/
\n     printf(\"Deletion not possible as entered location is invalid.\\n\");
\n  else
\n  {
\n     for (i = position - 1; i < n - 1; i++)   //since array index starts from 0; thus position in terms
\nof array index is position-1
\n        array[i] = array[i+1];
\n     printf(\"Resultant array after deletion of element %d from location %d:\\n\", num, position);
\n     for (i = 0; i < n - 1; i++)
\n        printf(\"%d\\n\", array[i]);
\n  }
\n  return 0;
\n}

Output:

Case 1: Entered location is valid\nEnter number of elements in array \n5 \nEnter array elements: \n14 \n15 \n16 \n17 \n18 \nEnter the location from where you wish to delete the element: \n3 \nResultant array after deletion of element 16 from location 3: \n14 \n15 \n17 \n18 \nCase 2: Entered location is invalid \nEnter number of elements in array \n5 \nEnter array elements: \n14 \n15 \n16 \n17 \n18 \nEnter the location from where you wish to delete the element: \n6 \n

Deletion not possible as entered location is invalid.

Searching element of an array:

Searching an element of an array is to check if a user entered element is present in the array or not. If present we display the position at which the element was found in the array.
There are various searching techniques that can be used to find an array element.
We are going to learn to implement the same using Linear Search.
Linear search is not efficient as it scans for each element sequentially, however it is the easiest to understand and implement for beginners.

Approach:

We accept the array input from user.
The user will enter the element that needs to be searched in the array.
We scan the entire array sequentially to search for entered element 'num'.
On discovering the element in the array at location i, we display it to the user.
If the element occurs at more than one place as well, the search continues until end of array is reached.
Once end of array is reached, loop is exited.
If even after scanning entire array element is not found, ( i==n) then same is conveyed to user.

Code:

#include <stdio.h>\nint main()
\n{
\n int array[100], num, i, n;
\n printf(\"Enter number of elements in array\\n\");
\n scanf(\"%d\", &n);
\n printf(\"Enter array elements: \\n\");
\n for (i = 0; i < n; i++)
\n   scanf(\"%d\", &array[i]);
\n printf(\"Enter a number to search\\n\");
\n scanf(\"%d\", &num);
\n for (i = 0; i < n; i++)
\n {
\n   if (array[i] == num)    /* When required element is found */
\n   {
\n     printf(\"The element: %d is present at location %d.\\n\", num, i+1);
\n     
\n     if(i == n-1)  //if end of array then exit search
\n     break;
\n   }
\n }
\n if (i == n)
\n   printf(\"The element %d is not present in the array.\\n\", num);
\n return 0;
\n}

Output:

Case 1: Element present in array

Enter number of elements in array\n10 \nEnter array elements: \n10 \n20 \n30 \n40 \n50 \n60 \n20 \n10 \n30 \n10 \nEnter a number to search \n10 \nThe element: 10 is present at location 1. \nThe element: 10 is present at location 8. \n

The element: 10 is present at location 10.

Case 2: Element not present in array

Enter number of elements in array\n4 \nEnter array elements: \n10 \n20 \n30 \n50 \nEnter a number to search \n40 \n

The element 40 is not present in the array.

Merging of two arrays:

Two arrays are taken as input from the user in order to merge them into a resultant array 'res'.
The arrays can be sorted or unsorted.
You can either after taking the input from the user, sort the array else after merging sort the array.
In our case, we first merge the array and then sort them.
For sorting, we use the basic bubble sort technique to sort the array in ascending order as previously seen in sorting an array program.
Since in our case, we sort the array post merging, initially you can simply save elements of arr1 and arr2 into result in the entered order itself.
However, we have written the code for merge considering that if the array input by user is already sorted then the merge function alone would suffice the need.
The function, compares the elements of the two arrays and inserts the elements in the ascending order into res array.
Since, we do not know if user will always enter a sorted array, we sort the resultant array res post merging as well.

Code:

#include<stdio.h>\nvoid merge(int arr1[20], int arr2[20], int n1, int n2) //merging arrays
\n{
\n   int i, j, k;
\n   int res[40];
\n   
\n    i = 0;
\n    j = 0;
\n    k = 0;
\n// Merging starts
\nwhile (i < n1 && j < n2)
\n{
\n   if (arr1[i] <= arr2[j])
\n       {
\n           res[k] = arr1[i];
\n           i++;
\n           k++;
\n       }
\n   else
\n       {
\n           res[k] = arr2[j];
\n             k++;
\n             j++;
\n       }
\n}
\n/* Some elements in array 'arr1' are still remaining where as array 'arr2' is exhausted */
\n while (i < n1)
\n {
\n       res[k] = arr1[i];
\n       i++;
\n       k++;
\n}
\n/* Some elements in array 'arr2' are still remaining where as array 'arr1' is exhausted */
\n while (j < n2)
\n {
\n       res[k] = arr2[j];
\n       k++;
\n       j++;
\n}
\nsort(res, (n1+n2));
\n//Displaying elements of array 'res'
\n    printf(\"\\nMerged array is :\");
\n       for (i = 0; i < n1 + n2; i++)
\n           printf(\"\\n%d\", res[i]);
\n}
\nvoid sort(int arr[20], int n)   //to sort the resultant array
\n{
\n   int i, j, swap;
\n   
\n   for (i = 0 ; i < n - 1; i++)
\n   {
\n   for (j= 0 ; j < n - i - 1; j++)
\n   {
\n     if (arr[j] > arr[j+1]) /* For decreasing order use < */
\n     {
\n       swap = arr[j];
\n       arr[j] = arr[j+1];
\n       arr[j+1] = swap;
\n     }
\n   }
\n }
\n}
\nint main()
\n{
\nint arr1[20], arr2[20];
\nint i, n1, n2;
\nprintf(\"Enter no of elements in 1st array :\\n\");
\nscanf(\"%d\", &n1);
\nprintf(\"Enter elements of 1st array : \\n\");
\nfor (i = 0; i < n1; i++)
\n{
\nscanf(\"%d\", &arr1[i]);
\n}
\n   printf(\"\\nEnter no of elements in 2nd array :\\n\");
\n    scanf(\"%d\", &n2);
\n   printf(\"Enter elements of 2nd array : \\n\");
\n        for (i = 0; i < n2; i++)
\n            {
\n               scanf(\"%d\", &arr2[i]);
\n            }
\nmerge(arr1, arr2, n1, n2);
\nreturn 0;
\n}

Output:

Enter no of elements in 1st array :\n4 \nEnter elements of 1st array : \n96 \n54 \n32 \n174 \nEnter no of elements in 2nd array : \n5 \nEnter elements of 2nd array : \n20 \n35 \n201 \n11 \n4 \nMerged array is : \n4 \n11 \n20 \n32 \n35 \n54 \n96 \n174 \n

201

\n","title":"Array operations in C – Part 2","authorDetails":{"name":"Pooja Rao","slug":"pooja-rao"},"seo":{"title":"Array operations in C – Part 2 C"},"description":"learn about various operations performed on array in c - Traversal, Copying, Reversing, Sorting, Insertion, Deletion, Searching, Merging of array.","slug":"blog/operation-on-arrays-in-c-2/","articleId":"636a834b7bb1ce5072622c98","bookmarkStatus":{"isBookmarked":false,"bookmarkId":null}}