İki boyutlu diziler (2D arrays)

Bazı veriler doğal olarak tablo şeklindedir: bir sınıfın her öğrencisinin her sınavdaki notu, satranç tahtası, sinema salonundaki koltuklar, bir matris. Java’da bunun için iki boyutlu dizi (two-dimensional array) kullanılır. Yeni bir kavram az, ama 1D dizideki kuralları iki indeksle birlikte doğru uygulamak gerekir. Sınavda tipik soru: “bu iç içe döngü 2D diziyi gezince ne basar?” ve “satır/sütun toplamını döndüren metot yaz”.

Altın kurallar:

1. m[r][c]: önce satır (row), sonra sütun (column).
2. m.length satır sayısı, m[r].length o satırın sütun sayısı.
3. Dış döngü satır, iç döngü sütun (satır satır gezinme, row-major).
4. 2D dizi, dizilerin dizisidir. m[r] başlı başına bir 1D dizi.
5. Sütun sınırında sabit sayı değil m[r].length yaz. Düzensiz dizilerde de doğru çalışır.

Oluşturma

int[][] grid = new int[3][4];        // 3 satır, 4 sütun, hepsi 0
grid[0][1] = 5;
grid[2][3] = 9;
System.out.println(grid.length + " " + grid[0].length + " " + grid[0][1] + " " + grid[1][1]);

3 4 5 0

          sütun 0   sütun 1   sütun 2   sütun 3
satır 0      0         5         0         0
satır 1      0         0         0         0
satır 2      0         0         0         9

Değerleri baştan biliyorsan başlangıç listesi: her iç süslü parantez bir satır.

int[][] m = {
    {1, 2, 3},
    {4, 5, 6}
};

Gezinme ve yazdırma

for (int r = 0; r < m.length; r++) {
    for (int c = 0; c < m[r].length; c++) {
        System.out.print(m[r][c] + " ");
    }
    System.out.println();               // satır bitti
}
System.out.println(m[1][0] + " " + m[0][2] + " " + m.length + " " + m[1].length);
System.out.println(Arrays.toString(m[1]));
System.out.println(Arrays.deepToString(m));

1 2 3 
4 5 6 
4 3 2 3
[4, 5, 6]
[[1, 2, 3], [4, 5, 6]]

m[1] ikinci satırın tamamı, yani {4, 5, 6} dizisi; bu yüzden Arrays.toString(m[1]) çalışıyor. Bütün tabloyu tek satırda görmek için Arrays.deepToString.

Hizalı bir tablo için printf genişliği kullan:

for (int[] row : m) {
    for (int v : row) System.out.printf("%4d", v * 10);
    System.out.println();
}

  10  20  30
  40  50  60

Enhanced for iç içe de kullanılır: dıştaki değişkenin tipi int[] (bir satır), içtekinin tipi int (bir hücre).

Sütun sütun gezinme

Döngülerin yerini değiştirirsen tablo sütun sütun okunur. Dikdörtgen dizide sütun sınırı için m[0].length kullanılır:

for (int c = 0; c < m[0].length; c++) {
    for (int r = 0; r < m.length; r++) System.out.print(m[r][c] + " ");
}

1 4 2 5 3 6 

Toplamlar, en büyük, köşegen

public static int total(int[][] m) {
    int t = 0;
    for (int[] row : m)
        for (int v : row)
            t += v;
    return t;
}
public static int[] rowSums(int[][] m) {
    int[] sums = new int[m.length];               // her satıra bir toplam
    for (int r = 0; r < m.length; r++)
        for (int c = 0; c < m[r].length; c++)
            sums[r] += m[r][c];
    return sums;
}
public static int colSum(int[][] m, int c) {
    int s = 0;
    for (int r = 0; r < m.length; r++) s += m[r][c];
    return s;
}
public static int max(int[][] m) {
    int best = m[0][0];
    for (int r = 0; r < m.length; r++)
        for (int c = 0; c < m[r].length; c++)
            if (m[r][c] > best) best = m[r][c];
    return best;
}
// main: m = {{1, 2, 3}, {4, 5, 6}}
System.out.println(total(m) + " " + Arrays.toString(rowSums(m)) + " " + colSum(m, 1) + " " + max(m));

21 [6, 15] 7 6

rowSums’ın iz tablosu, m = {{1, 2, 3}, {4, 5, 6}} için:

r   c   m[r][c]   sums
0   0   1         [1, 0]
0   1   2         [3, 0]
0   2   3         [6, 0]
1   0   4         [6, 4]
1   1   5         [6, 9]
1   2   6         [6, 15]

Satır toplamında satır sabit, sütun döner. Sütun toplamında sütun sabit, satır döner. Hangisinin sabit kaldığını düşünmek, döngüyü doğru kurmanın kısa yolu.

Köşegenler (kare dizide)

int[][] sq = {
    {2, 0, 1},
    {3, 5, 4},
    {9, 8, 6}
};
int diag = 0;
for (int i = 0; i < sq.length; i++) diag += sq[i][i];                    // ana köşegen
int anti = 0;
for (int i = 0; i < sq.length; i++) anti += sq[i][sq.length - 1 - i];    // yan köşegen

13
15

Ana köşegende (main diagonal) satır ve sütun indeksi eşit: 2 + 5 + 6. Yan köşegende toplamları n - 1: sq[0][2] + sq[1][1] + sq[2][0] = 1 + 5 + 9. Köşegen için tek döngü yeter.

Transpoze

Satırları sütun yapmak: yeni dizinin boyutları ters çevrilir, t[c][r] = m[r][c]. {{1, 2, 3}, {4, 5, 6}} için:

[[1, 4], [2, 5], [3, 6]]

Formülle doldurmak

Çarpım tablosu gibi her hücre indekslerden hesaplanıyorsa:

int[][] table = new int[3][3];
for (int r = 0; r < 3; r++)
    for (int c = 0; c < 3; c++)
        table[r][c] = (r + 1) * (c + 1);
System.out.println(Arrays.deepToString(table));

[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

Dizilerin dizisi ve düzensiz diziler

int[][] m aslında her elemanı bir int[] olan bir dizidir. m’nin kendisi satırların referanslarını tutar. Bu yüzden:

• int[] row = m[0]; ilk satırın referansını alır; row[1] = 20 doğrudan m[0][1]’i değiştirir.
• Satırların uzunlukları farklı olabilir: düzensiz dizi (ragged / jagged array).

int[][] tri = new int[4][];              // 4 satır, sütunlar henüz yok
for (int r = 0; r < tri.length; r++) {
    tri[r] = new int[r + 1];             // r. satırda r+1 eleman
    for (int c = 0; c <= r; c++) tri[r][c] = r + c;
}
for (int[] row : tri) System.out.println(Arrays.toString(row));
int[][] jag = {{1}, {2, 3, 4}, {5, 6}};
System.out.println(jag.length + " " + jag[1].length + " " + jag[2][1]);

[0]
[1, 2]
[2, 3, 4]
[3, 4, 5, 6]
3 3 6

TUZAK · sütun sayısını sabit yazmak. jag dizisinde iç döngüyü c < 3 diye yazınca ilk (tek elemanlı) satırda ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1 alındı. c < jag[0].length yazınca çökmedi ama her satırdan sadece ilk eleman toplandı: 8 (doğrusu 21). Her satır için m[r].length kullan.

Metoda 2D dizi geçirmek

1D ile aynı kural: referansın kopyası gider, metot hücreleri değiştirirse çağıran da görür. Parametre tipi int[][], dönüş tipi de int[][] olabilir (transpose gibi). Satır sayısı ve sütun sayısını parametre olarak ayrıca vermene gerek yok; length ile metodun içinde öğrenirsin.

Sık yapılan hatalar

int[][] m = {{4, 7}, {1, 9}, {3, 2}};
System.out.println(m.length + " " + m[0].length + " " + m[2][0] + " " + m[1][1]);

int[][] m = new int[2][3];
m[1][2] = 8;
m[0][0] = m[1][2] / 2;
int s = 0;
for (int[] row : m) for (int v : row) s += v;
System.out.println(s);

int[][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int s = 0;
for (int r = 0; r < 3; r++) s += m[r][2 - r];
System.out.println(s);

int[][] m = {{1, 2, 3}, {4, 5, 6}};
for (int c = 0; c < 3; c++) {
    for (int r = 0; r < 2; r++) System.out.print(m[r][c]);
    System.out.print(" ");
}

int[][] m = new int[3][3];
for (int r = 0; r < 3; r++)
    for (int c = 0; c < 3; c++)
        m[r][c] = r * 3 + c;
System.out.println(m[2][1] + " " + m[1][2]);

int[][] m = {{5, 1}, {2, 8}, {6, 3}};
int cnt = 0;
for (int r = 0; r < m.length; r++)
    for (int c = 0; c < m[r].length; c++)
        if (m[r][c] > r * 3) cnt++;
System.out.println(cnt);

int[][] m = {{1}, {2, 3}, {4, 5, 6}};
int s = 0;
for (int r = 0; r < m.length; r++) s += m[r][m[r].length - 1];
System.out.println(s);

int[][] m = {{1, 2}, {3, 4}};
int[] row0 = m[0];
row0[1] = 20;
m[1] = new int[]{7, 7, 7};
System.out.println(m[0][1] + " " + m[1].length);

int[][] m = {{3, 1, 2}, {9, 4, 6}};
System.out.println(Arrays.toString(rowSums(m)) + " " + colSum(m, 0) + " " + max(m));