Introduzione alle funzioni di array in C
Le funzioni di matrice in C sono un tipo di struttura di dati che contiene più elementi dello stesso tipo di dati. La dimensione di un array è fissa e gli elementi sono raccolti in modo sequenziale. Possono esserci diverse dimensioni di array e la programmazione C non limita il numero di dimensioni in un array.
Diverse funzioni di matrice in C
Esistono diverse funzioni che possono essere eseguite su array.
1) Attraversamento
Attraversare un array significa attraversare ogni elemento di un array esattamente una volta. Partiamo dal primo elemento e andiamo all'ultimo elemento. Un esempio di tale programma che esegue operazioni di spostamento su un array lineare è riportato di seguito in linguaggio C.
Codice
#include
void main()
(
int array() = (1, 2, 3, 4, 5);
int i, n = 5;
printf(" The array elements are: \n " );
for( i=0;i < n; i++)
(
printf(" array(%d) = %d \n ", i, array(i) );
)
)
Produzione:
2) Ricerca
L'operazione di ricerca viene utilizzata per trovare un particolare elemento o elemento di dati in un array. Siamo in grado di eseguire ricerche in una matrice non ordinata con l'aiuto della traversata della matrice. L'incrocio lineare dal primo all'ultimo elemento può essere usato per cercare se un dato numero è presente in un array e può anche essere usato per trovare la sua posizione se presente.
Questo viene fatto confrontando ciascun elemento con l'elemento dato (che deve essere cercato). Una volta trovato l'elemento, l'operazione di ricerca viene interrotta. Ecco un esempio per mostrare l'operazione di ricerca eseguita su un array in C
Codice
#include
int findElement(int arr(), int n, int key)
(
int i;
for (i = 0; i < n; i++)
if (arr(i) == key
return i;
return -1;
)
int main()
(
int arr() = (1, 4, 0, 6, 3);
int n = sizeof(arr) / sizeof(arr(0));
int key = 4;
int position = findElement(arr, n, key);
if (position == - 1)
printf("Element not found");
else
printf("Element Found at Position: %d", position + 1 );
return 0;
)
Produzione:
3) Inserimento
L'operazione di inserimento viene utilizzata per aggiungere un nuovo elemento nell'array. Quando specifichiamo l'elemento particolare e la posizione in cui deve essere aggiunto nell'array, eseguiamo l'operazione di inserimento. Tuttavia, la dimensione dell'array non viene disturbata durante l'esecuzione di questa operazione. Un elemento verrà inserito in un array solo se ha spazio sufficiente per aggiungerlo. Se la dimensione di un array è già piena, non è possibile aggiungere un nuovo elemento. Un esempio per mostrare l'operazione di inserimento in una matrice non ordinata in C.
Codice
#include
int insertSorted(int arr(), int n, int key, int capacity)
(
if (n >= capacity)
return n;
arr(n) = key;
return (n + 1);
)
int main()
(
int arr(20) = (8, 5, 6, 9, 0, 7) ;
int capacity = sizeof(arr) / sizeof(arr(0));
int n = 6;
int i, key = 2;
printf("\n Before Insertion: ");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
n = insertSorted(arr, n, key, capacity);
printf("\n After Insertion: ");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
return 0;
)
Produzione:
4) Cancellazione
Nell'operazione di eliminazione, l'elemento già esistente nell'array viene cercato (usando la ricerca lineare) ed eliminato, seguito dallo spostamento degli elementi. L'utente inserisce la posizione dell'elemento che deve essere eliminato dall'array. L'operazione di eliminazione, proprio come l'operazione di inserimento, non influisce sulla dimensione dell'array. Inoltre, la posizione dell'elemento da eliminare dovrebbe rientrare nelle dimensioni dell'array, poiché non è possibile eliminare un elemento oltre le dimensioni dell'array. Programma C per mostrare l'operazione di eliminazione in un array non ordinato.
Codice
#include
int findElement(int arr(), int n, int key);
int deleteElement(int arr(), int n, int key)
(
int pos = findElement(arr, n, key);
if (pos == - 1)
(
printf("Element not found");
return n;)
int i;
for (i = pos; i < n - 1; i++)
arr(i) = arr(i + 1);
return n - 1;
)
int findElement(int arr(), int n, int key)
(
int i;
for (i = 0; i < n; i++)
if (arr(i) == key)
return i;return - 1;
)
int main()
(
int i;
int arr() = (1, 5, 3, 4, 2);
int n = sizeof(arr) / sizeof(arr(0));
int key = 3;
printf("Array before deletion\n");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
n = deleteElement(arr, n, key);
printf("\nArray after deletion\n");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
return 0;
)
Produzione:
5) Ordinamento
Questa operazione viene eseguita per ordinare un array in un ordine fisso, ovvero crescente o decrescente. Ecco un esempio di operazione di ordinamento su un array in C
Codice
#include
void main()
(
int i, j, a, n, number(30);
printf("Enter the value of N \n");
scanf("%d", &n);
printf("Enter the numbers \n");
for (i = 0; i < n; ++i)
scanf("%d", &number(i));
for (i = 0; i < n; ++i)
(
for (j = i + 1; j < n; ++j)
(
if (number(i) > number(j))
(
a = number(i);
number(i) = number(j);
number(j) = a;
)
)
)
printf("The numbers arranged in ascending order are given below \n");
for (i = 0; i < n; ++i)
printf("%d\n", number(i));
)
Produzione:
Diversi modi di ordinare un array
Di seguito sono riportati i diversi metodi di ordinamento per l'array:
1) Bubble Sort
L'ordinamento a bolle confronta tutti gli elementi uno per uno e li ordina in base ai loro valori. Comincia confrontando il primo elemento con il secondo, se il primo elemento è maggiore del secondo elemento, cambierà entrambi gli elementi, continuerà a confrontare il secondo e il terzo elemento e così via.
2) Selezione ordinamento
L'idea alla base dell'ordinamento per selezione è trovare il minimo elemento nell'array non ordinato, sostituendolo con il primo elemento. Quindi continuare lo stesso processo con il resto dell'array non ordinato, ovvero dalla seconda posizione, quindi dalla terza e così via.
3) Unisci ordinamento
Questo metodo di ordinamento si basa sulla tecnica di divisione e conquista. Divide l'array in due sottoarray uguali e continua fino a quando ogni subarray contiene un singolo elemento, quindi li unisce in un modo ordinato dando origine ad un array ordinato.
4) Inserimento ordinamento
Nell'ordinamento per inserzione, iniziamo con il secondo elemento. Gli elementi dell'array vengono confrontati tra loro in modo sequenziale. L'elemento corrente (il valore da ordinare) viene confrontato con tutti gli elementi nel sottoarray ordinato. Tutti gli elementi nel sottoarray ordinato che sono maggiori dell'elemento corrente vengono spostati e viene inserito il valore corrente. Questo processo viene ripetuto fino a quando l'intero array non viene ordinato.
5) Ordinamento rapido
Quicksort, proprio come il merge sort, si basa anche sull'algoritmo divide and conquer. In questo metodo, un elemento viene scelto come perno (generalmente il primo elemento). Quindi, le partizioni di un array vengono create attorno al perno selezionato, vale a dire che tutti gli elementi inferiori al perno formano un array secondario e tutti gli elementi maggiori del perno ne formano un altro. La procedura viene ripetuta anche con gli array secondari fino a quando l'intero array non viene ordinato.
6) Ordinamento dell'heap
L'algoritmo dell'heap sort si basa sul confronto. L'elemento massimo viene selezionato e posizionato nella posizione finale. Quindi il secondo elemento più grande viene trovato e posizionato nella seconda ultima posizione. Questo processo si ripete per tutti gli elementi.
Articoli consigliati
Questa è una guida alle funzioni di array in C. Qui discutiamo le diverse funzioni e modi di ordinare un array. Puoi anche consultare i nostri altri articoli correlati per saperne di più -
- Matrici in C ++
- Matrici in R
- Funzioni in R
- Vantaggi dell'array
- Tipi di funzioni di array in PHP ed esempi