2D-massiivid C # -s - Põhjalik juhend CD-2-massiivide kohta

• Sissejuhatus CD-2-massiividesse

Sissejuhatus CD-2-massiividesse

Kahemõõtmelised massiivid on homogeensete elementide kogum, mis ulatub üle mitme rea ja veeru, eeldades maatriksi kuju. Allpool on toodud näide 2D-massiivist, millel on m rida ja n veergu, luues seega mxn-i konfiguratsiooni maatriksi.

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

Sakiliste massiivide kontseptsioon

Jagged massiiv on massiivide massiiv. Sakilised massiivid on põhimõtteliselt mitu massiivi, mis on mitmemõõtmelise massiivi moodustamiseks kokku sakitud. Kahemõõtmeline sakiline massiiv võib välja näha umbes selline:

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

Pange tähele, et kõik sakilise massiivi read võivad sisaldada sama arvu elemente või mitte.

Tõelised 2D massiivid vs sakilised massiivid

Jagged massiivid on rakendamise vaatenurgast täiesti erinevad kui tõeline 2D massiiv. Oluline on mõista, kuidas C # rakendab nii mitmemõõtmelisi kui ka sakilisi massiive.

Programmeerimiskeeled erinevad mitmemõõtmeliste massiivide rakendamisel. Mõned programmeerimiskeeled nagu C, C ++, C #, Fortran jne toetavad tõelisi 2D massiive. Kuigi on ka teisi, kes simuleerivad seda käitumist massiivide massiividega ehk sakiliste massiividega. Kuidas erineb tõeline kahemõõtmeline massiiv sakiliste massiividega?

Mitmemõõtmeliste massiivide kaks rakendust on salvestarbimise osas erinevad. Kui tõelises 2D-massiivis oleks m rida n elementi, siis sakilise massiivi korral võiks olla m rida, millel kõigil oleks erinev arv elemente. See viib andmekogude minimaalse raiskamiseni. Seega on allpool sakiliste massiividega kõik korras:

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

Kui sama andmekogum oleks rakendatud tõelises 2D-massiivis, oleks see toiminud järgmiselt:

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

Operatsioonid CD-2-massiividega

Allpool on toodud mõned toimingud 2D-massiividega:

1. Koostage C # 2D massiiv

Vaadakem viisi, kuidas kuulutada CD-s 2D-massiivi ja teist moodust, kuidas CD-s 2D-massiivi mitte kuulutada.

Kuidas?

2D-massiivi tõeline teostus C # -s algab massiivi deklaratsiooniga. See näeb välja järgmine:

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

Komade arv määratluses määrab massiivi mõõtme. Pange tähele, et massiivi deklaratsioonis ei saa massiivi suurust täpsustada. Seda tuleb teha massiivi initsialiseerimise ajal.

Kuidas mitte?

2D-massiivide ja sakiliste massiivide rakenduste vahel on lihtne segadusse minna. Sakiline massiivideklaratsioon näeb välja järgmine:

int()() jagged array;

2. Käivitage C # 2D massiiv

Järgmine samm on 2D-massiivi lähtestamine, mille me just kuulutasime. Selleks on mitu võimalust.

Uue operaatori kasutamine

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

Algatamine väärtustega

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

Ilma uue operaatorita

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

3. Lugege elemente C # 2D massiivist

Lugege üksikut elementi

Järgmine toiming on 2D-massiivi elementide lugemine. Kuna 2D-massiiv on mxn-i elementide maatriks, on igal elemendil määratud rea-indeksi ja veeru-indeksi kombinatsioon. Elementidele pääsete juurde, pakkudes alaindeksis rea- ja veeruindeksi. Allpool on näide:

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'

Märkus . Ridade ja veergude indeksid algavad nullist . Seega on indeksi positsioon (0, 0) esimene element ja (m-1, n-1) on massiivi viimane element.

Lugege kõiki elemente

Kuid ülaltoodud meetod annab meile massiivi ühe elemendi väärtuse. Kuidas läbida kogu massiiv, et lugeda selle iga elementi? Lihtne lahendus on silmus läbi kogu massiivi, kasutades silmustena pestud / samal ajal.

Kood

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äljund

GetLength () meetod

Okei. Kuid ülaltoodud näide töötab ainult siis, kui ma juba eelnevalt tean massiivi elementide arvu. Mis siis, kui minu massiiv on dünaamiline? Kuidas liikuda läbi kõigi dünaamilise massiivi elementide? Siin tuleb appi GetLengthi meetod.

int arr2D.GetLength (0); // tagastab esimese mõõtme (read)

int arr2D.GetLength (1); // tagastab teise mõõtme (veerud)

Kood

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äljund

Iga silmuse võimsus

Iga silmus täidab massiivi iga elemendi jaoks käskude komplekti. See on väga võimas silmusmehhanism ja seda on väga soovitatav kasutada, kuna see on tõhusam kui traditsiooniline silmuskonks.

Kood

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äljund

4. Sisestage elemendid C # 2D massiivi

Vaatame nüüd näidet elementide sisestamise kohta C # 2D massiivi. Idee on massiivi igast positsioonist mööda minemine ja sellele väärtuse määramine.

Kood

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äljund

5. Uuendage elemente C # 2D massiivis

Uuendame oma massiivi, korrutades iga elemendi kahega. Idee on liikuda massiivi igasse positsiooni ja värskendada selle väärtust.

Kood

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äljund

6. Kustutage elemendid C # 2D massiivist

See on keeruline toiming. Päris C # 2D massiivist pole võimalik üksikut elementi kustutada. Üksiku elemendi kustutamine häirib massiivi mõõtmeid nii, et see poleks enam maatriks. C # ei luba seda, kui see pole sakiline massiiv.

Mis on lahendus? Kas kustutame terve rea või kogu veeru? Ei, C # ei lubaks seda samuti. Massiivi suurus on deklareeritud või lähtestatud. Sellel on eraldatud mälu baitid. Me ei saa seda jooksval ajal muuta.

Lahendus on siin luua uus massiiv ilma elementideta, mida me kustutada tahame.

Kood

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äljund

Järeldus

Seega oleme näinud, kuidas CD-s rakendatakse 2D-massiivi ja milliseid erinevaid CRUD-toiminguid saame sellel teha. Samuti õppisime erinevust tõelise 2D-teostuse ja sakilise massiivi vahel. C #-s on saadaval palju rohkem meetodeid, mis aitavad arendajatel hõlpsalt massiividega töötada. Kontrollige neid MSDN-i dokumentidest.

Soovitatavad artiklid

See on juhend 2D-massiivide jaoks C # -s. Siin käsitleme sakiliste massiivide kontseptsiooni koos C # 2D-massiividega toimingutega. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -

1. 2D-massiivid Java-s
2. 2D-massiivid Pythonis
3. Massiivid C # -s
4. Massiivid C ++
5. Massiivid PHP-s
6. 2D graafika Java-s
7. Kuidas massiivid ja loendid Pythonis töötavad?
8. C ++ mitmemõõtmelised massiivid näidetega
9. 2D-massiivid PHP-s