Dizi İşlemleri ve Algoritmalar

Giriş

Dizileri tanımlamayı, elemanlara erişmeyi ve gezmeyi öğrendin. Şimdi sıra diziler üzerinde iş yapmaya geldi: sıralama, arama, kopyalama, doldurma...

Java, java.util.Arrays sınıfı ile bu işlerin çoğunu tek satırda yapmanı sağlar. Ama sadece hazır metotları kullanmak yetmez — arka planda ne olduğunu bilmen de lazım. Bu yüzden hem Arrays sınıfını hem de temel algoritmaları göreceğiz.

Arrays Sınıfı

java.util.Arrays sınıfı, dizilerle çalışmak için bir araç kutusu gibidir. İçinde sıralama, arama, karşılaştırma, kopyalama gibi bir sürü statik metot var.

Kullanmak için import gerekli:

import java.util.Arrays;

Şimdi en önemli metotları teker teker görelim.

Arrays.sort() — Sıralama

Diziyi küçükten büyüğe sıralar. Primitive tipler için Dual-Pivot Quicksort, referans tipler için TimSort kullanır.

int[] sayilar = {64, 25, 12, 22, 11};

Arrays.sort(sayilar);

System.out.println(Arrays.toString(sayilar));
// [11, 12, 22, 25, 64]

Bu kadar basit. Tek satırda sıralama yapıyorsun.

Kısmi Sıralama

Dizinin sadece belirli bir bölümünü sıralayabilirsin:

int[] sayilar = {64, 25, 12, 22, 11};

Arrays.sort(sayilar, 1, 4);  // indeks 1'den 4'e kadar (4 hariç)

System.out.println(Arrays.toString(sayilar));
// [64, 12, 22, 25, 11]
// sadece indeks 1,2,3 sıralandı

String Dizisi Sıralama

String[] isimler = {"Zeynep", "Ali", "Mehmet", "Ayse"};

Arrays.sort(isimler);

System.out.println(Arrays.toString(isimler));
// [Ali, Ayse, Mehmet, Zeynep]

String dizileri alfabetik (Unicode) sıraya göre sıralanır. Büyük harfler küçük harflerden önce gelir: "Zebra" < "armut".

⚠️ Dikkat: Arrays.sort() orijinal diziyi değiştirir, yeni dizi oluşturmaz. Orijinali korumak istiyorsan önce kopyala.

Arrays.binarySearch() — İkili Arama

Sıralı bir dizide bir elemanı hızlıca bulur. Ön koşul: dizi sıralı olmalı!

Algoritmayı bir telefon rehberi gibi düşün. "Mehmet" arıyorsan, rehberin ortasını açarsın. "M" oradaysa yakınsındır. Değilse, sağ tarafa mı sol tarafa mı bakacağını bilirsin. Her adımda arama alanını yarıya indirirsin.

int[] sayilar = {11, 12, 22, 25, 64};  // SIRALİ olmalı!

int indeks = Arrays.binarySearch(sayilar, 22);
System.out.println("22'nin indeksi: " + indeks);  // 2

int yok = Arrays.binarySearch(sayilar, 50);
System.out.println("50'nin indeksi: " + yok);      // negatif (bulunamadı)

Eleman bulunursa indeksini döndürür. Bulunamazsa negatif bir değer döndürür.

⚠️ Dikkat: Sıralı olmayan dizide binarySearch kullanırsan sonuç tanımsız olur. Yanlış indeks döndürebilir. Aramadan önce sort() çağırdığından emin ol.

int[] karisik = {64, 25, 12, 22, 11};

// YANLIŞ — dizi sıralı değil
int sonuc = Arrays.binarySearch(karisik, 22);  // güvenilmez!

// DOĞRU
Arrays.sort(karisik);  // önce sırala
int dogru = Arrays.binarySearch(karisik, 22);  // şimdi güvenilir

Arrays.fill() — Doldurma

Dizinin tamamını veya bir bölümünü belirli bir değerle doldurur.

int[] dizi = new int[5];

Arrays.fill(dizi, 42);
System.out.println(Arrays.toString(dizi));  // [42, 42, 42, 42, 42]

// Kısmi doldurma
Arrays.fill(dizi, 1, 3, 99);  // indeks 1'den 3'e kadar (3 hariç)
System.out.println(Arrays.toString(dizi));  // [42, 99, 99, 42, 42]

Başlangıç değeri atamak veya diziyi sıfırlamak için çok pratik.

Arrays.copyOf() — Kopyalama

Dizinin tamamını veya bir kısmını yeni bir diziye kopyalar.

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

// Aynı boyutta kopya
int[] kopya = Arrays.copyOf(orijinal, orijinal.length);
System.out.println(Arrays.toString(kopya));  // [1, 2, 3, 4, 5]

// Daha büyük boyutta kopya (fazlası 0 ile dolur)
int[] buyuk = Arrays.copyOf(orijinal, 8);
System.out.println(Arrays.toString(buyuk));  // [1, 2, 3, 4, 5, 0, 0, 0]

// Daha küçük boyutta kopya (sondan kırpılır)
int[] kucuk = Arrays.copyOf(orijinal, 3);
System.out.println(Arrays.toString(kucuk));  // [1, 2, 3]

💡 İpucu: copyOf ile dizi "büyütme" yapabilirsin. Java'da diziler sabit boyutlu olduğu için direkt büyütemezsin, ama copyOf ile daha büyük bir kopya oluşturabilirsin. ArrayList'in arka planda yaptığı şey de tam olarak budur.

Arrays.copyOfRange() — Belirli Aralığı Kopyalama

int[] orijinal = {10, 20, 30, 40, 50};

int[] parcali = Arrays.copyOfRange(orijinal, 1, 4);  // indeks 1'den 4'e (4 hariç)
System.out.println(Arrays.toString(parcali));  // [20, 30, 40]

Arrays.equals() — Karşılaştırma

İki dizinin içeriğini karşılaştırır.

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};

System.out.println(a == b);               // false — referans karşılaştırır
System.out.println(Arrays.equals(a, b));   // true — içerik karşılaştırır
System.out.println(Arrays.equals(a, c));   // false

== operatörü iki dizinin aynı nesne olup olmadığını kontrol eder. İçerikleri aynı olsa bile farklı nesnelerse false döner. İçerik karşılaştırması için her zaman Arrays.equals() kullan.

Arrays.toString() — Yazdırma

Önceki derslerde gördük ama tekrar edelim:

int[] dizi = {10, 20, 30};
System.out.println(dizi);                    // [I@15db9742
System.out.println(Arrays.toString(dizi));   // [10, 20, 30]

2D diziler için Arrays.deepToString() kullanıldığını unutma.

Linear Search (Doğrusal Arama)

En basit arama algoritması. Diziyi baştan sona gezerek aranan elemanı bul.

static int linearSearch(int[] dizi, int aranan) {
    for (int i = 0; i < dizi.length; i++) {
        if (dizi[i] == aranan) {
            return i;  // bulundu, indeksini döndür
        }
    }
    return -1;  // bulunamadı
}

// Kullanım
int[] sayilar = {64, 25, 12, 22, 11};
int indeks = linearSearch(sayilar, 22);
System.out.println("22'nin indeksi: " + indeks);  // 3

Performans

• En iyi durum: İlk elemanda bulur → 1 karşılaştırma

• En kötü durum: Son elemanda bulur veya bulamaz → N karşılaştırma

• Ortalama: N/2 karşılaştırma

Linear search sıralı olmayan dizilerde kullanılır. Sıralıysa binarySearch çok daha hızlı.

String Dizisinde Arama

static int linearSearch(String[] dizi, String aranan) {
    for (int i = 0; i < dizi.length; i++) {
        if (dizi[i].equals(aranan)) {  // String'de == yerine equals!
            return i;
        }
    }
    return -1;
}

⚠️ Dikkat: String karşılaştırmasında == yerine .equals() kullanmayı unutma. == referans karşılaştırır, .equals() içerik karşılaştırır.

Binary Search (İkili Arama) — Manuel Implementasyon

Arrays.binarySearch() hazır metot olsa da, algoritmanın nasıl çalıştığını bilmek önemli.

static int binarySearch(int[] dizi, int aranan) {
    int sol = 0;
    int sag = dizi.length - 1;

    while (sol <= sag) {
        int orta = (sol + sag) / 2;

        if (dizi[orta] == aranan) {
            return orta;           // bulundu
        } else if (dizi[orta] < aranan) {
            sol = orta + 1;        // sağ yarıda ara
        } else {
            sag = orta - 1;        // sol yarıda ara
        }
    }

    return -1;  // bulunamadı
}

Adım Adım Örnek

Dizi: [11, 12, 22, 25, 64], Aranan: 22

Adım 1: sol=0, sag=4, orta=2 → dizi[2]=22 → BULUNDU!

Dizi: [11, 12, 22, 25, 64], Aranan: 25

Adım 1: sol=0, sag=4, orta=2 → dizi[2]=22 < 25 → sol=3
Adım 2: sol=3, sag=4, orta=3 → dizi[3]=25 → BULUNDU!

Linear vs Binary Search Performans

Binary search her adımda arama alanını yarıya indirdiği için logaritmik karmaşıklığa sahip: O(log n). Linear search ise O(n).

Fark büyük dizilerde dramatik. Ama binary search'ün çalışması için dizi sıralı olmalı. Sıralı değilse önce sırala (O(n log n)) + sonra ara (O(log n)) → toplam O(n log n). Tek seferlik arama için linear search daha mantıklı olabilir, ama çok kez arayacaksan sırala + binary search.

Bubble Sort (Kabarcık Sıralama)

Arrays.sort() varken niye bubble sort öğreneyim diyebilirsin. Çünkü sıralama algoritmalarının mantığını anlamak, programcılık düşünceni geliştirir. Bubble sort en basit sıralama algoritmasıdır.

Algoritmanın mantığı: dizide yan yana duran elemanları karşılaştır, yanlış sıradalarsa yer değiştir. Bunu dizi sıralanana kadar tekrarla.

Bunu bir su içindeki kabarcık gibi düşün. En büyük eleman her turda yukarı (sona) doğru çıkar, tıpkı suyun içindeki kabarcık gibi.

static void bubbleSort(int[] dizi) {
    int n = dizi.length;

    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (dizi[j] > dizi[j + 1]) {
                // Swap (yer değiştir)
                int gecici = dizi[j];
                dizi[j] = dizi[j + 1];
                dizi[j + 1] = gecici;
            }
        }
    }
}

Adım Adım Örnek

Dizi: [64, 25, 12, 22, 11]

Tur 1: [25, 12, 22, 11, 64]   ← 64 yerine oturdu
Tur 2: [12, 22, 11, 25, 64]   ← 25 yerine oturdu
Tur 3: [12, 11, 22, 25, 64]   ← 22 yerine oturdu
Tur 4: [11, 12, 22, 25, 64]   ← tamamlandı

Optimize Edilmiş Bubble Sort

Eğer bir turda hiç swap yapılmadıysa, dizi zaten sıralıdır. Erken çıkabiliriz:

static void bubbleSortOptimized(int[] dizi) {
    int n = dizi.length;

    for (int i = 0; i < n - 1; i++) {
        boolean swapYapildi = false;

        for (int j = 0; j < n - 1 - i; j++) {
            if (dizi[j] > dizi[j + 1]) {
                int gecici = dizi[j];
                dizi[j] = dizi[j + 1];
                dizi[j + 1] = gecici;
                swapYapildi = true;
            }
        }

        if (!swapYapildi) break;  // dizi sıralı, erken çık
    }
}

Bu optimizasyon, zaten sıralı veya neredeyse sıralı dizilerde büyük fark yaratır.

Bubble Sort Performans

• En iyi durum: Dizi zaten sıralı → O(n) (optimize versiyonla)

• En kötü durum: Dizi ters sıralı → O(n²)

• Ortalama: O(n²)

Bubble sort öğretici bir algoritmadır. Gerçek projelerde Arrays.sort() kullan — çok daha hızlı.

Selection Sort (Seçmeli Sıralama) — Bonus

Bubble sort'a alternatif basit bir algoritma daha:

static void selectionSort(int[] dizi) {
    int n = dizi.length;

    for (int i = 0; i < n - 1; i++) {
        int minIndeks = i;

        for (int j = i + 1; j < n; j++) {
            if (dizi[j] < dizi[minIndeks]) {
                minIndeks = j;
            }
        }

        // En küçüğü i. pozisyona yerleştir
        int gecici = dizi[minIndeks];
        dizi[minIndeks] = dizi[i];
        dizi[i] = gecici;
    }
}

Her turda kalan dizideki en küçük elemanı bul ve başa koy. Basit ve anlaşılır.

Tüm Arrays Metotları Özet Tablosu

Pratik Örnek: Not Analizi

Tüm öğrendiklerimizi birleştirelim:

import java.util.Arrays;

public class NotAnalizi {
    public static void main(String[] args) {
        int[] notlar = {72, 85, 91, 60, 45, 78, 88, 95, 67, 53};

        System.out.println("Orijinal: " + Arrays.toString(notlar));

        // Kopyala ve sırala (orijinali korumak için)
        int[] sirali = Arrays.copyOf(notlar, notlar.length);
        Arrays.sort(sirali);
        System.out.println("Sıralı:   " + Arrays.toString(sirali));

        // En düşük ve en yüksek
        System.out.println("En düşük: " + sirali[0]);
        System.out.println("En yüksek: " + sirali[sirali.length - 1]);

        // Ortalama
        int toplam = 0;
        for (int not : notlar) toplam += not;
        double ortalama = (double) toplam / notlar.length;
        System.out.println("Ortalama: " + ortalama);

        // Belirli bir not var mı?
        int aranan = 85;
        int indeks = Arrays.binarySearch(sirali, aranan);
        System.out.println(aranan + " notu " + (indeks >= 0 ? "var" : "yok"));
    }
}

Özet

• Arrays sınıfı dizilerle çalışmak için hazır metotlar sunar: sort, binarySearch, fill, copyOf, equals, toString

• Linear search sırasız dizilerde çalışır, O(n) karmaşıklık

• Binary search sıralı dizilerde çalışır, O(log n) karmaşıklık — çok daha hızlı

• Bubble sort en basit sıralama algoritması, O(n²) — öğretici ama yavaş

• Gerçek projelerde Arrays.sort() kullan — arka planda optimize algoritmalar çalışır

• Arrays.sort() orijinal diziyi değiştirir, kopyalamak istersen önce copyOf kullan