Úvod do 2D polí v C #
Dvourozměrná pole jsou souborem homogenních prvků, které se rozprostírají přes více řádků a sloupců, přičemž předpokládají formu matice. Níže je uveden příklad 2D pole, které má řádky m a sloupce n, čímž se vytváří matice konfigurace mxn.
( a1, a2, a3, a4, …, an
b1, b2, b3, b4, …, bn
c1, c2, c3, c4, …, cn
.
.
.
m1, m2, m3, m4, …, mn )
Koncept Jagged Arrays
Jagged Array je řada polí. Zoubkovaná pole jsou v podstatě vícenásobná pole zoubkovaná dohromady, aby vytvořila vícerozměrné pole. Dvourozměrné zubaté pole může vypadat asi takto:
( ( a1, a2, a3, a4, …, an ),
( b1, b2, b3, b4, …, b20 ),
( c1, c2, c3, c4, …, c30 ),
.
.
.
( m1, m2, m3, m4, …, m25 ) )
Všimněte si, že všechny řádky zubatého pole mohou nebo nemusí obsahovat stejný počet prvků.
True 2D Arrays vs Jagged Arrays
Jagged Arrays jsou z pohledu implementace úplně odlišná od skutečného 2D pole. Je důležité pochopit, jak C # implementuje jak vícerozměrná pole, tak i zubatá pole.
Programovací jazyky se liší implementací vícerozměrných polí. Některé programovací jazyky jako C, C ++, C #, Fortran atd. Podporují skutečné 2D pole. Zatímco existují jiní, kteří simulují toto chování s poli matic, známými jako zubatá pole. Jak se tedy skutečné dvojrozměrné pole liší od zubatých polí?
Obě implementace vícerozměrných polí se liší z hlediska spotřeby úložiště. Zatímco skutečné 2D pole by mělo každý řádek m prvků n, členité pole by mohlo mít řádky m, z nichž každý by měl různé počty prvků. To vede k minimálnímu plýtvání prostorem pro soubory dat. Takže níže rozčleněné pole je naprosto v pořádku:
int()() jagged array = ( (1, 2, 3, 4),
(5, 6, 7),
(8, 9) )
Pokud by stejná sada dat byla implementována do skutečného 2D pole, bylo by to takto:
int(, ) multiDimArray = ( 1, 2, 3, 4
5, 6, 7, 0
8, 9, 0, 0 )
Operace na 2D polích v C #
Zde jsou uvedeny některé operace na 2D polích uvedené níže:
1. Vytvořte pole C # 2D
Podívejme se na to, jak deklarovat 2D pole v C # a další na to, jak deklarovat 2D pole v C #.
Jak?
Skutečná implementace 2D pole v C # začíná deklarací Array. Vypadá to takto:
int(, ) arr2D;
string(, ) arr2D_s;
Počet čár v definici určuje rozměr pole. Všimněte si, že v deklaraci pole nelze určit velikost pole. Musí se to provést během inicializace pole.
Jak to udělat?
Je snadné se zaměnit mezi implementacemi 2D polí a zubatými poli. Prohlášení o zubaté matici vypadá takto:
int()() jagged array;
2. Inicializujte pole C # 2D
Dalším krokem je inicializace 2D pole, které jsme právě deklarovali. Existuje několik způsobů, jak toho dosáhnout.
Používání nového operátora
arr2D = new int(2, 3); //separate initialization
string(, ) arr2D_s = new string(4, 5); //with declaration
Inicializace pomocí hodnot
//without dimensions
arr2D = new int(, )((1, 2), (3, 4), (5, 6));
//with declaration
arr2D_s = new string(2, 2)((“one”, ”two”), (“three”, “four”));
Bez nového operátora
Int(, ) arr2D_a = ((1, 2), (3, 4), (5, 6), (7, 8));
3. Čtěte prvky z pole C # 2D
Přečtěte si jeden prvek
Další operací je načtení prvků z 2D pole. Protože 2D pole je matice prvků mxn, má každý prvek určenou kombinaci řádek-index a sloupec-index. K elementům můžeme přistupovat poskytnutím indexu řádků a sloupců v indexu. Příklad je níže:
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'
Přečtěte si všechny prvky
Výše uvedená metoda nám však dává hodnotu jednoho prvku v poli. Jak procházíme celé pole, abychom si přečetli každý jeho prvek? Jednoduché řešení je opakování celého pole pomocí vnořených smyček pro / while.
Kód
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");
)
)
)
Výstup
Metoda GetLength ()
Dobře. Výše uvedený příklad však funguje pouze tehdy, když předem znám počet prvků v poli. Co když je moje pole dynamické? Jak procházím všechny prvky dynamického pole? Zde přichází metoda GetLength k naší záchraně.
int arr2D.GetLength (0); // vrací první dimenzi (řádky)
int arr2D.GetLength (1); // vrací druhou dimenzi (sloupce)
Kód
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");
)
)
)
Výstup
Síla pro každou smyčku
Smyčka for-each vykonává sadu příkazů pro každý prvek pole. Toto je velmi silný smyčkový mechanismus a je vysoce doporučeno jej používat, protože je účinnější než tradiční smyčka.
Kód
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);
)
)
)
Výstup
4. Vložte prvky do pole C # 2D
Nyní uvidíme příklad, jak vložit prvky do pole C # 2D. Cílem je projít každou pozici pole a přiřadit jí hodnotu.
Kód
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");
)
)
)
Výstup
5. Aktualizujte prvky v poli C # 2D
Aktualizujeme naše pole tak, aby se každý prvek znásobil 2. Myšlenkou je projít každou pozici pole a aktualizovat hodnotu, kterou má.
Kód
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");
)
)
)
Výstup
6. Odstraňte prvky v poli C # 2D
To je složitá operace. Není možné odstranit jediný prvek ze skutečného pole C # 2D. Odstranění jediného prvku naruší rozměry pole tak, že už nebude maticí. C # to neumožňuje, pokud se nejedná o zubaté pole.
Jaké je tedy řešení? Vymažeme celý řádek nebo celý sloupec? Ne, C # to také nedovolí. Při deklarování nebo inicializaci pole je velikost pevné. Má pevné bajty paměti přidělené. To nemůžeme změnit za běhu.
Řešením je vytvoření nového pole bez prvků, které chceme odstranit.
Kód
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");
)
)
)
Výstup
Závěr
Viděli jsme tedy, jak je 2D pole implementováno v C # a jaké jsou různé operace CRUD, které na něm můžeme provádět. Také jsme se dozvěděli rozdíl mezi skutečnou 2D implementací a zubatým polem. V C # je k dispozici mnohem více metod, které vývojářům usnadní práci s poli v pohodě. Zkontrolujte je v dokumentech MSDN.
Doporučené články
Toto je průvodce 2D poli v C #. Zde diskutujeme koncept zubatých polí spolu s operacemi na 2D polích v C #. Další informace naleznete také v následujících článcích
- 2D pole v Javě
- 2D pole v Pythonu
- Pole v C #
- Pole v C ++
- Pole v PHP
- 2D grafika v Javě
- Jak fungují pole a seznamy v Pythonu?
- Vícerozměrná pole v C ++ s příklady
- 2D pole v PHP