Dalawang-dimensional na array

Isang lecture snippet na may mentor bilang bahagi ng kurso ng Codegym University. Mag-sign up para sa buong kurso.

"Pagbati, Amigo!"

"Hello, Rishi!"

"Alam mo na ang isa o dalawang bagay tungkol sa mga array, at nagawa mo pang malutas ang ilang mga gawain, umaasa ako. Ngunit hindi mo alam ang lahat. Halimbawa, narito ang isa pang kawili-wiling katotohanan tungkol sa mga array. Ang mga array ay hindi lamang isang-dimensional (linear). ). Maaari rin silang maging two-dimensional."

"Um... Anong ibig sabihin nito?"

"Ito ay nangangahulugan na ang mga cell ng array ay maaaring kumatawan hindi lamang sa isang column (o row), kundi pati na rin sa isang hugis-parihaba na talahanayan.

int[][]name = new int[width][height];

"Kung saan ang pangalan ay ang pangalan ng array variable, ang lapad ay ang lapad ng talahanayan (sa mga cell), at ang taas ay ang taas ng talahanayan. Tingnan ang isang halimbawa:

int[][] data = new int[2][5];
data[1][1] = 5;

"Ito ang magiging hitsura nito sa memorya:

"Nga pala, para sa mga two-dimensional na array, maaari mo ring gamitin ang mabilis na pagsisimula:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"Hmm... ngayon ay kawili-wili na. Kung akala natin na sa unang panloob na mga bracket ay kumakatawan sa isang elemento, ang susunod ay isang segundo... Kaya ang isang two-dimensional array ay parang array ng mga arrays?"

"Ang talino mong mag-aaral! Eksakto. Ang unang elemento ay ang one-dimensional array {31, 28, 31}, ang pangalawa ay {30, 31, 30}, at iba pa. Ngunit babalikan natin iyon sa ibang pagkakataon sa araling ito. Hanggang doon, subukang isipin ang isang two-dimensional array bilang isang table na may mga row at column, na bumubuo ng mga cell sa bawat intersection.

"I've got a mental picture of that. By the way, ano ang gamit nila, itong two-dimensional arrays?"

"Ang programmer ay nangangailangan ng mga two-dimensional arrays nang madalas. Kung titingnan mong mabuti, halos anumang board game ay ipinapatupad gamit ang isang off-the-shelf two-dimensional array: chess, checkers, tic-tac-toe, sea battle, atbp.:"

"Naiintindihan ko! Ang larangan ng chess o sea battle ay akmang-akma sa two-dimensional arrays!"

"Oo, ngunit kailangan mong gumamit ng mga numero bilang mga cell coordinates. Hindi 'pawn e2-e4', ngunit 'pawn (5,2) -> (5,4)'. Mas magiging madali para sa iyo bilang programmer. "

Pag-aayos ng mga elemento sa mga array: (x, y) o (y, x)

"Ang paggawa ng dalawang-dimensional na arrays ay nagpapataas ng isang kawili-wiling dilemma. Kapag gumawa tayo ng array gamit ang new int [2][5];, mayroon ba tayong talahanayan ng 'two row at 5 columns ' o ito ba ay 'two column at 5 row'?"

"Sa madaling salita, hindi lubos na malinaw kung una nating tinutukoy ang lapad at pagkatapos ay ang 'taas... o kabaliktaran, una ang taas at pagkatapos ay lapad?"

"Oo, ito ang dilemma. At walang tiyak na sagot."

"Anong gagawin?"

"Una, mahalagang maunawaan kung paano aktwal na nakaimbak ang ating two-dimensional array sa memorya . Natural, ang memorya ng computer ay walang aktwal na mga talahanayan dito: ang bawat lokasyon sa memorya ay may sequential numeric address: 0, 1, 2, ... Para sa amin, ito ay isang 2 × 5 na talahanayan, ngunit sa memorya ito ay 10 mga cell lamang, wala nang higit pa. Walang paghahati sa mga hilera at haligi."

"Naiintindihan ko iyon. Paano natin malalaman kung aling dimensyon ang mauna — ang lapad o ang taas?"

"Isaalang-alang natin ang unang opsyon. Una ang lapad, pagkatapos ay ang taas. "Ang argumento na pabor sa diskarte na ito ay ito: lahat ay natututo ng matematika sa paaralan, at nalaman nila na ang mga pares ng coordinate ay nakasulat bilang 'x' (iyon ay, ang horizontal axis) at pagkatapos ay 'y' (ang patayong dimensyon). At ito ay hindi lamang isang pamantayan ng paaralan — ito ay karaniwang tinatanggap na pamantayan sa matematika. Sabi nga nila, hindi ka pwedeng makipagtalo sa math."

"Ganun ba? Eh kung hindi natin kayang ipaglaban, una ang lapad tapos ang taas?"

"Mayroong isang kawili-wiling argumento na pabor sa 'taas muna, pagkatapos ay lapad' . Ang argumentong ito ay nagmumula sa mabilis na pagsisimula ng mga two-dimensional na array. Pagkatapos ng lahat, kung gusto nating simulan ang ating array, pagkatapos ay magsusulat tayo ng code na tulad nito:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"So ano ang ginagawa nito para sa atin?"

"May napansin ka ba? Paano kung meron tayo nito?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"Kung isusulat namin ang aming data sa linya ng code sa bawat linya, makakakuha kami ng isang talahanayan na may 2 hilera at 5 hanay."

"Ngayon nakikita ko na. 2 ang taas, at 5 ang lapad... So anong option ang dapat nating gamitin?"

"Nasa iyo na magpasya kung alin ang mas maginhawa. Ang pinakamahalagang bagay ay ang lahat ng mga programmer na nagtatrabaho sa parehong proyekto ay nananatili sa parehong diskarte."

"Kung nagtatrabaho ka sa isang proyekto na ang code ay may maraming nasimulang two-dimensional arrays, malamang na lahat ng bagay doon ay ibabatay sa mabilis na pagsisimula ng data, ibig sabihin, magkakaroon ka ng karaniwang 'taas x lapad'.

"Kung nakita mo ang iyong sarili sa isang proyekto na kinasasangkutan ng maraming matematika at nagtatrabaho sa mga coordinate (halimbawa, mga engine ng laro), malamang na ang code ay gagamitin ang diskarte na 'lapad x taas'.

Paano isinasaayos ang mga two-dimensional na array

"Ngayon, naaalala mo ba ang espesyal na tampok ng dalawang-dimensional na array na napansin mo sa simula ng aralin?"

"Oo! Ang dalawang-dimensional na array ay talagang mga arrays ng arrays!"

"Tama. "Sa madaling salita, kung sa kaso ng isang ordinaryong array ang array variable ay nag-iimbak ng reference sa isang lalagyan na nag-iimbak ng mga elemento ng array, kung gayon sa kaso ng dalawang-dimensional na array, ang sitwasyon ay sumasabog nang kaunti: isang two-dimensional -array variable ay nag-iimbak ng reference sa isang container na nag-iimbak ng mga reference sa isang-dimensional na array. Mas mainam na makita ito nang isang beses sa pagkilos kaysa subukang ipaliwanag ito ng isang daang beses:"

"Sa kaliwa , mayroon kaming two-dimensional-array variable, na nag-iimbak ng reference sa isang two-dimensional-array object. Sa gitna ay mayroong two-dimensional array object na ang mga cell ay nag-iimbak ng mga one-dimensional array, na kung saan ay ang mga row ng two-dimensional array. At sa kanan , makikita mo ang apat na one-dimensional arrays — ang mga row ng aming two-dimensional array. Ganito talaga gumagana ang two-dimensional arrays."

"Fantastic! Ngunit ano ang ibinibigay nito sa atin?"

"Dahil ang isang 'lalagyan ng mga lalagyan' ay nag-iimbak ng mga sanggunian sa 'mga hanay ng mga hilera', maaari tayong magpalit ng mga hilera nang napakabilis at madali. Upang makakuha ng isang 'lalagyan ng mga lalagyan', kailangan mo lang tumukoy ng isang index sa halip na dalawa. Halimbawa:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

"Tingnan ang code sa ibaba. Magagamit natin ito upang magpalit ng mga hilera:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"Got it. It works like swapping any two ordinary items."

"Kaya nga. Well, kung tinutukoy mo ang isang cell ng isang two-dimensional array, ngunit tinukoy mo lamang ang isang index pagkatapos ng pangalan ng array, kung gayon ang tinutukoy mo ay isang lalagyan ng mga lalagyan na ang mga cell ay nag-iimbak ng mga sanggunian sa ordinaryong isa- mga dimensional na array."

"Mukhang lohikal at malinaw ang lahat. Salamat sa lecture, Rishi!"

"You are welcome. Isagawa ito nang matalino."