Nödvändig förutsättning: Arrayer i C

En flerdimensionell array kan betecknas som en array av arrays som lagrar homogena data i tabellform. Data i flerdimensionella arrayer lagras i allmänhet i rad-huvudordning i minnet.

De allmän form för att deklarera N-dimensionella arrayer visas nedan.

Syntax:

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

• data typ : Typ av data som ska lagras i arrayen.
• array_name : Namnet på arrayen.
• storlek 1, storlek 2,..., storlek N : Storlek på varje dimension.

Exempel :

packa upp i linux

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

Storlek på flerdimensionella arrayer:

Det totala antalet element som kan lagras i en flerdimensionell array kan beräknas genom att multiplicera storleken på alla dimensioner.
Till exempel:

• Arrayen int x[10][20] kan lagra totalt (10*20) = 200 element.
• Likaså array int x[5][10][20] kan lagra totalt (5*10*20) = 1000 element.

För att få storleken på arrayen i byte multiplicerar vi storleken på ett enskilt element med det totala antalet element i arrayen.
Till exempel:

• Storlek på array int x[10][20] = 10 * 20 * 4 = 800 byte. (där int = 4 byte)
• Likaså storleken på int x[5][10][20] = 5 * 10 * 20 * 4 = 4000 byte. (där int = 4 byte)

De vanligaste formerna av den flerdimensionella arrayen är:

1. Tvådimensionell array
2. Tredimensionell array

Tvådimensionell array i C

A tvådimensionell array eller 2D-array i C är den enklaste formen av den flerdimensionella arrayen. Vi kan visualisera en tvådimensionell array som en array av endimensionella arrayer arrangerade över varandra och bildar en tabell med 'x'-rader och 'y'-kolumner där radnumret sträcker sig från 0 till (x-1) och kolumnnumret sträcker sig från 0 till (y-1).

Grafisk representation av tvådimensionell matris i storlek 3 x 3

Deklaration om tvådimensionell array i C

Den grundläggande formen för att deklarera en 2D-array med x rader och och kolumner i C visas nedan.

Syntax:

data_type array_name[x][y];>

var,

• data typ: Typ av data som ska lagras i varje element.
• array_name: arrayens namn
• x: Antal rader.
• och: Antal kolumner.

Vi kan deklarera en tvådimensionell heltalsmatris säg 'x' med 10 rader och 20 kolumner som:

Exempel:

int x[10][20];>

Notera: I denna typ av deklaration tilldelas arrayen minne i stacken och storleken på arrayen bör vara känd vid kompileringstillfället, dvs. storleken på arrayen är fast. Vi kan också skapa en array dynamiskt i C genom att använda de nämnda metoderna här.

Initialisering av tvådimensionella arrayer i C

De olika sätten på vilka en 2D-array kan initieras är följande:

1. Använder initieringslista
2. Använda loopar

1. Initialisering av 2D-array med hjälp av Initializer List

Vi kan initiera en 2D-array i C genom att använda en initieringslista som visas i exemplet nedan.

Första metoden:

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

Ovanstående array har 3 rader och 4 kolumner. Elementen i hängslen från vänster till höger lagras i tabellen även från vänster till höger. Elementen kommer att fyllas i arrayen i ordning: de första 4 elementen från vänster kommer att fyllas i den första raden, de nästa 4 elementen i den andra raden, och så vidare.

Andra metoden (bättre) :

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

Denna typ av initiering använder sig av kapslade klammerparenteser. Varje uppsättning inre hängslen representerar en rad. I exemplet ovan finns det totalt tre rader så det finns tre uppsättningar inre hängslen. Fördelen med denna metod är att den är lättare att förstå.

Obs! Antalet element i initieringslistan ska alltid vara mindre än eller lika med det totala antalet element i arrayen.

Vi kan också deklarera arrayen utan att definiera storleken på raden om vi använder listinitiering. Kompilatorn kommer automatiskt att härleda storleken på arrayen i detta fall:

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

Det är fortfarande obligatoriskt att definiera antalet kolumner.

2. Initiering av 2D-array med loopar

Vi kan använda vilken C-loop som helst för att initiera varje medlem i en 2D-array en efter en som visas i exemplet nedan.

Exempel:

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

Denna metod är användbar när värdena för varje element har någon sekventiell relation.

Åtkomst till element i tvådimensionella arrayer i C

Element i 2D-matriser nås med hjälp av radindex och kolumnindex. Varje element i en 2D-array kan refereras till med:

Syntax:

array_name[i][j]>

var,

java för paus

• jag: Radindex.
• j: Kolumnindex.

Exempel:

int x[2][1];>

Ovanstående exempel representerar elementet som finns i den tredje raden och den andra kolumnen.

Notera : I arrayer, om storleken på en array är N. Dess index kommer att vara från 0 till N-1. Därför, för radindex 2 är radnummer 2+1 = 3. För att mata ut alla element i en tvådimensionell array kan vi använda kapslade för loopar. Vi kommer att kräva två för ’ slingor. En för att korsa raderna och en annan för att korsa kolumner.

För att skriva ut hela arrayen kommer vi åt varje element ett efter ett med hjälp av slingor. Övergångsordningen kan vara rad-huvudordning eller kolumn-storordning beroende på kravet. Exemplet nedan visar radens större korsning av en 2D-array.

Exempel:

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>

Tidskomplexitet: O(N*M) , där N(här 3) och M(här 2) är antal rader respektive kolumner.

Rymdkomplexitet:O(1)

Hur lagras 2D-arrayer i minnet?

Elementen i 2-D-matrisen måste lagras kontinuerligt i minnet. Eftersom datorerna har linjära minnesadresser måste 2D-matriserna linjäriseras för att möjliggöra deras lagring. Det finns två sätt att uppnå linjärisering av arrayelement:

• Rad-dur- Linjäriseringstekniken lagrar först den första raden i arrayen, sedan den andra raden i arrayen, sedan den tredje raden, och så vidare. (dvs. element lagras radvis. Rader listas på basis av kolumner)
• Kolumn-major – Denna linjäriseringsteknik lagrar först den första kolumnen, sedan den andra kolumnen, sedan den tredje kolumnen, och så vidare, dvs (element lagras kolumnvis. Kolumner listas på basis av rader)

Datorn håller inte reda på adresserna till alla element i arrayen men håller reda på Base Address (startadress för det allra första elementet) och beräknar adresserna till elementen när det behövs.

För att veta mer, se artikeln - Beräkning av adress för element av 1-D, 2-D och 3-D

Tredimensionell array i C

A Tredimensionell array eller 3D array i C är en samling tvådimensionella arrayer. Det kan visualiseras som flera 2D-arrayer staplade ovanpå varandra.

Grafisk representation av tredimensionell matris i storlek 3 x 3 x 3

Deklaration om tredimensionell array i C

Vi kan deklarera en 3D-array med x 2D-matriser som var och en har och rader och Med kolumner med hjälp av syntaxen som visas nedan.

Syntax:

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

• data typ: Typ av data som ska lagras i varje element.
• array_name: arrayens namn
• x: Antal 2D-matriser.
• och: Antal rader i varje 2D-array.
• Med: Antal kolumner i varje 2D-array.

Exempel:

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

Initialisering av tredimensionell array i C

Initiering i en 3D-array är densamma som för 2D-arrayer. Skillnaden är när antalet dimensioner ökar så antalet kapslade hängslen kommer också att öka.

En 3D-array i C kan initieras genom att använda:

1. Initialiseringslista
2. Slingor

Initialisering av 3D Array med hjälp av Initialiseringslista

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

Metod 2 (bättre) :

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

Återigen, precis som 2D-matriserna, kan vi också deklarera 3D-matriserna utan att specificera storleken på de första dimensionerna om vi använder initialiseringslistan för initiering. Kompilatorn kommer automatiskt att härleda storleken på den första dimensionen. Men vi måste fortfarande specificera resten av dimensionerna.

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

Initialisering av 3D Array med loopar

Det liknar också det för 2D-array med en mer kapslad slinga för åtkomst till ytterligare en dimension.

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

Åtkomst till element i tredimensionell array i C

Åtkomst till element i 3D-arrayer liknar också det för 2D-arrayer. Skillnaden är att vi måste använda tre loopar istället för två loopar för ytterligare en dimension i 3D-arrayer.

Syntax:

array_name[x][y][z]>

var,

• x: Index för 2D-array.
• och: Index för den 2D-arrayraden.
• Med: Index för den 2D-matriskolumnen.

C

>

hur man konverterar sträng till int i java

>

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>

På liknande sätt kan vi skapa arrayer med valfritt antal dimensioner. Men komplexiteten ökar också när antalet dimensioner ökar. Den mest använda flerdimensionella arrayen är den tvådimensionella arrayen.

Arrayer är också nära besläktade med pekare i C-språk. För att veta mer om förhållandet mellan arrayer och pekare i C, se detta artikel.