Tatasusunan 2D dalam C#

Tatasusunan dua dimensi ialah himpunan unsur homogen yang merentangi berbilang baris dan lajur, dengan mengandaikan bentuk matriks. Di bawah ialah contoh tatasusunan 2D yang mempunyai m baris dan n lajur, dengan itu mencipta matriks konfigurasi m x n.

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

Konsep Tatasusunan Bergerigi

Tatasusunan Bergerigi ialah tatasusunan tatasusunan. Tatasusunan bergerigi pada asasnya ialah berbilang tatasusunan yang dirangkai bersama untuk membentuk tatasusunan berbilang dimensi. Tatasusunan bergerigi dua dimensi mungkin kelihatan seperti ini:

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

Perhatikan bahawa semua baris tatasusunan bergerigi mungkin atau mungkin tidak mengandungi bilangan elemen yang sama.

Tatasusunan 2D Sebenar lwn Tatasusunan Bergerigi

Tatasusunan Bergerigi adalah berbeza sama sekali daripada tatasusunan 2D sebenar dari perspektif pelaksanaan. Adalah penting untuk memahami cara C# melaksanakan tatasusunan berbilang dimensi dan juga tatasusunan bergerigi.

Bahasa pengaturcaraan berbeza dalam pelaksanaan tatasusunan berbilang dimensi. Sesetengah bahasa pengaturcaraan seperti C, C++, C#, Fortran, dll. menyokong tatasusunan 2D yang benar. Walaupun terdapat orang lain yang mensimulasikan tingkah laku ini dengan tatasusunan tatasusunan a.k.a tatasusunan bergerigi. Jadi, bagaimanakah tatasusunan dua dimensi sebenar berbeza daripada tatasusunan bergerigi?

Dua pelaksanaan tatasusunan berbilang dimensi adalah berbeza dari segi penggunaan storan. Walaupun tatasusunan 2D benar akan mempunyai m baris elemen n setiap satu, tatasusunan bergerigi boleh mempunyai m baris setiap satu mempunyai bilangan elemen yang berbeza. Ini membawa kepada ruang terbuang minimum untuk set data. Oleh itu, tatasusunan bergerigi di bawah adalah baik:

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

Sekiranya set data yang sama dilaksanakan dalam tatasusunan 2D yang benar, ia akan menjadi seperti di bawah:

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

Operasi pada Tatasusunan 2D dalam C#

Di sini, beberapa operasi pada Tatasusunan 2D diberikan di bawah:

1. Bina C# 2D Array

Mari kita lihat cara untuk mengisytiharkan tatasusunan 2D dalam C# dan cara lain untuk tidak mengisytiharkan tatasusunan 2D dalam C#.

Bagaimana caranya?

Pelaksanaan Tatasusunan 2D yang benar dalam C# bermula dengan pengisytiharan Tatasusunan. Ia kelihatan seperti di bawah:

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

Bilangan koma dalam takrifan menentukan dimensi tatasusunan. Ambil perhatian bahawa anda tidak boleh menentukan saiz tatasusunan dalam pengisytiharan tatasusunan. Ia mesti dilakukan semasa permulaan tatasusunan.

Bagaimana tidak?

Adalah mudah untuk keliru antara pelaksanaan tatasusunan 2D dan tatasusunan bergerigi. Pengisytiharan tatasusunan bergerigi kelihatan seperti di bawah:

int[][] jagged array;

2. Mulakan C# 2D Array

Langkah seterusnya ialah untuk memulakan tatasusunan 2D yang baru kami isytiharkan. Terdapat beberapa cara untuk melakukannya.

Menggunakan Operator Baharu

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

Memulakan dengan nilai

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

Tanpa Operator Baharu

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

3. Baca Elemen daripada C# 2D Array

Baca satu elemen

Operasi seterusnya ialah membaca elemen daripada Tatasusunan 2D. Memandangkan Tatasusunan 2D ialah matriks elemen m x n, setiap elemen mempunyai gabungan indeks baris dan indeks lajur yang ditetapkan. Kita boleh mengakses elemen dengan menyediakan indeks baris dan indeks lajur dalam subskrip. Contohnya di bawah:

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'

Nota- Indeks baris dan lajur bermula dari 0. Oleh itu, kedudukan indeks [0,0] ialah elemen pertama dan [m-1, n-1] ialah elemen terakhir tatasusunan.

Baca semua elemen

Tetapi, kaedah di atas memberi kita nilai satu elemen dalam tatasusunan. Bagaimanakah kita merentasi keseluruhan tatasusunan untuk membaca setiap elemennya? Penyelesaian mudah adalah menggelung melalui keseluruhan tatasusunan menggunakan gelung bersarang untuk/sementara.

Kod

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

Output

Kaedah GetLength()

Baiklah. Tetapi, contoh di atas hanya berfungsi apabila saya mengetahui bilangan elemen dalam tatasusunan terlebih dahulu. Bagaimana jika tatasusunan saya dinamik? Bagaimanakah saya merentasi semua elemen tatasusunan dinamik? Inilah kaedah GetLength untuk menyelamatkan kami.

int arr2D.GetLength(0); //mengembalikan dimensi pertama (baris)

int arr2D.GetLength(1); //mengembalikan dimensi kedua (lajur)

Kod

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

Output

Kuasa untuk setiap gelung

Gelung untuk-setiap melaksanakan satu set perintah untuk setiap elemen tatasusunan. Ini ialah mekanisme gelung yang sangat berkuasa dan amat disyorkan untuk digunakan kerana ia lebih cekap daripada gelung tradisional.

Kod

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

Output

4. Sisipkan Elemen dalam C# 2D Array

Sekarang mari kita lihat contoh tentang cara memasukkan elemen dalam Tatasusunan 2D C#. Ideanya adalah untuk melintasi setiap kedudukan tatasusunan dan menetapkan nilai padanya.

Kod

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++

Atas ialah kandungan terperinci Tatasusunan 2D dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!