Prerequisito: Array in C

Un array multidimensionale può essere definito come un array di array che memorizza dati omogenei in forma tabellare. I dati negli array multidimensionali vengono generalmente archiviati in memoria in ordine di riga principale.

IL forma generale di dichiarazione di array N-dimensionali è mostrato di seguito.

Sintassi:

data_type array_name[size1][size2]....[sizeN];>

• tipo di dati : tipo di dati da memorizzare nell'array.
• nome_array : nome dell'array.
• taglia1, taglia2,…, tagliaN : dimensione di ciascuna dimensione.

Esempi :

preordine di attraversamento di un albero

  Two dimensional array:   int two_d[10][20];   Three dimensional array:   int three_d[10][20][30];>

Dimensioni degli array multidimensionali:

Il numero totale di elementi che possono essere memorizzati in un array multidimensionale può essere calcolato moltiplicando la dimensione di tutte le dimensioni.
Per esempio:

• La matrice intero x[10][20] può memorizzare un totale (10*20) = 200 elementi.
• Allo stesso modo array interox[5][10][20] può memorizzare un totale (5*10*20) = 1000 elementi.

Per ottenere la dimensione dell'array in byte, moltiplichiamo la dimensione di un singolo elemento per il numero totale di elementi nell'array.
Per esempio:

• Dimensione dell'array intero x[10][20] = 10 * 20 * 4 = 800 byte. (dove int = 4 byte)
• Allo stesso modo, dimensione di interox[5][10][20] = 5 * 10 * 20 * 4 = 4000 byte. (dove int = 4 byte)

Le forme più comunemente utilizzate dell'array multidimensionale sono:

1. Matrice bidimensionale
2. Matrice tridimensionale

Array bidimensionale in C

UN matrice bidimensionale O matrice 2D in C è la forma più semplice dell'array multidimensionale. Possiamo visualizzare un array bidimensionale come un array di array unidimensionali disposti uno sopra l'altro formando una tabella con righe 'x' e colonne 'y' in cui il numero di riga varia da 0 a (x-1) e il numero di colonna varia da 0 a (y-1).

Rappresentazione grafica di un array bidimensionale di dimensione 3 x 3

Dichiarazione di array bidimensionale in C

La forma base per dichiarare un array 2D con X righe e E colonne in C è mostrato di seguito.

Sintassi:

data_type array_name[x][y];>

Dove,

• tipo di dati: Tipo di dati da memorizzare in ciascun elemento.
• nome_array: nome dell'array
• X: Numero di righe.
• E: Numero di colonne.

Possiamo dichiarare un array di numeri interi bidimensionali, ad esempio 'x', con 10 righe e 20 colonne come:

Esempio:

int x[10][20];>

Nota: in questo tipo di dichiarazione, all'array viene allocata memoria nello stack e la dimensione dell'array dovrebbe essere nota al momento della compilazione, ovvero la dimensione dell'array è fissa. Possiamo anche creare un array dinamicamente in C utilizzando i metodi menzionati Qui.

Inizializzazione di array bidimensionali in C

I vari modi in cui è possibile inizializzare un array 2D sono i seguenti:

1. Utilizzo dell'elenco degli inizializzatori
2. Utilizzo dei loop

1. Inizializzazione dell'array 2D utilizzando l'elenco degli inizializzatori

Possiamo inizializzare un array 2D in C utilizzando un elenco di inizializzatori come mostrato nell'esempio seguente.

Primo metodo:

int x[3][4] = {0, 1 ,2 ,3 ,4 , 5 , 6 , 7 , 8 , 9 , 10 , 11}>

La matrice sopra ha 3 righe e 4 colonne. Gli elementi tra parentesi graffe da sinistra a destra vengono memorizzati nella tabella anche da sinistra a destra. Gli elementi verranno riempiti nell'array in ordine: i primi 4 elementi da sinistra verranno riempiti nella prima riga, i successivi 4 elementi nella seconda riga e così via.

Secondo metodo (migliore) :

int x[3][4] = {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};>

Questo tipo di inizializzazione utilizza parentesi graffe annidate. Ogni serie di parentesi graffe interne rappresenta una riga. Nell'esempio sopra, c'è un totale di tre righe, quindi ci sono tre serie di parentesi graffe interne. Il vantaggio di questo metodo è che è più facile da capire.

Nota: il numero di elementi nell'elenco degli inizializzatori deve essere sempre inferiore o uguale al numero totale di elementi nell'array.

Possiamo anche dichiarare l'array senza definire la dimensione della riga se stiamo usando l'inizializzazione della lista. In questo caso il compilatore dedurrà automaticamente la dimensione dell'array:

data_type array_name[][y] = {...} ;>

È ancora obbligatorio definire il numero di colonne.

2. Inizializzazione dell'array 2D utilizzando Loops

Possiamo utilizzare qualsiasi ciclo C per inizializzare ciascun membro di un array 2D uno per uno, come mostrato nell'esempio seguente.

Esempio:

int x[3][4]; for(int i = 0; i <3; i++){ for(int j = 0; j < 4; j++){ x[i][j] = i + j; } }>

Questo metodo è utile quando i valori di ciascun elemento hanno una relazione sequenziale.

Accesso agli elementi di array bidimensionali in C

È possibile accedere agli elementi nelle matrici 2D utilizzando indici di riga e indici di colonna. È possibile fare riferimento a ciascun elemento in un array 2D con:

pitone __dict__

Sintassi:

array_name[i][j]>

Dove,

• io: L'indice delle righe.
• J: L'indice della colonna.

Esempio:

int x[2][1];>

L'esempio sopra rappresenta l'elemento presente nella terza riga e nella seconda colonna.

Nota : Negli array, se la dimensione di un array è N. Il suo indice sarà compreso tra 0 e N-1. Pertanto, per l'indice di riga 2 il numero di riga è 2+1 = 3. Per visualizzare tutti gli elementi di un array bidimensionale possiamo utilizzare cicli for nidificati. Ne avremo bisogno di due ‘ per ‘ loop. Uno per attraversare le righe e un altro per attraversare le colonne.

Per stampare l'intero array, accediamo a ciascun elemento uno per uno utilizzando i loop. L'ordine di attraversamento può essere l'ordine della riga principale o l'ordine della colonna principale a seconda dei requisiti. L'esempio seguente mostra l'attraversamento della riga principale di un array 2D.

Esempio:

C

>

>

Element at x[0][0]: 0 Element at x[0][1]: 1 Element at x[1][0]: 2 Element at x[1][1]: 3 Element at x[2][0]: 4 Element at x[2][1]: 5>

Complessità temporale: O(N*M) , dove N(qui 3) e M(qui 2) sono rispettivamente il numero di righe e di colonne.

Complessità spaziale:O(1)

Come vengono archiviati gli array 2D nella memoria?

Gli elementi dell'array 2D devono essere archiviati in modo contiguo in memoria. Poiché i computer hanno indirizzi di memoria lineari, gli array 2D devono essere linearizzati in modo da consentirne la memorizzazione. Esistono due modi per ottenere la linearizzazione degli elementi dell'array:

• Riga-maggiore- La tecnica di linearizzazione memorizza prima la prima riga dell'array, poi la seconda riga dell'array, poi la terza riga e così via. (ovvero gli elementi sono memorizzati per riga. Le righe sono elencate in base alle colonne)
• Colonna maggiore – Questa tecnica di linearizzazione memorizza prima la prima colonna, poi la seconda colonna, poi la terza colonna e così via (gli elementi vengono memorizzati per colonna. Le colonne sono elencate in base alle righe)

Il computer non tiene traccia degli indirizzi di tutti gli elementi dell'array ma tiene traccia dell'indirizzo base (indirizzo iniziale del primissimo elemento) e calcola gli indirizzi degli elementi quando richiesto.

Per saperne di più fare riferimento all’articolo – Calcolo dell'indirizzo dell'elemento di 1-D, 2-D e 3-D

Array tridimensionale in C

UN Matrice tridimensionale O 3D array in C è una raccolta di array bidimensionali. Può essere visualizzato come più array 2D impilati uno sopra l'altro.

Rappresentazione grafica di una matrice tridimensionale di dimensioni 3 x 3 x 3

Dichiarazione di matrice tridimensionale in C

Possiamo dichiarare un array 3D con X Array 2D ciascuno con E righe e Con colonne utilizzando la sintassi mostrata di seguito.

Sintassi:

data_type array_name[x][y][z];>

• tipo di dati: Tipo di dati da memorizzare in ciascun elemento.
• nome_array: nome dell'array
• X: Numero di array 2D.
• E: Numero di righe in ciascuna matrice 2D.
• Con: Numero di colonne in ciascuna matrice 2D.

Esempio:

int array[3][3][3];>

Inizializzazione dell'array tridimensionale in C

L'inizializzazione in un array 3D è uguale a quella degli array 2D. La differenza è che all'aumentare del numero di dimensioni aumenterà anche il numero di parentesi graffe nidificate.

Un array 3D in C può essere inizializzato utilizzando:

1. Elenco degli inizializzatori
2. Loop

Inizializzazione dell'array 3D utilizzando l'elenco degli inizializzatori

Metodo 1 :

int x[2][3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};>

Metodo 2(Migliore) :

int x[2][3][4] =   {   { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} },  { {12,13,14,15}, {16,17,18,19}, {20,21,22,23} }  };>

Ancora una volta, proprio come gli array 2D, possiamo anche dichiarare gli array 3D senza specificare la dimensione delle prime dimensioni se utilizziamo l'elenco di inizializzatori per l'inizializzazione. Il compilatore dedurrà automaticamente la dimensione della prima dimensione. Ma dobbiamo ancora specificare il resto delle dimensioni.

data_type array_name[][y][z] = {....};>

Inizializzazione dell'array 3D utilizzando i loop

È anche simile a quello dell'array 2D con un ulteriore ciclo annidato per accedere a un'altra dimensione.

int x[2][3][4]; for (int i=0; i<2; i++) { for (int j=0; j<3; j++) { for (int k=0; k<4; k++) { x[i][j][k] = (some_value); } } }>

Accesso agli elementi in Three-Dimensional Array in C

Anche l'accesso agli elementi negli array 3D è simile a quello degli array 2D. La differenza è che dobbiamo usare tre loop invece di due loop per una dimensione aggiuntiva negli array 3D.

Sintassi:

array_name[x][y][z]>

Dove,

• X: Indice dell'array 2D.
• E: Indice di quella riga dell'array 2D.
• Con: Indice di quella colonna dell'array 2D.

C

barra degli strumenti di accesso rapido alle parole

>

>

Element at x[0][0][0] = 0 Element at x[0][0][1] = 1 Element at x[0][1][0] = 2 Element at x[0][1][1] = 3 Element at x[0][2][0] = 4 Element at x[0][2][1] = 5 Element at x[1][0][0] = 6 Element at x[1][0][1] = 7 Element at x[1][1][0] = 8 Element at x[1][1][1] = 9 Element at x[1][2][0] = 10 Element at x[1][2][1] = 11>

In modi simili, possiamo creare array con qualsiasi numero di dimensioni. Tuttavia, la complessità aumenta anche con l’aumentare del numero di dimensioni. L'array multidimensionale più utilizzato è l'array bidimensionale.

Gli array sono anche strettamente correlati ai puntatori nel linguaggio C. Per saperne di più sulla relazione degli array con i puntatori in C, fare riferimento a Questo articolo.