Dalawang-dimensional na array

1. Dalawang-dimensional na array

Isa pang kawili-wiling katotohanan tungkol sa mga array. Ang mga array ay hindi lamang one-dimensional (linear). Maaari rin silang maging two-dimensional.

Ano ang ibig sabihin nito, tanong mo?

Nangangahulugan ito na ang mga cell ng array ay maaaring kumatawan hindi lamang sa isang column (o row), kundi pati na rin sa isang rectangular table.

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. Halimbawa:

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

Ganito ang magiging hitsura nito sa memorya:

Sa pamamagitan ng paraan, maaari mo ring gamitin ang mabilis na pagsisimula para sa mga two-dimensional na array:

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

Napakaraming lugar kung saan ikaw, bilang isang programmer, ay maaaring mangailangan ng two-dimensional array. Ang mga two-dimensional array ay ang pundasyon ng halos bawat board game, hal. chess, checkers, tic-tac-toe, at sea battle:

Ang mga two-dimensional array ay perpekto para sa chess o sea battle. Kailangan lang namin ng mga numero na bumubuo sa mga cell coordinates. Hindi 'pawn e2-e4', kundi 'pawn (5,2) -> (5,4)'. Ito ay magiging mas madali para sa iyo bilang isang programmer.

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

Sa pamamagitan ng paraan, mayroong isang kawili-wiling dilemma dito:

Kapag gumawa tayo ng array gamit ang new int[2][5];, mayroon ba tayong table ng 'two row and 5 columns ' o ito ba ay 'two column and 5 row '?" Sa madaling salita, una ba nating tinutukoy ang lapad at pagkatapos ay ang taas... o vice versa, una ang taas at pagkatapos ay ang lapad? Well, tulad ng madalas nating sabihin, ang lahat ay hindi gaanong simple dito.

Magsimula tayo sa tanong kung paano nakaimbak ang array sa memorya .

Siyempre, ang memorya ng computer ay walang aktwal na matrix dito: ang bawat lokasyon sa memorya ay may sequential numeric address: 0, 1, 2, ... Sa aming kaso, nagsasalita kami ng isang 2 × 5 matrix, ngunit sa memorya ito ay 10 magkakasunod na mga cell, wala nang iba pa. Walang nagsasaad kung nasaan ang mga row at column.

Argumentong pabor sa "lapad x taas".

Ang argumento na pabor sa diskarteng ito ay ito na ang lahat ay natututo ng matematika sa paaralan, kung saan nalaman nila na ang mga pares ng coordinate ay nakasulat bilang 'x' (iyon ay, ang pahalang na 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. Ganoon ba? Unang lapad at pagkatapos ay taas?

Argumentong pabor sa "taas x lapad".

Mayroon ding isang kawili-wiling argumento na gagawin para sa posisyong ito: mabilis na pagsisimula ng mga two-dimensional na array. Sa katunayan, kung gusto nating simulan ang ating array, maaari tayong magsulat ng code na tulad nito:

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

Wala ka bang napapansin? 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, pagkatapos ay makakakuha kami ng isang matrix na may 2 hilera at 5 haligi.

Bottom line

Ano ang masasabi natin? Ikaw ang bahalang magpasya kung alin ang mas maginhawa para sa iyo. 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 doon ay ibabatay sa mabilis na pagsisimula ng data, ibig sabihin, magkakaroon ka ng karaniwang 'taas x lapad'.

Kung ikaw ay sapat na mapalad na mahanap ang iyong sarili sa isang proyekto na kinasasangkutan ng maraming matematika at nagtatrabaho sa mga coordinate (halimbawa, mga makina ng laro), malamang na ang code ay gagamitin ang diskarte na 'width x height'.

3. Paano nakaayos ang mga two-dimensional array

At ngayon ay matututunan mo kung paano aktwal na nakaayos ang dalawang-dimensional na array. handa na?

Ang mga two-dimensional na array ay talagang mga array ng mga array!

Sa madaling salita, kung sa kaso ng isang ordinaryong array, ang array variable ay nag-iimbak ng reference sa isang container na nag-iimbak ng mga elemento ng array, kung gayon sa kaso ng two-dimensional arrays ang sitwasyon ay sumasabog nang kaunti: ang isang two-dimensional-array variable ay nag-iimbak ng isang reference sa isang container na nag-iimbak ng mga reference sa mga one-dimensional na array. Mas mainam na makita ito sa pagkilos nang isang beses 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 na bagay. Nasagitna mayroon kaming dalawang-dimensional na array object na ang mga cell ay nag-iimbak ng mga one-dimensional na array, na siyang mga row ng isang two-dimensional array. At sa kanan , makikita mo ang apat na one-dimensional na array — ang mga row ng aming two-dimensional array.

Ito ay kung paano gumagana ang dalawang-dimensional na array. At ang pamamaraang ito ay nagbibigay sa Java programmer ng ilang mga pakinabang:

Una , dahil ang isang 'lalagyan ng mga lalagyan' ay nag-iimbak ng mga sanggunian sa 'mga hanay ng mga hilera', napakabilis at madaling makapagpalit tayo ng mga hilera. Upang makakuha ng 'lalagyan ng mga lalagyan', kailangan mo lang tukuyin ang isang index sa halip na dalawa. Halimbawa:

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

Hinahayaan ka ng code na ito na magpalit ng mga row:

// 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}
};

Kung tinutukoy mo ang isang cell ng isang two-dimensional na array, ngunit isang index lang ang tinutukoy mo pagkatapos ng pangalan ng array, ang tinutukoy mo ay isang container ng mga container na ang mga cell ay nag-iimbak ng mga reference sa mga ordinaryong one-dimensional na array.