Tvådimensionella arrayer

Ett föreläsningsutdrag med en mentor som en del av Codegym University-kursen. Anmäl dig till hela kursen.

"Hälsningar, Amigo!"

"Hej Rishi!"

"Du vet redan ett och annat om arrayer, och du lyckades till och med lösa några uppgifter, hoppas jag. Men du vet inte allt. Till exempel, här är ett annat intressant faktum om arrayer. Arrayer är inte bara endimensionella (linjära) ). De kan också vara tvådimensionella."

"Ehm... Vad betyder det?"

"Detta betyder att cellerna i arrayen inte bara kan representera en kolumn (eller rad), utan också en rektangulär tabell.

int[][]name = new int[width][height];

"Där namn är namnet på arrayvariabeln, bredd är tabellbredden (i celler) och höjd är tabellhöjden. Ta en titt på ett exempel:

int[][] data = new int[2][5];
data[1][1] = 5;

"Så här kommer det att se ut i minnet:

"Förresten, för tvådimensionella arrayer kan du också använda snabb initiering:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"Hmm... nu är det intressant. Om vi ​​föreställer oss att i de första inre parenteserna representerar ett element, är nästa ett andra... Så en tvådimensionell array är som en array av arrays?"

"Vilken smart student du är! Precis. Det första elementet är den endimensionella arrayen , {31, 28, 31}den andra är {30, 31, 30}, och så vidare. Men vi återkommer till det lite senare i den här lektionen. Tills dess, försök att tänka på en tvådimensionell matris som en tabell med rader och kolumner, som bildar celler vid varje skärningspunkt.

"Jag har en mental bild av det. Förresten, vad används de till, dessa tvådimensionella arrayer?"

"Programmerare behöver tvådimensionella arrayer ganska ofta. Om du tittar noga, implementeras nästan alla brädspel med hjälp av en tvådimensionell array från hyllan: schack, dam, tic-tac-toe, sjöstrid, etc.:"

"Jag förstår! Spelplanen för schack eller sjöstrid passar perfekt på tvådimensionella arrayer!"

"Ja, men du måste använda siffror som cellkoordinater. Inte 'bonde e2-e4', utan 'bonde (5,2) -> (5,4)'. Det blir ännu lättare för dig som programmerare. "

Ordna element i arrayer: (x, y) eller (y, x)

"Att skapa tvådimensionella arrayer väcker ett intressant dilemma. När vi skapar en array med hjälp av , new int [2][5];har vi en tabell med 'två rader och 5 kolumner ' eller är det 'två kolumner och 5 rader'?"

"Det är med andra ord inte helt klart om vi först anger bredden och sedan 'höjden... eller tvärtom, först höjden och sedan bredden?"

"Ja, detta är dilemmat. Och det finns inget definitivt svar."

"Vad ska man göra?"

"Först är det viktigt att förstå hur vår tvådimensionella array faktiskt är lagrad i minnet. Naturligtvis har datorminne faktiskt inga tabeller i sig: varje plats i minnet har en sekventiell numerisk adress: 0, 1, 2, ... För oss är detta en 2 × 5 tabell, men i minnet är det bara 10 celler, inget mer. Ingen uppdelning i rader och kolumner."

"Jag förstod det. Hur bestämmer vi då vilken dimension som kommer först - bredden eller höjden?"

"Låt oss överväga det första alternativet. Bredd först, sedan höjd. "Argumentet för detta tillvägagångssätt är detta: alla lär sig matematik i skolan, och de lär sig att koordinatpar skrivs som 'x' (det vill säga den horisontella axeln) och sedan 'y' (den vertikala dimensionen). Och detta är inte bara en skolstandard - det är en allmänt accepterad standard inom matematik. Som de säger, du kan inte argumentera med matematik."

"Är det så? Tja, om vi inte kan slåss, då först bredden och sedan höjden?"

"Det finns ett intressant argument till förmån för 'höjd först, sedan bredd'. Detta argument kommer från snabb initiering av tvådimensionella arrayer. När allt kommer omkring, om vi vill initiera vår array, så skriver vi kod så här:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"Så vad gör det för oss?"

"Märde du något? Tänk om vi har det här?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"Om vi ​​skriver våra data i koden rad för rad får vi en tabell med 2 rader och 5 kolumner."

"Nu ser jag. 2 är höjden och 5 är bredden... Så vilket alternativ ska vi då använda?"

"Det är upp till dig att bestämma vilket som är bekvämast. Det viktigaste är att alla programmerare som arbetar med samma projekt håller sig till samma tillvägagångssätt."

"Om du arbetar med ett projekt vars kod har massor av initierade tvådimensionella arrayer, så kommer allt troligen att baseras på snabb datainitiering, dvs du kommer att ha standarden 'höjd x bredd'.

"Om du befinner dig i ett projekt som involverar mycket matematik och arbetar med koordinater (till exempel spelmotorer), kommer koden med största sannolikhet att anta "bredd x höjd"-metoden.

Hur tvådimensionella arrayer är arrangerade

"Nu, kommer du ihåg den speciella egenskapen hos tvådimensionella arrayer som du märkte i början av lektionen?"

"Ja! Det var att tvådimensionella arrayer faktiskt är arrayer av arrayer!"

"Helt riktigt. "Med andra ord, om i fallet med en vanlig array en arrayvariabel lagrar en referens till en behållare som lagrar arrayelement, då exploderar situationen lite i fallet med tvådimensionella arrayer: en tvådimensionell -arrayvariabel lagrar en referens till en behållare som lagrar referenser till endimensionella arrayer. Det är bättre att se det i aktion en gång istället för att försöka förklara det hundra gånger:"

"Till vänster har vi en tvådimensionell arrayvariabel, som lagrar en referens till ett tvådimensionell arrayobjekt. I mitten finns ett tvådimensionellt arrayobjekt vars celler lagrar endimensionella arrayer, som är rader i en tvådimensionell array. Och till höger kan du se fyra endimensionella arrayer — raderna i vår tvådimensionella array. Så här fungerar tvådimensionella arrayer faktiskt."

"Fantastiskt! Men vad ger det oss?"

"Eftersom en 'container of containers' lagrar referenser till 'arrays of rows' kan vi mycket snabbt och enkelt byta rader. För att få en 'container of containers' behöver du bara ange ett index istället för två. Exempel:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

"Titta på koden nedan. Vi kan använda den för att byta rader:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"Förstår. Det fungerar som att byta två vanliga föremål."

"Så det gör det. Tja, om du hänvisar till en cell i en tvådimensionell array, men du bara anger ett index efter namnet på arrayen, då hänvisar du till en behållare med behållare vars celler lagrar referenser till vanlig en- dimensionella arrayer."

"Allt verkar logiskt och tydligt. Tack för föreläsningen, Rishi!"

"Du är välkommen. Omsätt det på ett klokt sätt."