Diziler

Bilgisayar ve Programlamaya Giriş

TanımİndeksDöngüAramaMatris

Sercan KÜLCÜ · Giresun Üniversitesi

Giriş

Öğrenme Çıktıları

Oluşturma

Dizi tanımlamak ve ilk değer vermek.

Erişim

İndeks ve length kullanmak.

İşleme

Diziyi döngülerle gezmek ve dönüştürmek.

Matris

İki boyutlu dizilerle satır-sütun işlemleri yapmak.

Temeller

Dizi Nedir?

Aynı türde, sabit sayıda elemanı tek nesnede ardışık hücrelerde saklar.
Elemanlara sıfır tabanlı indeksle erişilir: sayılar[0] … sayılar[4].
Uzunluk (length) oluşturulduktan sonra değişmez.
Dizi değişkeni elemanları değil, heap'teki dizi nesnesinin başvurusunu (adresini) tutar.

Değişken → dizi nesnesi (başvuru oku)

Temeller

Dizi ve İndeks

İlk indeks 0, son indeks length − 1'dir (5 eleman → 0…4).
a[i] adresi doğrudan hesaplanır (başlangıç + i × hücre boyu); bu yüzden erişim diziyi gezmeden, sabit sürede (O(1)) olur.

Temeller

Avantaj ve Sınır

Avantaj	Sınır
İndeksle hızlı erişim	Boyut sabittir
Eleman türü tutarlıdır	Araya ekleme maliyetlidir
Döngüyle kolay işlenir	Sınır aşımı çalışma zamanı hatasıdır
Bellekte düzenli yapı	Farklı türleri birlikte tutmaz

Tanımlama

Dizi Oluşturma

int[] sayılar = new int[5];
String[] adlar = {"Ada", "Can", "Ece"};
double[] ölçümler;
ölçümler = new double[10];

new ile oluşturulan dizinin hücreleri türün varsayılan değerini alır (sağda).
Başlatıcı {…} kullanılınca uzunluk değer sayısından çıkarılır (adlar.length = 3).

Varsayılan başlangıç değerleri

Tanımlama · Kodu adım adım çalıştır

Kod İzleme: Dizi Oluşturma

Bildirim: yığında yalnızca sayılar adlı başvuru değişkeni açılır; henüz bir dizi yok.

new int[4] heap'te 4 hücreli dizi oluşturur, hepsi 0. Değişkene dizinin başvurusu yazılır (ok).

sayılar[0] = 7: ok izlenir, 0 numaralı hücreye 7 yazılır.

sayılar[3] = 2: son hücre (indeks length − 1 = 3) güncellenir.

Başlatıcı {…}: 3 değer var → uzunluk 3 olan dizi kurulur ve adlar onu gösterir.

length bir alandır (parantez yok): 4 ve 3 yazılır.

int[] sayılar;
sayılar = new int[4];
sayılar[0] = 7;
sayılar[3] = 2;
String[] adlar = {"Ada", "Can", "Ece"};
System.out.println(sayılar.length + " "
                   + adlar.length);

Erişim · Kodu adım adım çalıştır

Eleman Okuma ve Yazma

Üç elemanlı dizi oluşur; indeksler 0, 1, 2.

Okuma: puanlar[0] ilk hücredeki değeri verir → ilk = 70.

Yazma: atamanın solundaki puanlar[1] hücrenin kendisidir; 85 silinir, 88 yazılır.

puanlar.length - 1 = 3 − 1 = 2 → son eleman 90. Dizi boyu değişse de kod doğru kalır.

İki değer aralarında boşlukla yazdırılır.

int[] puanlar = {70, 85, 90};
int ilk = puanlar[0];
puanlar[1] = 88;
int son = puanlar[puanlar.length - 1];
System.out.println(ilk + " " + son);

Erişim

Sınır Dışı Hatası

Geçerli indeksler 0 ile length − 1 arasındadır; negatif indeks ve length'in kendisi geçersizdir.
Derleyici bunu yakalamaz; program çalışırken ArrayIndexOutOfBoundsException ile durur.

Döngü koşulunda i < dizi.length kullanın; <= bir tur fazla döner.

Erişim · Kodu adım adım çalıştır

Kod İzleme: Bir Tur Fazla (`<=`)

Uzunluğu 3 olan dizi: geçerli indeksler 0, 1, 2.

0 <= 3 → true, gövdeye girilir.

a[0] = 4 yazdırılır.

i++ → 1 <= 3 → true, gövdeye girilir.

a[1] = 8 yazdırılır.

i++ → 2 <= 3 → true, gövdeye girilir.

a[2] = 6 yazdırılır.

i++ → 3 <= 3 → true — dikkat: 3 geçersiz indeks ama koşul yine de doğru!

a[3]: böyle bir hücre yok → program hata ile durur. Çözüm: koşulu i < a.length yapmak.

int[] a = {4, 8, 6};
for (int i = 0; i <= a.length; i++) {
    System.out.println(a[i]);
}

Döngüler · Kodu adım adım çalıştır

Klasik `for` ile Dolaşma

Dizi hazır; i indeks olarak 0'dan başlayacak.

int i = 0; 0 < 3 → true

puanlar[0] = 70; %d: %d kalıbı 0: 70 üretir.

i++ → 1 < 3 → true

puanlar[1] = 88; %d: %d kalıbı 1: 88 üretir.

i++ → 2 < 3 → true

puanlar[2] = 90; %d: %d kalıbı 2: 90 üretir.

i++ → 3 < 3 → false → döngü biter; i = length olduğu için a[i]'ye hiç erişilmez.

int[] puanlar = {70, 88, 90};
for (int i = 0; i < puanlar.length; i++) {
  System.out.printf("%d: %d%n", i, puanlar[i]);
}

İndeks gerektiğinde (konum yazdırmak, komşu elemana bakmak, hücreye yazmak) klasik for kullanılır.

Döngüler · Kodu adım adım çalıştır

Gelişmiş `for` (for-each)

Gelişmiş for dizinin elemanlarını sırayla verir; indeks yoktur.

1. tur: puan'a puanlar[0]'nin kopyası (70) konur.

puan = 75 olur; dizideki hücre 70 olarak kalır — değişen yalnızca kopya.

75 yazdırılır.

2. tur: puan'a puanlar[1]'nin kopyası (88) konur.

puan = 93 olur; dizideki hücre 88 olarak kalır — değişen yalnızca kopya.

93 yazdırılır.

3. tur: puan'a puanlar[2]'nin kopyası (90) konur.

puan = 95 olur; dizideki hücre 90 olarak kalır — değişen yalnızca kopya.

95 yazdırılır.

Eleman kalmadı → döngü biter; puan değişkeni kapsam dışına çıkar.

puanlar[0] hâlâ 70: gelişmiş for'da döngü değişkenine atama diziyi değiştirmez.

int[] puanlar = {70, 88, 90};
for (int puan : puanlar) {
    puan = puan + 5;
    System.out.println(puan);
}
System.out.println(puanlar[0]);

İşlemler · Kodu adım adım çalıştır

Toplam ve Ortalama

Dört elemanlı dizi.

Biriktirici toplam = 0 ile başlar.

değer = 4 → toplam += değer: 0 + 4 = 4.

değer = 7 → toplam += değer: 4 + 7 = 11.

değer = 2 → toplam += değer: 11 + 2 = 13.

değer = 6 → toplam += değer: 13 + 6 = 19.

Döngü bitti. ortalama 0 ile başlatılır (boş dizi için güvenli değer).

4 > 0 → true: dizi boş değil, bölme yapılabilir.

(double) 19 / 4 = 4.75. Dönüşüm olmasa tam sayı bölmesi 4 verirdi.

Sonuçlar yazdırılır.

int[] sayılar = {4, 7, 2, 6};
int toplam = 0;
for (int değer : sayılar) toplam += değer;
double ortalama = 0;
if (sayılar.length > 0)
    ortalama = (double) toplam / sayılar.length;
System.out.println(toplam + " " + ortalama);

İşlemler · Kodu adım adım çalıştır

En Küçük ve En Büyük

Dizi: 5, 3, 9, 1.

İlk eleman hem min hem max adayıdır (0 ile başlatmak negatif/pozitif dizilerde yanlış sonuç verirdi).

1. tur: değer = 5.

5 < 5 → false; min değişmez.

5 > 5 → false; max değişmez.

2. tur: değer = 3.

3 < 5 → true: min = 3.

3 > 5 → false; max değişmez.

3. tur: değer = 9.

9 < 3 → false; min değişmez.

9 > 5 → true: max = 9.

4. tur: değer = 1.

1 < 3 → true: min = 1.

1 > 9 → false; max değişmez.

Tüm elemanlara bakıldı (n = 4 tur) → 1 9.

int[] sayılar = {5, 3, 9, 1};
int min = sayılar[0], max = sayılar[0];
for (int değer : sayılar) {
    if (değer < min) min = değer;
    if (değer > max) max = değer;
}
System.out.println(min + " " + max);

Boş dizide sayılar[0] hata verir; gerçek kodda önce sayılar.length == 0 durumu ele alınmalıdır.

İşlemler · Kodu adım adım çalıştır

Diziyi Ters Çevirme (iki işaretçi)

Tersine çevrilecek dizi.

İki işaretçi: sol = 0 ve sağ = length − 1 = 4.

0 < 4 → true, uçlar yer değiştirecek.

geçici = dizi[0] = 1: soldaki değer kaybolmasın diye saklanır.

dizi[0] = dizi[4] → sol hücreye 5 yazılır.

dizi[4] = geçici → sağ hücreye 1. Takas tamam.

İşaretçiler merkeze yaklaşır: sol = 1, sağ = 3.

1 < 3 → true, uçlar yer değiştirecek.

geçici = dizi[1] = 2: soldaki değer kaybolmasın diye saklanır.

dizi[1] = dizi[3] → sol hücreye 4 yazılır.

dizi[3] = geçici → sağ hücreye 2. Takas tamam.

İşaretçiler merkeze yaklaşır: sol = 2, sağ = 2.

2 < 2 → false: işaretçiler ortada buluştu → dizi ters çevrildi.

int[] dizi = {1, 2, 3, 4, 5};
int sol = 0, sağ = dizi.length - 1;
while (sol < sağ) {
    int geçici = dizi[sol];
    dizi[sol] = dizi[sağ];
    dizi[sağ] = geçici;
    sol++;
    sağ--;
}

n/2 takas yapılır; ek dizi gerekmez (yerinde, O(1) ek alan).

İşlemler

Dizi Kopyalama

b = a elemanları değil başvuruyu kopyalar: iki ok aynı nesneyi gösterir.
Bağımsız kopya için a.clone(), Arrays.copyOf(a, a.length) veya System.arraycopy.
Nesne dizilerinde bu yöntemler eleman başvurularını kopyalar; nesnelerin kendisi çoğaltılmaz (sığ kopya).

İşlemler · Kodu adım adım çalıştır

Kod İzleme: Başvuru Kopyası ve Eleman Kopyası

Heap'te bir dizi; a onu gösterir.

b = a: yeni dizi oluşmaz; b'ye aynı başvuru yazılır → iki ok aynı nesnede.

b[0] = 99: b'nin gösterdiği nesne değişti — bu, a'nın da nesnesi!

a[0] artık 99. Başvuru kopyası bağımsız bir dizi değildir.

a.clone() heap'te yeni bir dizi açar ve elemanları tek tek kopyalar.

c[1] = 50 yalnızca kopyayı değiştirir.

a[1] = 2 (değişmedi), c[1] = 50.

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 99;
System.out.println(a[0]);
int[] c = a.clone();
c[1] = 50;
System.out.println(a[1] + " " + c[1]);

Arama · Kodu adım adım çalıştır

Doğrusal Arama: `ara(d, 6)`

main'de dizi oluşturulur.

ara(d, 6) çağrılır: yeni çerçeve açılır; dizi parametresi aynı diziyi gösterir (başvuru aktarılır).

0 < 4 → true, i = 0.

dizi[0] == 6 → 8 == 6 → false.

1 < 4 → true, i = 1.

dizi[1] == 6 → 3 == 6 → false.

2 < 4 → true, i = 2.

dizi[2] == 6 → 6 == 6 → true: return 2, döngü erken biter.

Çerçeve kapanır, dönen 2 yazdırılır. Hedef yoksa n karşılaştırmadan sonra −1 dönerdi → O(n).

static int ara(int[] dizi, int hedef) {
    for (int i = 0; i < dizi.length; i++)
        if (dizi[i] == hedef) return i;
    return -1;
}
// main içinde:
int[] d = {8, 3, 6, 2};
System.out.println(ara(d, 6));

Arama

Sıralama ve İkili Arama

Arrays.sort(a) diziyi küçükten büyüğe yerinde sıralar (özgün sıra kaybolur).
Arrays.binarySearch(a, x) yalnızca sıralı dizide doğru çalışır; bulursa indeksi döndürür.
Her adımda aralığı yarıya indirdiği için doğrusal aramadan çok daha az karşılaştırma yapar.
İkisi için de import java.util.Arrays; gerekir.

Analiz

Temel Karmaşıklıklar

İşlem	Zaman
İndeksle erişim	O(1)
Doğrusal arama	O(n)
Sona kadar dolaşma	O(n)
Ortaya ekleme / silme	O(n)
İki iç içe tam dolaşma	O(n²)

Matris

İki Boyutlu Dizi

int[][] matris = {
    {1, 2, 3},
    {4, 5, 6}
};
int değer = matris[1][2]; // 6

İlk indeks satır, ikinci indeks sütun.
Dış dizinin her hücresi bir satır dizisini gösterir; satırlar farklı uzunlukta olabilir (düzensiz dizi).
matris.length = satır sayısı, matris[0].length = sütun sayısı.

Matris · Kodu adım adım çalıştır

Matrisi Satır Satır Dolaşma

2 satır × 3 sütunluk matris; matris.length = 2.

Dış döngü: 0 < 2 → true → 0. satır işlenecek.

İç döngü: 0 < 3 → true; matris[0][0] = 1 yazılır (print: satır atlamaz).

İç döngü: 1 < 3 → true; matris[0][1] = 2 yazılır (print: satır atlamaz).

İç döngü: 2 < 3 → true; matris[0][2] = 3 yazılır (print: satır atlamaz).

3 < 3 → false: satır bitti, iç döngüden çıkılır.

println() alt satıra geçer; ardından i++.

Dış döngü: 1 < 2 → true → 1. satır işlenecek.

İç döngü: 0 < 3 → true; matris[1][0] = 4 yazılır (print: satır atlamaz).

İç döngü: 1 < 3 → true; matris[1][1] = 5 yazılır (print: satır atlamaz).

İç döngü: 2 < 3 → true; matris[1][2] = 6 yazılır (print: satır atlamaz).

3 < 3 → false: satır bitti, iç döngüden çıkılır.

println() alt satıra geçer; ardından i++.

Dış döngü: 2 < 2 → false → bitti. Toplam 2 × 3 = 6 hücre gezildi.

int[][] matris = {{1, 2, 3}, {4, 5, 6}};
for (int i = 0; i < matris.length; i++) {
  for (int j = 0; j < matris[i].length; j++) {
    System.out.print(matris[i][j] + " ");
  }
  System.out.println();
}

Matris · Kodu adım adım çalıştır

Matris Transpozu

Kaynak matris 2 × 3.

matris.length = satır sayısı = 2.

matris[0].length = ilk satırın uzunluğu = 3.

Hedef t boyutları ters: 3 × 2, hücreler 0.

t[0][0] = matris[0][0] = 1: satır ↔ sütun yer değiştirir.

t[1][0] = matris[0][1] = 2: satır ↔ sütun yer değiştirir.

t[2][0] = matris[0][2] = 3: satır ↔ sütun yer değiştirir.

t[0][1] = matris[1][0] = 4: satır ↔ sütun yer değiştirir.

t[1][1] = matris[1][1] = 5: satır ↔ sütun yer değiştirir.

t[2][1] = matris[1][2] = 6: satır ↔ sütun yer değiştirir.

Döngüler bitti: matrisin satırları t'nin sütunları oldu.

int[][] matris = {{1, 2, 3}, {4, 5, 6}};
int satırSayısı = matris.length;
int sütunSayısı = matris[0].length;
int[][] t = new int[sütunSayısı][satırSayısı];
for (int i = 0; i < satırSayısı; i++)
    for (int j = 0; j < sütunSayısı; j++)
        t[j][i] = matris[i][j];

Tasarım

Dizi mi Liste mi?

Eleman sayısı baştan belli ve sabitse dizi yeterli ve hızlıdır.
Eleman sayısı değişecekse ArrayList gibi koleksiyonlar daha kullanışlıdır (ileri derslerde).
int[] sayıları doğrudan saklar; ArrayList<Integer> her sayıyı bir nesne içinde tutar.
Seçim; kullanım biçimine, okunabilirliğe ve ölçülen performansa göre yapılır.

Doğrulama

Yaygın Hatalar

Bir tur fazla

i <= a.length son turda a[length]'e erişir → ArrayIndexOutOfBoundsException. Doğrusu i < a.length.

Boş dizide ilk eleman

int min = a[0]; boş dizide hata verir; önce a.length == 0 kontrolü.

Başvuru kopyası

int[] b = a; yeni dizi değildir; b[0] = 9 a'yı da değiştirir. Kopya için a.clone().

Düzensiz matris

Her satırın uzunluğu matris[0].length değildir; iç döngüde matris[i].length kullanın.

Özet

Bölüm Özeti

Yapı

Aynı türde, sabit sayıda eleman; indeks 0 … length − 1; değişken diziyi başvuruyla gösterir.

Erişim

a[i] okuma/yazma sabit sürede; sınır dışı indeks çalışma zamanı hatası.

Dolaşma

Klasik for (indeks gerekince) ve gelişmiş for (yalnızca okuma); toplam, min-max, ters çevirme, arama.

Matris

int[][] dizi dizisidir: matris.length satır, matris[i].length sütun sayısı.

Özet

Kontrol Soruları

Beş elemanlı dizinin son indeksi nedir?
Gelişmiş for ne zaman yetersiz kalır?
Dizi ataması ile eleman kopyası arasındaki fark nedir?
İkili arama için hangi ön koşul gerekir?
matris.length ile matris[0].length neyi verir?

Cevaplar

4 (length − 1).
İndeks gerektiğinde: konumu yazdırmak, hücreye yeni değer yazmak, diziyi tersten veya iki diziyi birlikte gezmek.
Atama (b = a) yalnızca başvuruyu kopyalar, iki değişken aynı nesneyi gösterir; clone/Arrays.copyOf yeni bir dizi oluşturur.
Dizinin sıralı olması.
Satır sayısını ve ilk satırın sütun sayısını.

Son

Diziler

← → veya boşluk ile gezinin · F: tam ekran · Home/End: ilk/son slayt

Diziler

Öğrenme Çıktıları

Dizi Nedir?

Dizi ve İndeks

Avantaj ve Sınır

Dizi Oluşturma

Kod İzleme: Dizi Oluşturma

Eleman Okuma ve Yazma

Sınır Dışı Hatası

Kod İzleme: Bir Tur Fazla (<=)

Klasik for ile Dolaşma

Gelişmiş for (for-each)

Toplam ve Ortalama

En Küçük ve En Büyük

Diziyi Ters Çevirme (iki işaretçi)

Dizi Kopyalama

Kod İzleme: Başvuru Kopyası ve Eleman Kopyası

Doğrusal Arama: ara(d, 6)

Sıralama ve İkili Arama

Temel Karmaşıklıklar

İki Boyutlu Dizi

Matrisi Satır Satır Dolaşma

Matris Transpozu

Dizi mi Liste mi?

Yaygın Hatalar

Bölüm Özeti

Kontrol Soruları

Son

Kod İzleme: Bir Tur Fazla (`<=`)

Klasik `for` ile Dolaşma

Gelişmiş `for` (for-each)

Doğrusal Arama: `ara(d, 6)`