2D-Arrays in C#

Zweidimensionale Arrays sind eine Sammlung homogener Elemente, die sich über mehrere Zeilen und Spalten erstrecken und die Form einer Matrix annehmen. Unten sehen Sie ein Beispiel für ein 2D-Array mit m Zeilen und n Spalten, wodurch eine Matrix mit m x n-Konfiguration entsteht.

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

Konzept der Jagged Arrays

Ein Jagged Array ist ein Array von Arrays. Gezackte Arrays sind im Wesentlichen mehrere gezackte Arrays, die zu einem mehrdimensionalen Array zusammengefügt werden. Ein zweidimensionales gezacktes Array könnte etwa so aussehen:

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

Beachten Sie, dass alle Zeilen eines gezackten Arrays die gleiche Anzahl von Elementen enthalten können oder auch nicht.

Echte 2D-Arrays vs. gezackte Arrays

Jagged Arrays unterscheiden sich aus Sicht der Implementierung völlig von einem echten 2D-Array. Es ist wichtig zu verstehen, wie C# sowohl mehrdimensionale Arrays als auch gezackte Arrays implementiert.

Programmiersprachen unterscheiden sich in der Implementierung mehrdimensionaler Arrays. Einige Programmiersprachen wie C, C++, C#, Fortran usw. unterstützen echte 2D-Arrays. Während es andere gibt, die dieses Verhalten mit Arrays von Arrays, auch Jagged Arrays genannt, simulieren. Wie unterscheidet sich ein echtes zweidimensionales Array von gezackten Arrays?

Die beiden Implementierungen mehrdimensionaler Arrays unterscheiden sich hinsichtlich des Speicherverbrauchs. Während ein echtes 2D-Array m Zeilen mit jeweils n Elementen hätte, könnte ein gezacktes Array m Zeilen mit jeweils unterschiedlicher Anzahl von Elementen haben. Dies führt zu einer minimalen Platzverschwendung für Datensätze. Daher ist das unten gezackte Array völlig in Ordnung:

int[][] jagged array = [ [1, 2, 3, 4],
[5, 6, 7],
[8, 9] ]

Wenn derselbe Datensatz in einem echten 2D-Array implementiert würde, wäre das wie folgt:

int[,] multiDimArray = [ 1, 2, 3, 4
5, 6, 7, 0
8, 9, 0, 0 ]

Operationen auf 2D-Arrays in C#

Hier einige Operationen an 2D-Arrays unten:

1. Erstellen Sie ein C#-2D-Array

Sehen wir uns eine Möglichkeit an, wie man ein 2D-Array in C# deklariert, und eine andere Möglichkeit, wie man ein 2D-Array in C# nicht deklariert.

Wie geht's?

Eine echte 2D-Array-Implementierung in C# beginnt mit der Array-Deklaration. Es sieht wie folgt aus:

int[,] arr2D;
string[,] arr2D_s;

Die Anzahl der Kommas in der Definition bestimmt die Dimension des Arrays. Beachten Sie, dass Sie die Größe des Arrays nicht in der Array-Deklaration angeben können. Dies muss während der Initialisierung eines Arrays erfolgen.

Wie auch nicht?

Es ist leicht, die Implementierungen von 2D-Arrays und gezackten Arrays zu verwechseln. Eine gezackte Array-Deklaration sieht wie folgt aus:

int[][] jagged array;

2. C#-2D-Array initialisieren

Der nächste Schritt besteht darin, das gerade deklarierte 2D-Array zu initialisieren. Dafür gibt es mehrere Möglichkeiten.

Verwendung des neuen Operators

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

Initialisierung mit Werten

//without dimensions
arr2D = new int[,]{{1,2}, {3,4}, {5,6}};
//with declaration
arr2D_s = new string[2,2]{{"one","two"},{"three", "four"}};

Ohne den neuen Operator

Int[,] arr2D_a = {{1,2}, {3,4}, {5,6}, {7,8}};

3. Elemente aus C#-2D-Array lesen

Einzelnes Element lesen

Der nächste Vorgang besteht darin, die Elemente aus dem 2D-Array zu lesen. Da das 2D-Array eine Matrix aus m x n Elementen ist, verfügt jedes Element über eine bestimmte Kombination aus Zeilenindex und Spaltenindex. Wir können auf die Elemente zugreifen, indem wir den Zeilenindex und den Spaltenindex im Index angeben. Ein Beispiel ist unten:

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'

Lesen Sie alle Elemente

Aber die obige Methode gibt uns den Wert eines einzelnen Elements im Array. Wie durchqueren wir das gesamte Array, um jedes einzelne Element davon zu lesen? Die einfache Lösung besteht darin, das gesamte Array mithilfe verschachtelter for/while-Schleifen zu durchlaufen.

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

Ausgabe

Die GetLength()-Methode

Okay. Das obige Beispiel funktioniert jedoch nur, wenn ich die Anzahl der Elemente im Array vorher kenne. Was ist, wenn mein Array dynamisch ist? Wie durchlaufe ich alle Elemente eines dynamischen Arrays? Hier kommt uns die GetLength-Methode zu Hilfe.

int arr2D.GetLength(0); //gibt die erste Dimension (Zeilen) zurück

int arr2D.GetLength(1); //gibt die zweite Dimension (Spalten) zurück

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

Ausgabe

Die Leistung von for every loop

Die for-each-Schleife führt eine Reihe von Befehlen für jedes Element des Arrays aus. Dies ist ein sehr leistungsstarker Schleifenmechanismus, dessen Verwendung dringend empfohlen wird, da er effizienter ist als eine herkömmliche for-Schleife.

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

Ausgabe

4. Elemente in ein C#-2D-Array einfügen

Sehen wir uns nun ein Beispiel zum Einfügen von Elementen in ein C#-2D-Array an. Die Idee besteht darin, jede Position des Arrays zu durchlaufen und ihr einen Wert zuzuweisen.

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

Output

5. Update Elements in C# 2D Array

We will update our array to multiply each element with 2. The idea is to traverse each position of the array and update the value it holds.

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

Output

6. Delete Elements in C# 2D Array

This is a tricky operation. It is not possible to delete a single element from a true C# 2D Array. Deleting a single element will disturb the dimensions of the array such that it would no longer be a matrix. C# does not allow that unless it is a jagged array.

So, what is the solution? Do we delete the entire row or the entire column? No, C# would not allow that as well. The array is fixed in size when declared or initialized. It has fix bytes of memory allocated. We cannot change that at run time.

The solution here is to create a new array without the elements that we want to delete.

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

Output

Conclusion

Thus, we have seen how a 2D Array is implemented in C# and what are the various CRUD operations we can perform on it. We also learned the difference between a true 2D implementation and a jagged array. There are a lot more methods available in C# to assist the developers with working with Arrays at ease. Do check them out at the MSDN docs.

Recommended Articles

This is a guide to 2D Arrays in C#. Here we discuss the concept of jagged arrays along with operations on 2D arrays in C#. You may also look at the following articles to learn more-

1. 2D Arrays in Java
2. 2D Arrays In Python
3. Arrays in C#
4. Arrays in C++

Das obige ist der detaillierte Inhalt von2D-Arrays in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!