Inleiding tot 2D-arrays in C #

Tweedimensionale arrays zijn een verzameling homogene elementen die zich over meerdere rijen en kolommen uitstrekken, in de vorm van een matrix. Hieronder ziet u een voorbeeld van een 2D-array met m rijen en n kolommen, waarmee een matrix met mxn-configuratie wordt gemaakt.

( a1, a2, a3, a4, …, an
b1, b2, b3, b4, …, bn
c1, c2, c3, c4, …, cn
.
.
.
m1, m2, m3, m4, …, mn )

Concept van Jagged Arrays

Een Jagged Array is een reeks arrays. Gekartelde reeksen zijn in wezen meerdere gekartelde reeksen om een ​​multidimensionale reeks te vormen. Een tweedimensionale gekartelde array kan er ongeveer zo uitzien:

( ( a1, a2, a3, a4, …, an ),
( b1, b2, b3, b4, …, b20 ),
( c1, c2, c3, c4, …, c30 ),
.
.
.
( m1, m2, m3, m4, …, m25 ) )

Merk op dat alle rijen van een gekartelde array al dan niet hetzelfde aantal elementen kunnen bevatten.

Echte 2D-arrays versus gekartelde arrays

Jagged Arrays zijn totaal verschillend van een echte 2D-array vanuit een implementatieperspectief. Het is belangrijk om te begrijpen hoe C # zowel multidimensionale arrays als gekartelde arrays implementeert.

Programmeertalen verschillen in hun implementatie van multidimensionale arrays. Sommige programmeertalen zoals C, C ++, C #, Fortran, etc. ondersteunen echte 2D-arrays. Terwijl er anderen zijn die dit gedrag simuleren met arrays van arrays aka gekartelde arrays. Dus, hoe verschilt een echte tweedimensionale array van gekartelde arrays?

De twee implementaties van multidimensionale arrays verschillen qua opslagconsumptie. Terwijl een echte 2D-reeks m rijen van n elementen elk zou hebben, zou een gekartelde reeks m rijen kunnen hebben die elk een verschillend aantal elementen hebben. Dit leidt tot een minimale verspilde ruimte voor gegevenssets. Dus de onder-gekartelde array is prima:

int()() jagged array = ( (1, 2, 3, 4),
(5, 6, 7),
(8, 9) )

Als dezelfde gegevensset zou worden geïmplementeerd in een echte 2D-array, zou het zijn zoals hieronder:

int(, ) multiDimArray = ( 1, 2, 3, 4
5, 6, 7, 0
8, 9, 0, 0 )

Bewerkingen op 2D-arrays in C #

Hier volgen enkele bewerkingen op 2D-arrays:

1. Construct C # 2D-array

Laten we een manier zien om een ​​2D-array in C # te declareren en een andere manier om een ​​2D-array niet in C # te declareren.

Hoe?

Een echte 2D Array-implementatie in C # begint met de Array-aangifte. Het ziet er als volgt uit:

int(, ) arr2D;
string(, ) arr2D_s;

Het aantal komma's in de definitie bepaalt de dimensie van de array. Houd er rekening mee dat u de grootte van de array niet kunt opgeven in de arraydeclaratie. Dit moet worden gedaan tijdens de initialisatie van een array.

Hoe niet?

Het is gemakkelijk om verward te raken tussen de implementaties van 2D-arrays en gekartelde arrays. Een declaratie van gekartelde matrix ziet er als volgt uit:

int()() jagged array;

2. Initialiseer C # 2D-array

De volgende stap is het initialiseren van de 2D-array die we zojuist hebben gedeclareerd. Er zijn verschillende manieren om dit te doen.

De nieuwe operator gebruiken

arr2D = new int(2, 3); //separate initialization
string(, ) arr2D_s = new string(4, 5); //with declaration

Initialiseren met waarden

//without dimensions
arr2D = new int(, )((1, 2), (3, 4), (5, 6));
//with declaration
arr2D_s = new string(2, 2)((“one”, ”two”), (“three”, “four”));

Zonder de nieuwe operator

Int(, ) arr2D_a = ((1, 2), (3, 4), (5, 6), (7, 8));

3. Lees elementen van C # 2D Array

Lees een enkel element

De volgende bewerking is het lezen van de elementen uit de 2D-array. Aangezien de 2D-array een matrix van mxn-elementen is, heeft elk element een toegewezen rij-index en kolom-index combinatie. We hebben toegang tot de elementen door de rij-index en kolom-index in het subscript op te geven. Een voorbeeld is hieronder:

int(, ) arr2D_i = ((1, 2), (3, 4), (5, 6), (7, 8));
string arr2D_s = ((“one”, ”two”), (“three”, “four”));
int val_i = arr2D_i(2, 1); //returns '6'
string val_s = arr2D_s(1, 1); //returns 'four'

Opmerking: de indices van rijen en kolommen beginnen bij 0. De indexpositie (0, 0) is dus het eerste element en (m-1, n-1) is het laatste element van de array.

Lees alle elementen

Maar de bovenstaande methode geeft ons de waarde van een enkel element in de array. Hoe doorkruisen we de hele reeks om elk element ervan te lezen? De eenvoudige oplossing is het doorlopen van de hele array met behulp van geneste for / while-lussen.

Code

using System;
public class Program
(
public static void Main()
(
int(, ) arr2D_i = new int(3, 3)((1, 2, 3), (4, 5, 6), (7, 8, 9));
//reading all the elements through for loop
for (int i = 0; i < 3; i++)
(
for (int j = 0; j < 3; j++)
(
Console.Write(arr2D_i(i, j) + "\t");
)
Console.WriteLine("\n");
)
)
)

uitgang

De methode GetLength ()

Oke. Maar het bovenstaande voorbeeld werkt alleen als ik van tevoren het aantal elementen in de array weet. Wat als mijn array dynamisch is? Hoe doorloop ik alle elementen van een dynamische array? Hier komt de GetLength-methode ons te hulp.

int arr2D.GetLength (0); // retourneert eerste dimensie (rijen)

int arr2D.GetLength (1); // retourneert tweede dimensie (kolommen)

Code

using System;
public class Program
(
public static void Main()
(
int(, ) arr2D_i = new int(3, 3)((1, 2, 3), (4, 5, 6), (7, 8, 9));
//reading all the elements through for loop
for (int i = 0; i < arr2D_i.GetLength(0); i++)
(
for (int j = 0; j < arr2D_i.GetLength(1); j++)
(
Console.Write(arr2D_i(i, j) + "\t");
)
Console.WriteLine("\n");
)
)
)

uitgang

De kracht van voor elke lus

De for-each-lus voert een set opdrachten uit voor elk element van de array. Dit is een zeer krachtig lusmechanisme en wordt ten zeerste aanbevolen om te gebruiken omdat het efficiënter is dan een traditionele luslus.

Code

using System;
public class Program
(
public static void Main()
(
string(, ) arr2D_s = new string(3, 3)(("one", "two", "three"), ("four", "five", "six"), ("seven", "eight", "nine"));
//reading all the elements through foreach loop
foreach(var ele in arr2D_s)
(
Console.WriteLine(ele);
)
)
)

uitgang

4. Voeg elementen in de C # 2D-array in

Laten we nu een voorbeeld bekijken van het invoegen van elementen in een C # 2D-array. Het idee is om elke positie van de array te doorlopen en er een waarde aan toe te wijzen.

Code

using System;
public class Program
(
public static void Main()
(
int(, ) arr2D_i = new int(3, 3)((1, 2, 3), (4, 5, 6), (7, 8, 9));
int(, ) squares = new int(3, 3);
int(, ) cubes = new int(3, 3);
for (int i = 0; i < arr2D_i.GetLength(0); i++)
(
for (int j = 0; j < arr2D_i.GetLength(1); j++)
(
squares(i, j) = arr2D_i(i, j) * arr2D_i(i, j);
cubes(i, j) = squares(i, j) * arr2D_i(i, j);
)
)
Console.WriteLine("Squares\n");
DisplayArray(squares);
Console.WriteLine("\n\nCubes\n");
DisplayArray(cubes);
)
static void DisplayArray(int(, ) arr)
(
for (int i = 0; i < arr.GetLength(0); i++)
(
for (int j = 0; j < arr.GetLength(1); j++)
( Console.Write(arr(i, j) + "\t"); )
Console.WriteLine("\n");
)
)
)

uitgang

5. Werk elementen bij in C # 2D-array

We zullen onze array bijwerken om elk element met 2 te vermenigvuldigen. Het idee is om elke positie van de array te doorlopen en de waarde ervan bij te werken.

Code

using System;
public class Program
(
public static void Main()
(
int(, ) arr2D_i = new int(3, 3)((1, 2, 3), (4, 5, 6), (7, 8, 9));
Console.WriteLine("Original Array\n");
DisplayArray(arr2D_i);
for (int i = 0; i < arr2D_i.GetLength(0); i++)
(
for (int j = 0; j < arr2D_i.GetLength(1); j++)
(
arr2D_i(i, j) *= 2;
)
)
Console.WriteLine("\n\nUpdated Array (multiplied by 2)\n");
DisplayArray(arr2D_i);
)
static void DisplayArray(int(, ) arr)
(
for (int i = 0; i < arr.GetLength(0); i++)
(
for (int j = 0; j < arr.GetLength(1); j++)
(
Console.Write(arr(i, j) + "\t");
)
Console.WriteLine("\n");
)
)
)

uitgang

6. Verwijder elementen in C # 2D Array

Dit is een lastige operatie. Het is niet mogelijk om een ​​enkel element uit een echte C # 2D-array te verwijderen. Het verwijderen van een enkel element zal de dimensies van de array zodanig verstoren dat het niet langer een matrix is. C # staat dat niet toe tenzij het een gekartelde array is.

Dus wat is de oplossing? Verwijderen we de hele rij of de hele kolom? Nee, C # zou dat ook niet toestaan. De array heeft een vaste grootte wanneer deze wordt gedeclareerd of geïnitialiseerd. Het heeft vaste bytes geheugen toegewezen. We kunnen dat tijdens runtime niet veranderen.

De oplossing hier is om een ​​nieuwe array te maken zonder de elementen die we willen verwijderen.

Code

using System;
public class Program
(
public static void Main()
(
int(, ) arr2D_i = new int(3, 3)((1, 2, 3), (4, 5, 6), (7, 8, 9));
int(, ) new_array = new int(2, 2);
Console.WriteLine("Original Array\n");
DisplayArray(arr2D_i);
int rowToDel = 2;
int colToDel = 2;
for (int i = 0; i < arr2D_i.GetLength(0); i++)
(
if(i==rowToDel)
continue;
for (int j = 0; j < arr2D_i.GetLength(1); j++)
(
if(j==colToDel)
continue;
new_array(i, j)=arr2D_i(i, j);
)
)
Console.WriteLine("\n\nArray after deleting elements\n");
DisplayArray(new_array);
)
static void DisplayArray(int(, ) arr)
(
for (int i = 0; i < arr.GetLength(0); i++)
(
for (int j = 0; j < arr.GetLength(1); j++)
(
Console.Write(arr(i, j) + "\t");
)
Console.WriteLine("\n");
)
)
)

uitgang

Conclusie

We hebben dus gezien hoe een 2D-array in C # is geïmplementeerd en wat de verschillende CRUD-bewerkingen zijn die we erop kunnen uitvoeren. We hebben ook het verschil geleerd tussen een echte 2D-implementatie en een gekartelde array. Er zijn veel meer methoden beschikbaar in C # om de ontwikkelaars te helpen op hun gemak met Arrays te werken. Ga ze bekijken bij de MSDN-documenten.

Aanbevolen artikelen

Dit is een gids voor 2D-arrays in C #. Hier bespreken we het concept van gekartelde arrays samen met bewerkingen op 2D-arrays in C #. U kunt ook de volgende artikelen bekijken voor meer informatie-

  1. 2D-arrays in Java
  2. 2D-reeksen in Python
  3. Arrays in C #
  4. Arrays in C ++
  5. Arrays in PHP
  6. 2D-afbeeldingen in Java
  7. Hoe arrays en lijsten werken in Python?
  8. Multidimensionale arrays in C ++ met voorbeelden
  9. 2D-arrays in PHP