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 ]
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 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 ]
Di sini, beberapa operasi pada Tatasusunan 2D diberikan di bawah:
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;
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}};
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'
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
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
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
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
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.
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-
Atas ialah kandungan terperinci Tatasusunan 2D dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!