Tatasusunan dua dimensi

1. Tatasusunan dua dimensi

Satu lagi fakta menarik tentang tatasusunan. Tatasusunan bukan sahaja satu dimensi (linear). Mereka juga boleh menjadi dua dimensi.

Apakah maksudnya, anda bertanya?

Ini bermakna bahawa sel tatasusunan boleh mewakili bukan sahaja lajur (atau baris), tetapi juga jadual segi empat tepat.

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

Di mana nama ialah nama pembolehubah tatasusunan, lebar ialah lebar jadual (dalam sel), dan ketinggian ialah ketinggian jadual. Contoh:

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

Ini adalah bagaimana ia akan kelihatan dalam ingatan:

Dengan cara ini, anda juga boleh menggunakan pemulaan pantas untuk tatasusunan dua dimensi:

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

Terdapat begitu banyak tempat di mana anda, sebagai pengaturcara, mungkin memerlukan tatasusunan dua dimensi. Tatasusunan dua dimensi ialah asas kepada hampir setiap permainan papan, contohnya catur, dam, tic-tac-toe dan pertempuran laut:

Tatasusunan dua dimensi adalah sesuai untuk catur atau pertempuran laut. Kami hanya memerlukan nombor daripada koordinat sel. Bukan 'gadai e2-e4', tetapi 'gadai (5,2) -> (5,4)'. Ia akan menjadi lebih mudah untuk anda sebagai pengaturcara.

2. Menyusun elemen dalam tatasusunan: (x, y) atau (y, x)

Ngomong-ngomong, terdapat dilema yang menarik di sini:

Apabila kita mencipta tatasusunan menggunakan new int[2][5];, adakah kita mempunyai jadual 'dua baris dan 5 lajur ' atau adakah ia 'dua lajur dan 5 baris '?" Dengan kata lain, adakah kita mula-mula menentukan lebar dan kemudian ketinggian... atau sebaliknya, pertama ketinggian dan kemudian lebar? Nah, seperti yang sering kita katakan, semuanya tidak begitu mudah di sini.

Mari kita mulakan dengan persoalan bagaimana tatasusunan disimpan dalam ingatan .

Sudah tentu, memori komputer sebenarnya tidak mempunyai matriks di dalamnya: setiap lokasi dalam ingatan mempunyai alamat berangka berjujukan: 0, 1, 2, ... Dalam kes kami, kami bercakap tentang matriks 2 × 5, tetapi dalam ingatan ia hanya 10 sel berturut-turut, tidak lebih. Tiada apa-apa yang menunjukkan di mana baris dan lajur berada.

Hujah yang menyokong "lebar x tinggi".

Hujah yang menyokong pendekatan ini ialah semua orang belajar matematik di sekolah, di mana mereka belajar bahawa pasangan koordinat ditulis sebagai 'x' (iaitu, paksi mendatar) dan kemudian 'y' (dimensi menegak). Dan ini bukan sekadar standard sekolah — ia adalah piawaian yang diterima umum dalam matematik. Seperti yang mereka katakan, anda tidak boleh berdebat dengan matematik. Adakah begitu? Lebar pertama dan kemudian tinggi?

Hujah yang memihak kepada "tinggi x lebar".

Terdapat juga hujah yang menarik untuk dibuat untuk kedudukan ini: permulaan pantas tatasusunan dua dimensi. Sesungguhnya, jika kita ingin memulakan tatasusunan kita, maka kita boleh menulis kod seperti ini:

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

Adakah anda tidak perasan apa-apa? Bagaimana jika kita mempunyai ini?

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

Jika kita menulis data kita dalam kod baris demi baris, maka kita mendapat matriks dengan 2 baris dan 5 lajur.

Pokoknya

Apa yang boleh kita katakan? Terpulang kepada anda untuk memutuskan mana yang lebih sesuai untuk anda. Perkara yang paling penting ialah semua pengaturcara yang bekerja pada projek yang sama berpegang pada pendekatan yang sama.

Jika anda mengusahakan projek yang kodnya mempunyai banyak tatasusunan dua dimensi yang dimulakan, maka kemungkinan besar segala-galanya akan berdasarkan pada permulaan data yang pantas, iaitu anda akan mempunyai 'tinggi x lebar' standard.

Jika anda cukup bernasib baik kerana mendapati diri anda dalam projek yang melibatkan banyak matematik dan bekerja dengan koordinat (contohnya, enjin permainan), maka kod tersebut berkemungkinan besar akan menggunakan pendekatan 'lebar x tinggi'.

3. Bagaimana tatasusunan dua dimensi disusun

Dan kini anda akan belajar bagaimana tatasusunan dua dimensi sebenarnya disusun. sedia?

Tatasusunan dua dimensi sebenarnya ialah tatasusunan tatasusunan!

Dalam erti kata lain, jika dalam kes tatasusunan biasa pembolehubah tatasusunan menyimpan rujukan kepada bekas yang menyimpan elemen tatasusunan, maka dalam kes tatasusunan dua dimensi keadaan meletup sedikit: pembolehubah tatasusunan dua dimensi menyimpan satu rujukan kepada bekas yang menyimpan rujukan kepada tatasusunan satu dimensi. Adalah lebih baik untuk melihatnya dalam tindakan sekali daripada cuba menerangkannya seratus kali:

Di sebelah kiri , kami mempunyai pembolehubah tatasusunan dua dimensi, yang menyimpan rujukan kepada objek tatasusunan dua dimensi. Di dalamtengah kita mempunyai objek tatasusunan dua dimensi yang selnya menyimpan tatasusunan satu dimensi, yang merupakan baris tatasusunan dua dimensi. Dan di sebelah kanan , anda boleh melihat empat tatasusunan satu dimensi — baris tatasusunan dua dimensi kami.

Inilah cara tatasusunan dua dimensi sebenarnya berfungsi. Dan pendekatan ini memberikan beberapa kelebihan kepada pengaturcara Java:

Pertama , kerana 'bekas bekas' menyimpan rujukan kepada 'tatasusunan baris', kita boleh menukar baris dengan cepat dan mudah. Untuk mendapatkan 'bekas bekas', anda hanya perlu menentukan satu indeks dan bukannya dua. Contoh:

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

Kod ini membolehkan anda menukar baris:

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

Jika anda merujuk kepada sel tatasusunan dua dimensi, tetapi anda hanya menentukan satu indeks selepas nama tatasusunan, maka anda merujuk kepada bekas bekas yang selnya menyimpan rujukan kepada tatasusunan satu dimensi biasa.