Voorwaarde: Arrays in C

Een multidimensionale array kan worden omschreven als een array van arrays die homogene gegevens in tabelvorm opslaat. Gegevens in multidimensionale arrays worden doorgaans in rij-hoofdvolgorde in het geheugen opgeslagen.

De algemene vorm van het declareren van N-dimensionale arrays wordt hieronder weergegeven.

Syntaxis:

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

• data type : Type gegevens dat in de array moet worden opgeslagen.
• array_naam : Naam van de array.
• maat1, maat2,…, maatN : Grootte van elke dimensie.

Voorbeelden :

knn-algoritme

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

Grootte van multidimensionale arrays:

Het totale aantal elementen dat in een multidimensionale array kan worden opgeslagen, kan worden berekend door de grootte van alle dimensies te vermenigvuldigen.
Bijvoorbeeld:

• De array int x[10][20] kan totaal (10*20) = 200 elementen opslaan.
• Op dezelfde manier array int x[5][10][20] kan totaal (5*10*20) = 1000 elementen opslaan.

Om de grootte van de array in bytes te krijgen, vermenigvuldigen we de grootte van een enkel element met het totale aantal elementen in de array.
Bijvoorbeeld:

• Grootte van de array int x[10][20] = 10 * 20 * 4 = 800 bytes. (waarbij int = 4 bytes)
• Op dezelfde manier is de grootte van int x[5][10][20] = 5 * 10 * 20 * 4 = 4000 bytes. (waarbij int = 4 bytes)

De meest gebruikte vormen van de multidimensionale array zijn:

1. Tweedimensionale array
2. Driedimensionale array

Tweedimensionale array in C

A tweedimensionale array of 2D-array in C is de eenvoudigste vorm van de multidimensionale array. We kunnen een tweedimensionale array visualiseren als een array van eendimensionale arrays die over elkaar zijn gerangschikt en een tabel vormen met 'x'-rijen en 'y'-kolommen waarbij het rijnummer varieert van 0 tot (x-1) en het kolomnummer varieert van 0 tot (y-1).

Grafische weergave van een tweedimensionale array van maat 3 x 3

Verklaring van tweedimensionale array in C

De basisvorm voor het declareren van een 2D-array met X rijen en En kolommen in C worden hieronder weergegeven.

Syntaxis:

data_type array_name[x][y];>

waar,

• data type: Type gegevens dat in elk element moet worden opgeslagen.
• arraynaam: naam van de array
• X: Aantal rijen.
• En: Aantal columns.

We kunnen een tweedimensionale integer-array declareren, bijvoorbeeld ‘x’ met 10 rijen en 20 kolommen, als:

Voorbeeld:

int x[10][20];>

Opmerking: bij dit type declaratie wordt aan de array geheugen in de stapel toegewezen en moet de grootte van de array bekend zijn tijdens het compileren, d.w.z. de grootte van de array staat vast. We kunnen ook dynamisch een array in C maken met behulp van de genoemde methoden hier.

Initialisatie van tweedimensionale arrays in C

De verschillende manieren waarop een 2D-array kan worden geïnitialiseerd zijn als volgt:

1. Initialisatielijst gebruiken
2. Het gebruik van lussen

1. Initialisatie van 2D-array met behulp van Initializer List

We kunnen een 2D-array in C initialiseren door een initialisatielijst te gebruiken, zoals weergegeven in het onderstaande voorbeeld.

Eerste methode:

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

De bovenstaande array heeft 3 rijen en 4 kolommen. De elementen in de accolades van links naar rechts worden ook van links naar rechts in de tabel opgeslagen. De elementen worden op volgorde in de array gevuld: de eerste vier elementen van links worden in de eerste rij gevuld, de volgende vier elementen in de tweede rij, enzovoort.

Tweede methode (beter) :

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

Dit type initialisatie maakt gebruik van geneste accolades. Elke set binnenste accolades vertegenwoordigt één rij. In het bovenstaande voorbeeld zijn er in totaal drie rijen, dus er zijn drie sets binnenbeugels. Het voordeel van deze methode is dat het gemakkelijker te begrijpen is.

Opmerking: Het aantal elementen in de initialisatielijst moet altijd kleiner zijn dan of gelijk zijn aan het totale aantal elementen in de array.

We kunnen de array ook declareren zonder de grootte van de rij te definiëren als we lijstinitialisatie gebruiken. De compiler leidt in dit geval automatisch de grootte van de array af:

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

Het is nog steeds verplicht om het aantal kolommen te definiëren.

2. Initialisatie van 2D-array met behulp van Loops

We kunnen elke C-lus gebruiken om elk lid van een 2D-array één voor één te initialiseren, zoals weergegeven in het onderstaande voorbeeld.

Voorbeeld:

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

Deze methode is handig als de waarden van elk element een opeenvolgende relatie hebben.

Toegang tot elementen van tweedimensionale arrays in C

Elementen in 2D-arrays zijn toegankelijk via rij-indexen en kolomindexen. Naar elk element in een 2D-array kan worden verwezen door:

Syntaxis:

array_name[i][j]>

waar,

• i: De rij-index.
• J: De kolomindex.

Voorbeeld:

int x[2][1];>

Het bovenstaande voorbeeld vertegenwoordigt het element dat aanwezig is in de derde rij en tweede kolom.

Opmerking : In arrays, als de grootte van een array N is. De index zal van 0 tot N-1 zijn. Daarom is voor rijindex 2 het rijnummer 2+1 = 3. Om alle elementen van een tweedimensionale array uit te voeren, kunnen we geneste for-lussen gebruiken. We hebben twee ‘ voor ‘lussen. Eén om de rijen te doorkruisen en een andere om kolommen te doorkruisen.

Om de hele array af te drukken, benaderen we elk element één voor één met behulp van lussen. De volgorde van doorlopen kan afhankelijk van de vereiste een rij-majeurvolgorde of een kolom-majorvolgorde zijn. Het onderstaande voorbeeld demonstreert de rij-major traversal van een 2D-array.

Voorbeeld:

C

abstracte methoden

>

>

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>

Tijdcomplexiteit: O(N*M) , waarbij N(hier 3) en M(hier 2) respectievelijk het aantal rijen en kolommen zijn.

Ruimtecomplexiteit:O(1)

Hoe worden 2D-arrays in het geheugen opgeslagen?

De elementen van de 2D-array moeten aaneengesloten in het geheugen worden opgeslagen. Omdat de computers lineaire geheugenadressen hebben, moeten de 2D-arrays gelineariseerd worden om hun opslag mogelijk te maken. Er zijn twee manieren om linearisatie van array-elementen te bereiken:

• Rij-majoor- Bij de linearisatietechniek wordt eerst de eerste rij van de array opgeslagen, vervolgens de tweede rij van de array, vervolgens de derde rij, enzovoort. (dat wil zeggen dat elementen rijsgewijs worden opgeslagen. Rijen worden weergegeven op basis van kolommen)
• Column-majoor – Deze linearisatietechniek slaat eerst de eerste kolom op, dan de tweede kolom, dan de derde kolom, enzovoort (elementen worden kolomsgewijs opgeslagen. Kolommen worden weergegeven op basis van rijen)

De computer houdt niet de adressen van alle elementen van de array bij, maar wel het basisadres (startadres van het allereerste element) en berekent indien nodig de adressen van de elementen.

Raadpleeg voor meer informatie het artikel – Berekening van het adres van een element van 1D, 2D en 3D

Driedimensionale array in C

A Driedimensionale array of 3D array in C is een verzameling tweedimensionale arrays. Het kan worden gevisualiseerd als meerdere 2D-arrays die op elkaar zijn gestapeld.

Grafische weergave van een driedimensionale reeks met afmetingen 3 x 3 x 3

Verklaring van driedimensionale array in C

We kunnen een 3D-array declareren met X 2D-arrays met elk En rijen en Met kolommen met behulp van de onderstaande syntaxis.

Syntaxis:

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

• data type: Type gegevens dat in elk element moet worden opgeslagen.
• arraynaam: naam van de array
• X: Aantal 2D-arrays.
• En: Aantal rijen in elke 2D-array.
• Met: Aantal kolommen in elke 2D-array.

Voorbeeld:

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

Initialisatie van driedimensionale array in C

Initialisatie in een 3D-array is hetzelfde als die van 2D-arrays. Het verschil is dat naarmate het aantal dimensies toeneemt, het aantal geneste accolades ook zal toenemen.

Een 3D-array in C kan worden geïnitialiseerd met behulp van:

1. Initialisatielijst
2. Lussen

Initialisatie van 3D-array met behulp van Initializer List

Methode 1 :

java wiskunde.random

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};>

Methode 2 (Beter) :

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} }  };>

Nogmaals, net als bij de 2D-arrays kunnen we ook de 3D-arrays declareren zonder de grootte van de eerste dimensies op te geven als we de initialisatielijst gebruiken voor initialisatie. De compiler leidt automatisch de grootte van de eerste dimensie af. Maar we moeten nog de rest van de afmetingen specificeren.

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

Initialisatie van 3D-array met behulp van loops

Het is ook vergelijkbaar met die van een 2D-array met nog een geneste lus voor toegang tot nog een dimensie.

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); } } }>

Toegang tot elementen in Three-Dimensional Array in C

De toegang tot elementen in 3D-arrays is ook vergelijkbaar met die van 2D-arrays. Het verschil is dat we drie lussen moeten gebruiken in plaats van twee lussen voor één extra dimensie in 3D-arrays.

Syntaxis:

array_name[x][y][z]>

waar,

• X: Index van 2D-array.
• En: Index van die 2D-arrayrij.
• Met: Index van die 2D-arraykolom.

C

>

>

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>

Op vergelijkbare manieren kunnen we arrays maken met een willekeurig aantal dimensies. De complexiteit neemt echter ook toe naarmate het aantal dimensies toeneemt. De meest gebruikte multidimensionale array is de Two-Dimensional Array.

Arrays zijn ook nauw verwant aan pointers in C-taal. Raadpleeg voor meer informatie over de relatie tussen arrays en pointers in C dit artikel.