Una array es una colección de tipos similares de elementos. Por ejemplo, una array de enteros contiene los elementos de los tipos int, mientras que una array de caracteres contiene los elementos de los tipos char. A continuación se muestra la representación de la array:
Sin embargo, la array tiene su propio conjunto de ventajas y desventajas.
Ventajas de las arrays
A continuación se presentan algunas ventajas de la array:
- En una array, acceder a un elemento es muy fácil usando el número de índice.
- El proceso de búsqueda se puede aplicar a una array fácilmente.
- 2D Array se utiliza para representar arrays.
- Por alguna razón, un usuario desea almacenar múltiples valores de tipo similar, entonces el Array se puede usar y utilizar de manera eficiente.
Desventajas de las arrays
Ahora veamos algunas desventajas de la array y cómo superarlas:
El tamaño de la array es fijo : la array es estática, lo que significa que su tamaño siempre es fijo. La memoria que se le asigna no se puede aumentar ni disminuir. A continuación se muestra el programa para el mismo:
C
// C program to illustrate that the
// array size is fixed
#include <stdio.h>
// Driver Code
int main()
{
int arr[10];
// Assign values to array
arr[0] = 5;
arr[5] = 6;
arr[7] = -9;
// Print array element at index 0
printf("Element at index 0"
" is %d\n",
arr[0]);
// Print array element at index 11
printf("Element at index 11"
" is %d",
arr[11]);
return 0;
}
Element at index 0 is 5 Element at index 11 is -1176897384
Explicación : en el programa anterior, se declara la array de tamaño 10 y el valor se asigna a un índice particular. Pero cuando se imprime el valor en el índice 11, se imprime el valor de basura porque se accedió a la array desde el índice enlazado . En algún compilador, da error como «Índice de array fuera de límite». .
Cómo superarlo : para superar ese problema, use la asignación dinámica de memoria como malloc() , calloc() . También nos ayuda a desasignar la memoria usando el método free() que ayuda a reducir el desperdicio de memoria al liberarla. A continuación se muestra el programa para el mismo:
C
// C program to illustrate the use of
// array using Dynamic Memory Allocation
#include <stdio.h>
#include <stdlib.h>
// Driver Code
int main()
{
// Pointer will hold the base address
int* ptr;
int n = 10;
// Dynamically allocates memory
// using malloc() function
ptr = (int*)malloc(n * sizeof(int));
// Assign values to the array
for (int i = 0; i < n; i++) {
ptr[i] = i + 1;
}
// Print the array
printf("The elements are: ");
for (int i = 0; i < n; i++) {
printf("%d ", ptr[i]);
}
// Free the dynamically
// allocated memory
free(ptr);
return 0;
}
The elements are: 1 2 3 4 5 6 7 8 9 10
La array es homogénea : la array es homogénea, es decir, solo se puede almacenar un tipo de valor en la array. Por ejemplo, si una array es de tipo “ int ”, solo puede almacenar elementos enteros y no puede permitir elementos de otros tipos como double, float, char, etc. A continuación se muestra el programa para el mismo:
C
// C++ program to illustrate that
// the array is homogeneous
#include <stdio.h>
// Driver Code
int main()
{
// Below declaration will give
// Compilation Error
int a[5] = { 0, 1, 2, "string", 9, 4.85 };
return 0;
}
100 547.000000 Ram
Producción:
Explicación : el código anterior da un « Error de compilación » ya que se asigna un valor a una array de tipo entero a una string y tipo flotante .
Cómo superar : Para superar ese problema, la idea es estructurar , donde puede almacenar valor no homogéneo (heterogéneo). A continuación se muestra el programa para el mismo:
C
// C program to illustrate the use of
// structure to store heterogeneous
// variables
#include <stdio.h>
// Structure students
struct student {
int student_id;
float marks;
char name[30];
};
// Driver Code
int main()
{
// Structure variable s1
struct student s1 = { 100, 547, "Ram" };
// Accessing structure members
// using structure pointer
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;
}
100 547.000000 Ram
La array es bloques de memoria contiguos : la array almacena datos en una ubicación de memoria contigua (uno por uno). A continuación se muestra la representación del mismo:
Cómo superar: Para superar el acceso secuencial a la array, la idea es utilizar la lista Enlazada . En una lista enlazada , los elementos no se almacenan en ubicaciones de memoria contiguas. A continuación se muestra la representación del mismo:
La inserción y la eliminación no son fáciles en Array : la operación de inserción y eliminación en una array es problemática ya que para insertar o eliminar en cualquier parte de la array, es necesario atravesar la array y luego cambiar los elementos restantes según la operación. Este costo de operación es más.
Ejemplo: para insertar 22 en la tercera posición de la array, a continuación se muestran los pasos:
A continuación se muestra el programa para ilustrar lo mismo:
C
// C Program to insert an element at
// a specific position in an array
#include <stdio.h>
// Driver Code
int main()
{
int arr[100] = { 0 };
int i, x, pos, n = 10;
// Initial array of size 10
for (i = 0; i < 10; i++) {
arr[i] = i + 1;
}
// Print the original array
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// Element to be inserted
x = 50;
// Position at which element
// is to be inserted
pos = 5;
printf("Array after inserting %d"
" at position %d\n",
x, pos);
// Increase the size by 1
n++;
// Shift elements forward
for (i = n - 1; i >= pos; i--) {
arr[i] = arr[i - 1];
}
// Insert x at pos
arr[pos - 1] = x;
// Print the updated array
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
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
Cómo superar: Para superar el problema anterior utilizando una lista enlazada . A continuación se muestra la representación del mismo:
A continuación se muestra el programa para implementar el mismo:
C
// C program to insert an element at
// a position using linked list
#include <stdio.h>
#include <stdlib.h>
// Structure for the linked list
struct node {
int data;
struct node* next;
};
// head Node
struct node* head;
// Function to insert any element
// at the end of the linked list
int insert_last(int k)
{
struct node *ptr, *s;
ptr = (struct node*)
malloc(sizeof(struct node));
ptr->data = k;
ptr->next = NULL;
// If head is NULL
if (head == NULL) {
head = ptr;
}
// Else
else {
s = head;
// Traverse the LL to last
while (s->next != NULL) {
s = s->next;
}
s->next = ptr;
}
}
// Function to display linked list
void display()
{
struct node* s;
// Store the head
s = head;
// Traverse till s is NULL
while (s != NULL) {
// Print the data
printf("%d ", s->data);
s = s->next;
}
printf("\n");
}
// Function to insert any element at
// the given position of linked list
int insert_position(int a, int b)
{
int f = 0, i;
struct node *ptr, *s;
// Allocate new Node
ptr = (struct node*)
malloc(sizeof(struct node));
ptr->data = a;
// If first position
if (b == 1) {
ptr->next = head;
head = ptr;
}
// Otherwise
else {
s = head;
// Move to (b - 1) position
for (i = 0; i < b - 2; i++) {
s = s->next;
}
// Assign node
ptr->next = s->next;
s->next = ptr;
}
return 0;
}
// Driver Code
int main()
{
// Given Linked List
insert_last(3);
insert_last(1);
insert_last(5);
insert_last(7);
printf("Current Linked List is: ");
// Display the LL
display();
// Insert 6 at position 4
insert_position(6, 4);
printf("\n Linked List after insert"
" 6 in 4th position: ");
// Display the LL
display();
return 0;
}
Current Linked List is: 3 1 5 7 Linked List after insert 6 in 4th position: 3 1 5 6 7
Publicación traducida automáticamente
Artículo escrito por eshitadutta y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA