Masīvs ir datu struktūras veids, ko izmanto, lai saglabātu viena un tā paša datu tipa vienumu kolekciju, kas atrodas blakus esošās atmiņas vietās. Masīvi var būt viendimensionāli vai daudzdimensionāli, pamatojoties uz virzienu skaitu, kuros masīvs var augt. Šajā rakstā mēs pētīsim daudzdimensiju masīvus, piemēram, divdimensiju masīvus un trīsdimensiju masīvus.
Kas ir daudzdimensiju masīvs programmā C++?
Daudzdimensiju masīvs ir masīvs ar vairāk nekā vienu dimensiju. Tā ir viendabīga vienumu kolekcija, kurā katram elementam var piekļūt, izmantojot vairākus rādītājus.
Daudzdimensiju masīva deklarācija
datatype arrayName [ size1][size2]...[sizeN];>
kur,
- datu tips: Masīvā glabājamo datu veids.
- masīva nosaukums: Masīva nosaukums.
- izmērs1, izmērs2,…, izmērsN: Katras dimensijas izmērs.
Piemērs:
Two dimensional array: int two_d[2][4]; Three dimensional array: int three_d[2][4][8];>
Daudzdimensiju masīva lielums
Masīva lielums ir vienāds ar datu tipa lielumu, kas reizināts ar kopējo elementu skaitu, ko var saglabāt masīvā. Mēs varam aprēķināt kopējo elementu skaitu masīvā, reizinot daudzdimensiju masīva katras dimensijas lielumu.
Piemēram:
int arr1[2][4];>
- Masīva int arr1[2][4] var uzglabāt kopā (2*4) = 8 elementi.
- C++ int datu tips aizņem 4 baitus, un masīvā ir 8 elementi 'arr1' no int veida.
- Kopējais izmērs = 4*8 = 32 baiti .
int arr2[2][4][8];>
- Masīva starpt arr2[2][4][8] var uzglabāt kopā (2*4*8) = 64 elementi.
- Kopējais izmērs arr2 ' = 64*4 = 256 baiti .
Lai pārbaudītu iepriekš minēto aprēķinu, mēs varam izmantot izmērs() metode masīva lieluma noteikšanai.
C++
// C++ program to verify the size of multidimensional> // arrays> #include> using> namespace> std;> > int> main()> {> >// creating 2d and 3d array> >int> arr1[2][4];> >int> arr2[2][4][8];> > >// using sizeof() operator to get the size of the above> >// arrays> >cout <<>'Size of array arr1: '> <<>sizeof>(arr1)> ><<>' bytes'> << endl;> >cout <<>'Size of array arr2: '> <<>sizeof>(arr2)> ><<>' bytes'>;> > >return> 0;> }> |
>
>Izvade
java cilpai
Size of array arr1: 32 bytes Size of array arr2: 256 bytes>
Visplašāk izmantotie daudzdimensiju masīvi ir:
- Divdimensiju masīvs
- Trīsdimensiju masīvs
Divdimensiju masīvs (vai 2D masīvs)
Divdimensiju masīvs C++ ir elementu kolekcija, kas sakārtota rindās un kolonnās. To var vizualizēt kā tabulu vai režģi, kur katram elementam var piekļūt, izmantojot divus indeksus: vienu rindai un vienu kolonnai. Tāpat kā viendimensijas masīvam, arī divdimensiju masīva indeksi svārstās no 0 līdz n-1 gan rindām, gan kolonnām.
2D masīva sintakse
datu_tips masīva_nosaukums[ n ][ m ];
kur,
- n: Rindu skaits.
- m: Kolonnu skaits.
Mēs varam deklarēt 2D masīvu statiski un dinamiski. Statiskajā deklarācijā atmiņa tiek piešķirta kompilēšanas laikā, bet dinamiskajā atmiņa tiek piešķirta izpildlaikā. Iepriekš minētā ir 2D masīva statiskās deklarācijas sintakse. Lai uzzinātu, kā dinamiski deklarēt 2D masīvu, skatiet šis rakstu.
Divdimensiju masīvu inicializācija programmā C++
Tālāk ir norādīti dažādi veidi, kā inicializēt 2D masīvu:
- Inicializētāju saraksta izmantošana
- Izmantojot cilpas
1. Inicializējiet 2D masīvu, izmantojot sarakstu Initializer
Mēs varam inicializēt 2D masīvu, izmantojot inicializētāju sarakstu divos veidos. Tālāk ir sniegta pirmā metode, kā inicializēt 2D masīvu, izmantojot inicializētāju sarakstu.
Pirmā metode: Zemāk esošajā masīvā ir 2 rindas un 4 kolonnas. Elementi tiek aizpildīti tā, ka pirmie 4 elementi tiek aizpildīti pirmajā rindā un nākamie 4 elementi tiek aizpildīti otrajā rindā.
int arr[2][4] = {0, 1, 2, 3, 4, 5, 6, 7};> Otrā metode: Tālāk norādītais veids ir tīrāks veids, kā inicializēt 2D masīvu, jo ligzdotais saraksts attēlo elementus rindā, un tajā esošo elementu skaits ir vienāds ar kolonnu skaitu 2D masīvā. Ligzdoto sarakstu skaits norāda kolonnu skaitu.
int x[2][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}};> 2. 2D masīva inicializācija, izmantojot cilpas
Mēs varam arī inicializēt 2D masīvu, izmantojot cilpas. Lai inicializētu 2D masīvu, mums ir jāizmanto divas ligzdotas cilpas, un ligzdotās cilpas ir vienādas ar izmēru. Piemēram, lai inicializētu 3D masīvu, mums ir jāizmanto trīs ligzdotas cilpas. Apskatīsim piemēru.
Piemērs: Tālāk esošajā piemērā mēs inicializējām 2D masīvu ar 1. Ārējā cilpa tiek izmantota, lai izsekotu rindas i=0 nozīmē pirmo rindu, jo 0 indeksē līdzīgi j=0 nozīmē pirmo kolonnu un apvieno šo x [0][0] apzīmē pirmo 2D masīva šūnu.
int x[2][4]; for(int i = 0; i <2; i++){ for(int j = 0; j <4; j++){ x[i][j] = 1; } }> Piekļuve divdimensiju masīvu elementiem programmā C++
Mēs varam piekļūt 2-dimensiju masīva elementiem, izmantojot rindu un kolonnu indeksus. Tas ir līdzīgs matricas elementa pozīcijai, taču vienīgā atšķirība ir tā, ka šeit indeksēšana sākas no 0.
Sintakse:
ir īpašs raksturs
array_name[i][j];>
kur,
- es: Rindas rādītājs.
- j: Kolonnas rādītājs.
Piemērs: Zemāk ir otrās rindas un trešās kolonnas elementu rādītājs.
int x[1][2];>
Sapratīsim to, izmantojot kodu, drukājot 2D masīva elementus.
2D masīva piemērs
C++
// c++ program to illustrate the two dimensional array> #include> using> namespace> std;> > int> main()> {> > >int> count = 1;> > >// Declaring 2D array> >int> array1[3][4];> > >// Initialize 2D array using loop> >for> (>int> i = 0; i <3; i++) {> >for> (>int> j = 0; j <4; j++) {> >array1[i][j] = count;> >count++;> >}> >}> > >// Printing the element of 2D array> >for> (>int> i = 0; i <3; i++) {> >for> (>int> j = 0; j <4; j++) {> >cout << array1[i][j] <<>' '>;> >}> >cout << endl;> >}> > >return> 0;> }> |
>
>Izvade
1 2 3 4 5 6 7 8 9 10 11 12>
Paskaidrojums: Iepriekš minētajā kodā mēs esam inicializējuši skaitīšanu ar “1” un deklarējuši 2D masīvu ar 3 rindām un 4 kolonnām, pēc tam mēs inicializējām masīvu ar skaitīšanas vērtību un skaitīšanas pieauguma vērtību katrā cilpas iterācijā. Pēc tam mēs izdrukājam 2D masīvu, izmantojot ligzdotu cilpu, un tālāk redzamajā izvadā redzam, ka tajā ir 3 rindas un 4 kolonnas.
Laika sarežģītība: O(n*m)
Kosmosa sarežģītība: O(n*m)
kur n ir rindu skaits un m ir kolonnu skaits.
Trīsdimensiju masīvs C++ valodā
3D masīvs ir datu struktūra, kas glabā elementus trīsdimensiju kubveida struktūrā. To var vizualizēt kā vairāku divdimensiju masīvu kolekciju, kas sakrautas viens virs otra. Katrs 3D masīva elements tiek identificēts pēc tā trim indeksiem: rindas indekss, kolonnas indekss un dziļuma indekss.
Trīsdimensiju masīva deklarācija C++ valodā
Lai deklarētu 3D masīvu programmā C++, mums ir jānorāda tā trešā dimensija kopā ar 2D izmēriem.
Sintakse:
dataType arrayName[d][r];>
- datu tips: Katrā elementā glabājamo datu veids.
- masīva nosaukums: Masīva nosaukums
- d: 2D masīvu skaits vai masīva dziļums.
- r: Rindu skaits katrā 2D masīvā.
- c: Kolonnu skaits katrā 2D masīvā.
Piemērs:
int array[3][5][2];>
Trīsdimensiju masīva inicializācija programmā C++
Lai inicializētu 3D masīvu programmā C++, mēs izmantojam tās pašas metodes, kuras izmantojām, lai inicializētu 2D masīvu. 3D masīvā mums ir vēl viena dimensija, tāpēc mums ir jāpievieno vēl viens ligzdots elementu saraksts.
3D masīvu formātā C var inicializēt, izmantojot:
- Inicializētāju saraksts
- Cilpas
3D masīva inicializācija, izmantojot inicializētāju sarakstu
1. metode: Izmantojot šo metodi, mums ir jāieraksta kopējais elementu skaits cirtainajās iekavās, un katrs vienums tiek novietots savā vietā atbilstoši norādītajam izmēram.
int x[3][5][2] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30};> 2. metode (labāka) : Izmantojot šo metodi, elementi ir sadalīti, izmantojot ligzdotus sarakstus, un to ir viegli lasīt.
int x[3][5][2] = { { {0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9} } , { {10, 11}, {12, 13}, {14, 15}, {16, 17}, {18, 19} } , { {20, 21}, {22, 23}, {24, 25}, {26, 27}, {28, 30} } , } ;> 3D masīva inicializācija, izmantojot cilpas
Šī metode ir tāda pati kā 2D masīva inicializācija, izmantojot cilpas ar vēl vienu ligzdotu cilpu trešajai dimensijai.
int x[3][5][2]; for (int i = 0; i <3; i++) { for (int j = 0; j <5; j++) { for (int k = 0; k <2; k++) { x[i][j][k] = (some_value) ; } } }> Piekļuve elementiem trīsdimensiju masīvā programmā C++
Piekļuve elementiem 3D masīvos ir tikpat vienkārša kā piekļuve elementiem 2D masīvos. Šeit mums ir jāveic papildu darbs, lai pievienotu vēl vienu ligzdotu cilpu, lai sekotu līdzi trešajai dimensijai.
C++
// C++ program to illustrate the 3d array> #include> using> namespace> std;> > int> main()> {> > >int> count = 0;> >// declaring 3d array> >int> x[2][2][3];> > >// initializing the array> >for> (>int> i = 0; i <2; i++) {> >for> (>int> j = 0; j <2; j++) {> >for> (>int> k = 0; k <3; k++) {> >x[i][j][k] = count;> >count++;> >}> >}> >}> > >// printing the array> >for> (>int> i = 0; i <2; i++) {> >for> (>int> j = 0; j <2; j++) {> >for> (>int> k = 0; k <3; k++) {> >printf>(>'x[%d][%d][%d] = %d
'>, i, j, k,> >x[i][j][k]);> >count++;> >}> >}> >}> > >return> 0;> }> |
>
>Izvade
execvp
x[0][0][0] = 0 x[0][0][1] = 1 x[0][0][2] = 2 x[0][1][0] = 3 x[0][1][1] = 4 x[0][1][2] = 5 x[1][0][0] = 6 x[1][0][1] = 7 x[1][0][2] = 8 x[1][1][0] = 9 x[1][1][1] = 10 x[1][1][2] = 11>
Paskaidrojums: Iepriekš minētajā kodā mēs esam inicializējuši 3D masīvu, izmantojot cilpu, kā paskaidrots iepriekš, ar skaitli no 0 līdz 7, izmantojot skaitīšanas mainīgo, un pēc tam piekļūstot elementiem, izmantojot to pašu cilpu, ko izmantoja 3D masīva inicializēšanai. Vienīgā atšķirība ir tā, ka tā vietā, lai piešķirtu elementu noteiktā pozīcijā, sakiet x[0][0][1]=1 mēs drukājam šajā vietā saglabāto elementu, kā redzams tālāk esošajā izvadā.