Introducere în Arhiere 2D în C #

Matricele bidimensionale sunt o colecție de elemente omogene care se întind pe mai multe rânduri și coloane, asumând forma unei matrice. Mai jos este un exemplu de matrice 2D care are m rânduri și n coloane, creând astfel o matrice de configurație mxn.

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

Conceptul de Jagged Arrays

O matrice zimțată este o serie de tablouri. Matricele zimțate sunt, în esență, mai multe tablouri împărțite împreună pentru a forma un tablou multidimensional. Un tablou zimțat bidimensional poate arăta astfel:

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

Rețineți că toate rândurile unui tablou zimțat pot conține sau nu același număr de elemente.

Arrayuri adevărate 2D vs Jagged Arrays

Array-urile zimțate sunt complet diferite decât un adevărat tablou 2D din perspectiva implementării. Este important să înțelegem modul în care C # implementează atât tablouri multidimensionale, cât și tablouri zimțate.

Limbile de programare diferă în implementarea matricelor multidimensionale. Unele limbaje de programare precum C, C ++, C #, Fortran, etc., acceptă adevărate tablouri 2D. În timp ce există alții care simulează acest comportament cu tablouri de tablouri, de asemenea, tablouri zimțate. Deci, cum este diferit un adevărat tablou bidimensional de matricile zimțate?

Cele două implementări ale matricelor multidimensionale sunt diferite în ceea ce privește consumul de stocare. În timp ce un adevărat tablou 2D ar avea m rânduri de n elemente fiecare, un tablou zimțat ar putea avea m rânduri fiecare având un număr diferit de elemente. Acest lucru duce la un spațiu minim pierdut pentru seturi de date. Astfel, tabelul de mai jos este perfect perfect:

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

Dacă același set de date ar fi fost implementat într-un adevărat tablou 2D, ar fi fost după cum urmează:

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

Operațiuni cu Arătări 2D în C #

Aici, unele operații pe Arhiere 2D date mai jos:

1. Construiește C # 2D Array

Haideți să vedem un mod despre cum se poate declara un tablou 2D în C # și un alt mod despre cum să nu se declare un tablou 2D în C #.

Cum să?

O adevărată implementare Array 2D în C # începe cu declarația Array. Arată ca mai jos:

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

Numărul de virgule din definiție determină dimensiunea tabloului. Rețineți că nu puteți specifica dimensiunea tabloului în declarația matricială. Trebuie făcut în timpul inițializării unui tablou.

Cum să nu?

Este ușor să vă confundați între implementările matricelor 2D și matricile zimțate. O declarație matricială zimtată arată ca mai jos:

int()() jagged array;

2. Inițializează Array C # 2D

Următorul pas este inițializarea tabloului 2D pe care tocmai l-am declarat. Există mai multe modalități de a face acest lucru.

Utilizarea noului operator

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

Inițializarea cu valori

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

Fără noul operator

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

3. Citiți Elemente din Array C # 2D

Citiți un singur element

Următoarea operație este să citiți elementele din Arhiva 2D. Deoarece 2D Array este o matrice de elemente mxn, fiecare element are o combinație desemnată rând-index și coloană-index. Putem accesa elementele furnizând indexul rând și coloana în abonament. Un exemplu este mai jos:

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'

Notă- Indicii rândurilor și coloanelor încep de la 0. Astfel, poziția indexului (0, 0) este primul element și (m-1, n-1) este ultimul element al tabloului.

Citiți toate elementele

Dar, metoda de mai sus ne oferă valoarea unui singur element din tablou. Cum traversăm întregul tablou pentru a citi fiecare element al acestuia? Soluția simplă este realizarea de bucle pe întregul tablou folosind bucle cuibare pentru / în timp.

Cod

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

producție

Metoda GetLength ()

Bine. Dar, exemplul de mai sus funcționează doar atunci când știu în prealabil numărul de elemente din tablă. Ce se întâmplă dacă tabloul meu este dinamic? Cum pot traversa toate elementele unui tablou dinamic? Aici vine metoda GetLength pentru salvarea noastră.

int arr2D.GetLength (0); // returnează prima dimensiune (rânduri)

int arr2D.GetLength (1); // returnează a doua dimensiune (coloane)

Cod

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

producție

Puterea pentru fiecare buclă

Pentru fiecare buclă se execută un set de comenzi pentru fiecare element al tabloului. Acesta este un mecanism de buclă foarte puternic și este recomandat să fie utilizat, deoarece este mai eficient decât un tradițional pentru buclă.

Cod

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

producție

4. Introduceți elementele în Array C # 2D

Acum să vedem un exemplu despre cum să inserați elemente într-un Array C # 2D. Ideea este să traversăm fiecare poziție a tabloului și să îi atribuim o valoare.

Cod

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

producție

5. Actualizează Elemente în C # 2D Array

Vom actualiza matricea noastră pentru a multiplica fiecare element cu 2. Ideea este să traversăm fiecare poziție a tabloului și să actualizăm valoarea pe care o deține.

Cod

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

producție

6. Ștergeți elementele în Array C # 2D

Aceasta este o operație complicată. Nu este posibilă ștergerea unui singur element dintr-un Array C # 2D adevărat. Ștergerea unui singur element va perturba dimensiunile tabloului, astfel încât acesta nu va mai fi o matrice. C # nu permite asta decât dacă este un tablou zimțat.

Deci, care este soluția? Ștergem întregul rând sau întreaga coloană? Nu, C # nu ar permite asta. Matricea este fixată ca mărime atunci când este declarată sau inițiată. Are octeți fixi de memorie alocați. Nu putem schimba asta în timp de execuție.

Soluția aici este crearea unui nou tablou fără elementele pe care dorim să le ștergem.

Cod

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

producție

Concluzie

Astfel, am văzut cum este implementată o matrice 2D în C # și care sunt diferitele operații CRUD pe care le putem efectua pe acesta. Am învățat, de asemenea, diferența dintre o implementare adevărată 2D și un tablou zimțat. Există multe alte metode disponibile în C # pentru a ajuta dezvoltatorii să lucreze cu Array-uri cu ușurință. Verificați-le la documentele MSDN.

Articole recomandate

Acesta este un ghid pentru Schițele 2D în C #. Aici vom discuta conceptul de matrițe zimțate împreună cu operațiunile cu matrice 2D în C #. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-

  1. Arhiere 2D în Java
  2. Arătări 2D în Python
  3. Arătări în C #
  4. Arătări în C ++
  5. Arătări în PHP
  6. Grafica 2D în Java
  7. Cum funcționează Schițele și Listele în Python?
  8. Arătări multidimensionale în C ++ cu exemple
  9. Arătări 2D în PHP