Wprowadzenie do tablic 2D w C #

Tablice dwuwymiarowe to zbiór jednorodnych elementów obejmujących wiele wierszy i kolumn, przyjmujących postać macierzy. Poniżej znajduje się przykład tablicy 2D, która ma m wierszy i n kolumn, tworząc macierz konfiguracji mxn.

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

Pojęcie postrzępionych tablic

Jagged Array to tablica tablic. Postrzępione tablice są w zasadzie wieloma tablicami postrzępionymi razem, tworząc tablicę wielowymiarową. Dwuwymiarowa poszarpana tablica może wyglądać mniej więcej tak:

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

Zauważ, że wszystkie wiersze poszarpanej tablicy mogą, ale nie muszą zawierać taką samą liczbę elementów.

Prawdziwe tablice 2D vs Jagged Arrays

Jagged Arrays są zupełnie inne niż prawdziwa tablica 2D z punktu widzenia implementacji. Ważne jest, aby zrozumieć, w jaki sposób C # implementuje zarówno tablice wielowymiarowe, jak i tablice poszarpane.

Języki programowania różnią się implementacją tablic wielowymiarowych. Niektóre języki programowania, takie jak C, C ++, C #, Fortran itp., Obsługują prawdziwe tablice 2D. Podczas gdy istnieją inne, które symulują to zachowanie za pomocą tablic tablic zwanych tablicami postrzępionymi. Czym zatem różni się prawdziwa dwuwymiarowa tablica od tablic poszarpanych?

Dwie implementacje tablic wielowymiarowych różnią się pod względem zużycia pamięci. Podczas gdy prawdziwa tablica 2D miałaby m rzędów n elementów każdy, poszarpana tablica mogłaby mieć m rzędów mających różną liczbę elementów. Prowadzi to do minimalnej ilości zmarnowanego miejsca na zestawy danych. Tak więc tablica poniżej poszarpanych jest idealnie w porządku:

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

Gdyby ten sam zestaw danych miał zostać zaimplementowany w prawdziwej tablicy 2D, wyglądałoby to tak:

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

Operacje na tablicach 2D w C #

Oto niektóre operacje na tablicach 2D podane poniżej:

1. Skonstruuj tablicę C # 2D

Zobaczmy sposób na zadeklarowanie tablicy 2D w C # i inny sposób na nie deklarowanie tablicy 2D w C #.

Jak?

Prawdziwa implementacja tablicy 2D w języku C # rozpoczyna się od deklaracji tablicy. Wygląda jak poniżej:

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

Liczba przecinków w definicji określa wymiar tablicy. Pamiętaj, że nie można określić rozmiaru tablicy w deklaracji tablicy. Należy to zrobić podczas inicjalizacji tablicy.

Jak nie

Łatwo jest pomylić implementacje tablic 2D i tablic postrzępionych. Deklaracja poszarpanej tablicy wygląda jak poniżej:

int()() jagged array;

2. Zainicjuj tablicę C # 2D

Następnym krokiem jest zainicjowanie właśnie zadeklarowanej tablicy 2D. Można to zrobić na kilka sposobów.

Korzystanie z nowego operatora

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

Inicjalizacja za pomocą wartości

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

Bez nowego operatora

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

3. Przeczytaj elementy z tablicy C # 2D

Przeczytaj pojedynczy element

Następną operacją jest odczytanie elementów z tablicy 2D. Ponieważ tablica 2D jest macierzą elementów mxn, każdy element ma określoną kombinację indeksu wierszy i indeksu kolumny. Możemy uzyskać dostęp do elementów, udostępniając indeks wiersza i indeks kolumny w indeksie dolnym. Przykład jest poniżej:

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'

Uwaga - Wskaźniki wierszy i kolumn zaczynają się od 0. Zatem pozycja indeksu (0, 0) jest pierwszym elementem, a (m-1, n-1) jest ostatnim elementem tablicy.

Przeczytaj wszystkie elementy

Ale powyższa metoda podaje nam wartość pojedynczego elementu w tablicy. Jak przemierzamy całą tablicę, aby odczytać każdy jej element? Prostym rozwiązaniem jest zapętlanie całej tablicy za pomocą zagnieżdżonych pętli for / while.

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

Wynik

Metoda GetLength ()

W porządku. Ale powyższy przykład działa tylko wtedy, gdy znam wcześniej liczbę elementów w tablicy. Co jeśli moja tablica jest dynamiczna? Jak przechodzić przez wszystkie elementy tablicy dynamicznej? Na ratunek przychodzi metoda GetLength.

int arr2D.GetLength (0); // zwraca pierwszy wymiar (wiersze)

int arr2D.GetLength (1); // zwraca drugi wymiar (kolumny)

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

Wynik

Moc każdej pętli

Pętla for-each wykonuje zestaw poleceń dla każdego elementu tablicy. Jest to bardzo potężny mechanizm zapętlania i jest wysoce zalecany do użycia, ponieważ jest bardziej wydajny niż tradycyjny dla pętli.

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

Wynik

4. Wstaw elementy do tablicy C # 2D

Zobaczmy teraz przykład, jak wstawiać elementy do tablicy C # 2D. Chodzi o to, aby przejść przez każdą pozycję tablicy i przypisać jej wartość.

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

Wynik

5. Zaktualizuj elementy w tablicy C # 2D

Zaktualizujemy naszą tablicę, aby pomnożyć każdy element przez 2. Pomysł polega na przejściu przez każdą pozycję tablicy i zaktualizowaniu wartości, którą posiada.

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

Wynik

6. Usuń elementy z tablicy C # 2D

To trudna operacja. Nie można usunąć pojedynczego elementu z prawdziwej tablicy 2D C #. Usunięcie pojedynczego elementu zakłóci wymiary tablicy, przez co przestanie być matrycą. C # nie pozwala na to, chyba że jest to postrzępiona tablica.

Więc jakie jest rozwiązanie? Czy usuwamy cały wiersz czy całą kolumnę? Nie, C # również na to nie pozwoli. Rozmiar tablicy ma ustalony rozmiar podczas deklaracji lub inicjalizacji. Ma przydzielone ustalone bajty pamięci. Nie możemy tego zmienić w czasie wykonywania.

Rozwiązaniem tutaj jest utworzenie nowej tablicy bez elementów, które chcemy usunąć.

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

Wynik

Wniosek

Tak więc widzieliśmy, jak tablica 2D jest implementowana w języku C # i jakie są różne operacje CRUD, które możemy na niej wykonać. Poznaliśmy także różnicę między prawdziwą implementacją 2D a postrzępioną tablicą. W języku C # dostępnych jest znacznie więcej metod, które pomagają programistom w swobodnej pracy z tablicami. Sprawdź je w dokumentach MSDN.

Polecane artykuły

Jest to przewodnik po tablicach 2D w języku C #. Tutaj omawiamy koncepcję poszarpanych tablic wraz z operacjami na tablicach 2D w C #. Możesz także przejrzeć następujące artykuły, aby dowiedzieć się więcej-

  1. Tablice 2D w Javie
  2. Tablice 2D w języku Python
  3. Tablice w C #
  4. Tablice w C ++
  5. Tablice w PHP
  6. Grafika 2D w Javie
  7. Jak działają tablice i listy w Pythonie?
  8. Tablice wielowymiarowe w C ++ z przykładami
  9. Tablice 2D w PHP