Advantages and Disadvantages of Array in C
An array is a data structure that stores a collection of elements, all of the same data type, in a contiguous block of memory. Each element in the array is identified by an index, which is a numerical value that represents the position of the element in the array. The first element in the array has an index of 0, the second element has an index of 1, and so on.
Arrays can be used to store a variety of data types, including integers, floats, characters, and even user-defined types. They are commonly used to store collections of similar data, such as a list of numbers, a list of strings, or a list of objects.
Though, the array got its own set of advantages and disadvantages.
Advantages of Arrays
Below are some advantages of the array:
- In an array, accessing an element is very easy by using the index number.
- The search process can be applied to an array easily.
- 2D Array is used to represent matrices.
- For any reason a user wishes to store multiple values of similar type then the Array can be used and utilized efficiently.
- Arrays have low overhead.
- C provides a set of built-in functions for manipulating arrays, such as sorting and searching.
- C supports arrays of multiple dimensions, which can be useful for representing complex data structures like matrices.
- Arrays can be easily converted to pointers, which allows for passing arrays to functions as arguments or returning arrays from functions.
Disadvantages of Arrays
Now let’s see some disadvantages of the array and how to overcome it:
Array size is fixed: The array is static, which means its size is always fixed. The memory which is allocated to it cannot be increased or decreased. Below is the program for the same:
C
#include <stdio.h>
int main()
{
int arr[10];
arr[0] = 5;
arr[5] = 6;
arr[7] = -9;
printf ( "Element at index 0"
" is %d\n" ,
arr[0]);
printf ( "Element at index 11"
" is %d" ,
arr[11]);
return 0;
}
|
Output
Element at index 0 is 5
Element at index 11 is -1176897384
Explanation: In the above program the array of size 10 is declared and the value is assigned at a particular index. But when the value at index 11 is printed then it prints the garbage value because the array was accessed out of the bound index. In some compiler, it gives error as “Array Index Out Of Bound.”.
How to overcome: To overcome that problem use Dynamic Memory Allocation like malloc(), calloc(). It also helps us to deallocates the memory using the free() method which helps to reduce wastage of memory by releasing it. Below is the program for the same:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int * ptr;
int n = 10;
ptr = ( int *) malloc (n * sizeof ( int ));
for ( int i = 0; i < n; i++) {
ptr[i] = i + 1;
}
printf ( "The elements are: " );
for ( int i = 0; i < n; i++) {
printf ( "%d " , ptr[i]);
}
free (ptr);
return 0;
}
|
Output
The elements are: 1 2 3 4 5 6 7 8 9 10
Array is homogeneous:The array is homogeneous, i.e., only one type of value can be store in the array. For example, if an array type “int“, can only store integer elements and cannot allow the elements of other types such as double, float, char so on. Below is the program for the same:
C
#include <stdio.h>
int main()
{
int a[5] = { 0, 1, 2, "string" , 9, 4.85 };
return 0;
}
|
Output
100
547.000000
Ram
Output:
Explanation: The above code gives “Compilation Error” as an integer type array is assigned value to a string and float type.
How to overcome: To overcome that problem, the idea is to structure, where it can store non-homogeneous (heterogeneous) value. Below is the program for the same:
C
#include <stdio.h>
struct student {
int student_id;
float marks;
char name[30];
};
int main()
{
struct student s1 = { 100, 547, "Ram" };
printf ( "%d\n" , s1.student_id);
printf ( "%f\n" , s1.marks);
for ( int i = 0;
s1.name[i] != '\0' ; i++) {
printf ( "%c" , s1.name[i]);
}
return 0;
}
|
Output
100
547.000000
Ram
Array is Contiguous blocks of memory: The array stores data in contiguous(one by one) memory location. Below is the representation of the same:
How to overcome: To overcome the sequential access to the array, the idea is to use the Linked list. In a Linked list, the elements are not stored in contiguous memory locations. Below is the representation of the same:
Insertion and deletion are not easy in Array: The operation insertion and deletion over an array are problematic as to insert or delete anywhere in the array, it is necessary to traverse the array and then shift the remaining elements as per the operation. This operation cost is more.
Example: For inserting 22 in 3rd position of the array then below are the steps:
Below is the program to illustrate the same:
C
#include <stdio.h>
int main()
{
int arr[100] = { 0 };
int i, x, pos, n = 10;
for (i = 0; i < 10; i++) {
arr[i] = i + 1;
}
for (i = 0; i < n; i++) {
printf ( "%d " , arr[i]);
}
printf ( "\n" );
x = 50;
pos = 5;
printf ( "Array after inserting %d"
" at position %d\n" ,
x, pos);
n++;
for (i = n - 1; i >= pos; i--) {
arr[i] = arr[i - 1];
}
arr[pos - 1] = x;
for (i = 0; i < n; i++) {
printf ( "%d " , arr[i]);
}
return 0;
}
|
Output
1 2 3 4 5 6 7 8 9 10
Array after inserting 50 at position 5
1 2 3 4 50 5 6 7 8 9 10
How to overcome: To overcome the above problem using a Linked List. Below is the representation of the same:
Below is the program to implement the same:
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int data;
struct node* next;
};
struct node* head;
int insert_last( int k)
{
struct node *ptr, *s;
ptr = ( struct node*)
malloc ( sizeof ( struct node));
ptr->data = k;
ptr->next = NULL;
if (head == NULL) {
head = ptr;
}
else {
s = head;
while (s->next != NULL) {
s = s->next;
}
s->next = ptr;
}
}
void display()
{
struct node* s;
s = head;
while (s != NULL) {
printf ( "%d " , s->data);
s = s->next;
}
printf ( "\n" );
}
int insert_position( int a, int b)
{
int f = 0, i;
struct node *ptr, *s;
ptr = ( struct node*)
malloc ( sizeof ( struct node));
ptr->data = a;
if (b == 1) {
ptr->next = head;
head = ptr;
}
else {
s = head;
for (i = 0; i < b - 2; i++) {
s = s->next;
}
ptr->next = s->next;
s->next = ptr;
}
return 0;
}
int main()
{
insert_last(3);
insert_last(1);
insert_last(5);
insert_last(7);
printf ( "Current Linked List is: " );
display();
insert_position(6, 4);
printf ( "\n Linked List after insert"
" 6 in 4th position: " );
display();
return 0;
}
|
Output
Current Linked List is: 3 1 5 7
Linked List after insert 6 in 4th position: 3 1 5 6 7
Last Updated :
02 Nov, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...