Bevezetés a 2D tömbökbe a C # -ben
A kétdimenziós tömbök olyan homogén elemek gyűjteményét képezik, amelyek több soron és oszlopon átnyúlnak, feltételezve a mátrix formáját. Az alábbiakban egy példa egy 2D tömbre, amelyben m sor és n oszlop van, és így létrejön az mxn konfiguráció mátrixa.
( a1, a2, a3, a4, …, an
b1, b2, b3, b4, …, bn
c1, c2, c3, c4, …, cn
.
.
.
m1, m2, m3, m4, …, mn )
Koncepció az egyenetlen tömbök
A Jagged Array tömb tömb. Az osztott tömbök lényegében több tömb, amelyek egymáshoz illeszkedve egy többdimenziós tömböt alkotnak. A kétdimenziós egyenetlen tömb így néz ki:
( ( a1, a2, a3, a4, …, an ),
( b1, b2, b3, b4, …, b20 ),
( c1, c2, c3, c4, …, c30 ),
.
.
.
( m1, m2, m3, m4, …, m25 ) )
Vegye figyelembe, hogy az egyenetlen tömb minden sora tartalmazhat vagy nem tartalmazhat azonos számú elemet.
Valódi 2D tömbök és ütött tömbök
Az egyenetlen tömbök a megvalósítás szempontjából teljesen eltérnek a valódi 2D tömbtől. Fontos megérteni, hogy a C # hogyan valósítja meg mind a többdimenziós tömböket, mind pedig az osztott tömböket.
A programozási nyelvek különböznek a többdimenziós tömbök megvalósításában. Egyes programozási nyelvek, például a C, C ++, C #, Fortran stb. Támogatják az igaz 2D tömböket. Míg vannak olyanok, amelyek ezt a viselkedést tömbök tömbjeivel, más néven egyenetlen tömbökkel szimulálják. Tehát hogyan különbözik egy igazi kétdimenziós tömb az egyenetlen tömböktől?
A többdimenziós tömbök két megvalósítása eltér a tárolási fogyasztás szempontjából. Míg egy valódi 2D tömbben mindegyik n elem n sor lenne, az egyenetlen tömbben mindegyik m sor lehet, eltérő számú elemmel. Ez az adatkészletek minimális pazarlásához vezet. Így az alul eltöltött tömb tökéletes:
int()() jagged array = ( (1, 2, 3, 4),
(5, 6, 7),
(8, 9) )
Ha ugyanazt az adatkészletet valós 2D tömbben valósítanák meg, akkor az lenne az alábbiak szerint:
int(, ) multiDimArray = ( 1, 2, 3, 4
5, 6, 7, 0
8, 9, 0, 0 )
Műveletek a 2D-s tömbökkel a C # -ben
Az alábbiakban bemutatunk néhány műveletet a 2D-tömbökkel:
1. Készítse el a C # 2D tömböt
Nézzük meg, hogyan lehet egy 2D-tömböt deklarálni a C # -ben, és egy másik módszert arról, hogyan ne deklaráljuk a 2D-tömböt a C # -ben.
Hogyan kell?
A valódi 2D tömb megvalósítása a C # -ben a tömb deklarációval kezdődik. Az alábbiak szerint néz ki:
int(, ) arr2D;
string(, ) arr2D_s;
A meghatározásban szereplő vesszők száma határozza meg a tömb méretét. Vegye figyelembe, hogy a tömb deklarációjában nem adhatja meg a tömb méretét. Ezt egy tömb inicializálásakor kell megtenni.
Hogyan nem?
Könnyű összekeverni a 2D-tömbök és az egyenetlen tömbök megvalósítását. Az egyenetlen tömb deklaráció az alábbiak szerint néz ki:
int()() jagged array;
2. Inicializálja a C # 2D tömböt
A következő lépés az éppen bejelentett 2D tömb inicializálása. Ennek többféle módja van.
Az új operátor használata
arr2D = new int(2, 3); //separate initialization
string(, ) arr2D_s = new string(4, 5); //with declaration
Inicializálás értékekkel
//without dimensions
arr2D = new int(, )((1, 2), (3, 4), (5, 6));
//with declaration
arr2D_s = new string(2, 2)((“one”, ”two”), (“three”, “four”));
Az új üzemeltető nélkül
Int(, ) arr2D_a = ((1, 2), (3, 4), (5, 6), (7, 8));
3. Olvassa el az Elemeket a C # 2D tömbből
Olvassa el egyetlen elemet
A következő művelet az, hogy elolvassa a 2D tömb elemeit. Mivel a 2D tömb az mxn elemek mátrixa, minden elem rendelkezik egy kijelölt sorindex és oszlopindex kombinációval. Az elemekhez úgy érhetjük el, hogy a sorindexet és az oszlopindexet megadjuk az alindexben. Az alábbiakban bemutatunk egy példát:
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'
Olvassa el az összes elemet
A fenti módszer megadja a tömb egyetlen elemének értékét. Hogyan áthúzzuk az egész tömböt, hogy olvassa el annak minden elemét? Az egyszerű megoldás az, hogy a teljes tömbön keresztül hurkolnak egymásba ágyazott hurkok segítségével.
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");
)
)
)
Kimenet
A GetLength () módszer
Oké. A fenti példa azonban csak akkor működik, ha előzetesen ismerem a tömb elemeinek számát. Mi van, ha a tömböm dinamikus? Hogyan lehet átjárni a dinamikus tömb összes elemét? Itt jön a GetLength módszer a megmentésre.
int arr2D.GetLength (0); // visszaadja az első dimenziót (sorok)
int arr2D.GetLength (1); // a második dimenziót adja vissza (oszlopok)
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");
)
)
)
Kimenet
Az egyes hurkok ereje
Az egyes hurkok a tömb minden elemére parancskészletet hajtanak végre. Ez egy nagyon erős hurkoló mechanizmus, és erősen ajánlott használni, mivel hatékonyabb, mint a hagyományos hurok.
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);
)
)
)
Kimenet
4. Helyezze be az elemeket a C # 2D tömbbe
Most nézzük meg egy példát az elemek beszúrására a C # 2D tömbbe. Az ötlet az, hogy áthalad a tömb minden pozíciójában, és értéket rendel hozzá.
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");
)
)
)
Kimenet
5. Frissítse az elemeket a C # 2D tömbben
Frissítjük a tömbünket, hogy megszorozzuk az egyes elemeket 2-gyel. Az ötlet az, hogy a tömb minden pozícióját áthaladjuk, és frissítsük a benne lévő értéket.
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");
)
)
)
Kimenet
6. Törölje az elemeket a C # 2D tömbből
Ez egy trükkös művelet. Nem lehet egyetlen elemet törölni a valódi C # 2D tömbből. Egy elem törlése megzavarja a tömb dimenzióit, így az már nem lenne mátrix. A C # ezt nem engedélyezi, kivéve, ha egyenetlen tömb.
Szóval, mi a megoldás? Töröljük az egész sort vagy az egész oszlopot? Nem, a C # ezt nem is engedné. A tömb méretét rögzítik, amikor deklarálják vagy inicializálják. A memória fix bájtjai vannak hozzárendelve. Ezt futási időben nem változtathatjuk meg.
A megoldás itt egy új tömb létrehozása a törölni kívánt elemek nélkül.
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");
)
)
)
Kimenet
Következtetés
Így láttuk, hogy a 2D tömb hogyan valósul meg a C # -ben, és milyen különféle CRUD műveleteket hajthatunk végre rajta. Megtudtuk a különbséget a valódi 2D megvalósítás és az egyenetlen tömb között is. A C #-ben sokkal több módszer áll rendelkezésre, amelyek segítenek a fejlesztőknek az Arrays-szal való könnyű munkában. Nézze meg őket az MSDN dokumentumokban.
Ajánlott cikkek
Ez egy útmutató a 2 # tömbökhöz a C # -ben. Itt tárgyaljuk az egyenetlen tömbök koncepcióját és a C # 2D-tömbökkel végzett műveleteket. A következő cikkeket is megnézheti további információkért -
- 2D tömbök Java-ban
- 2D tömbök a Pythonban
- Tömbök C # -ben
- Tömbök C ++-ban
- Tömbök a PHP-ben
- 2D grafika Java-ban
- Hogyan működnek a tömbök és a listák a Pythonban?
- Többdimenziós tömbök C ++-ban példákkal
- 2D tömbök a PHP-ben