Tek Boyutlu Diziler - Tüm Operasyonlar

Dizi (array), aynı türdeki verileri bellekte ardışık olarak saklayan en temel veri yapısıdır. Bir dizi tanımladığınızda, işletim sistemi bellekte o dizinin boyutu kadar ardışık alan ayırır. Bu sayede her elemana indeks numarası üzerinden doğrudan erişebilirsiniz.

Bunu bir apartmandaki daireler gibi düşünebilirsiniz: her dairenin bir numarası vardır ve siz numarayı bildiğiniz sürece doğrudan o daireye gidersiniz. Tek tek tüm kapıları çalmanıza gerek yoktur.

Temel Kavramlar ve Tanımlar

İndeks (Index) Nedir?

İndeks, dizideki her elemanın sahip olduğu benzersiz konum numarasıdır. C dilinde diziler sıfırdan indekslenir (zero-indexed), yani ilk elemanın indeksi 0'dır, ikincinin 1'dir ve bu şekilde devam eder. Bu durum başlangıçta kafa karıştırıcı olabilir: 5 elemanlı bir dizide son elemanın indeksi 5 değil 4'tür.

Eleman (Element) Nedir?

Dizi içinde saklanan her bir veriye eleman denir. Bir dizinin tüm elemanları aynı veri tipinde olmak zorundadır. Yani int tipinde tanımlanmış bir diziye float veya char değer koyamazsınız. Bu kısıtlama, dizinin bellekte düzgün çalışmasını garanti eder çünkü her elemanın kaplayacağı byte miktarı önceden bilinmelidir.

Boyut (Size) ve Kapasite (Capacity)

Bu iki kavram sıkça karıştırılır. Kapasite, dizinin tanımlanırken ayrılan toplam alan miktarıdır. Boyut ise dizide o anda gerçekten kullanılan eleman sayısıdır. Örneğin int arr[10] yazdığınızda kapasite 10'dur ama içine sadece 3 eleman koyduysanız boyut 3'tür.

Statik Dizi vs Dinamik Dizi

C dilindeki diziler statik dizilerdir, yani boyutları derleme zamanında (compile time) belirlenir ve çalışma sırasında değiştirilemez. 5 elemanlık bir dizi tanımladıysanız, daha sonra 6. bir eleman ekleyemezsiniz. Eğer çalışma zamanında boyut değiştirmek istiyorsanız malloc() ve realloc() fonksiyonlarıyla dinamik bellek yönetimi yapmanız gerekir. Python'daki list veya Java'daki ArrayList gibi yapılar arka planda bu dinamik boyutlandırmayı sizin yerinize otomatik yapar, ancak altta yatan mekanizma yine aynıdır: yeni ve daha büyük bir alan ayrılır, eski veriler kopyalanır, eski alan serbest bırakılır.

Bellekte Nasıl Durur?

C dilinde int arr[5] = {10, 20, 30, 40, 50}; yazdığınızda bellekte şu şekilde bir alan ayrılır:

Adres Hesaplama Formülü

Bir dizinin herhangi bir elemanının bellek adresini şu formülle hesaplayabilirsiniz:

İşte dizilerin O(1) erişim süresine sahip olmasının sırrı bu formüldür. Hangi elemana erişmek isterseniz isteyin, CPU tek bir çarpma ve toplama işlemiyle doğrudan o adrese gider. 5. elemana erişmek ile 5000. elemana erişmek arasında hiçbir hız farkı yoktur.

Farklı Veri Tiplerinin Bellek Kullanımı

Dizi Oluşturma

C dilinde dizi tanımlamanın birden fazla yolu vardır:

// Yöntem 1: Boyut belirleyip sonra değer atama
int arr[5];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;

// Yöntem 2: Tanımlarken değer atama
int arr[5] = {10, 20, 30, 40, 50};

// Yöntem 3: Boyut belirtmeden (derleyici sayar)
int arr[] = {10, 20, 30, 40, 50};

// Yöntem 4: Kısmi atama (geri kalanlar 0 olur)
int arr[5] = {10, 20};  // → {10, 20, 0, 0, 0}

Dizinin Boyutunu Öğrenme

C dilinde bir dizinin kaç elemandan oluştuğunu doğrudan söyleyen bir komut yoktur. Bunun yerine sizeof operatörünü kullanarak hesaplama yapılır. sizeof(arr) dizinin toplam byte büyüklüğünü, sizeof(arr[0]) ise tek bir elemanın byte büyüklüğünü verir. Birini diğerine böldüğünüzde eleman sayısını elde edersiniz.

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

// Toplam boyut: 5 eleman × 4 byte = 20 byte
printf("Toplam boyut: %lu byte\n", sizeof(arr));        // 20

// Tek eleman boyutu: 4 byte (int)
printf("Eleman boyutu: %lu byte\n", sizeof(arr[0]));   // 4

// Eleman sayısı: 20 / 4 = 5
int n = sizeof(arr) / sizeof(arr[0]);
printf("Eleman sayısı: %d\n", n);                       // 5

// ❌ YANLIŞ: Fonksiyon içinde sizeof dizi boyutunu vermez
void yanlisFonksiyon(int arr[]) {
    int n = sizeof(arr) / sizeof(arr[0]);  // pointer boyutu / int boyutu = 2 (yanlış!)
}

// ✅ DOĞRU: Eleman sayısını parametre olarak geçir
void dogruFonksiyon(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
}

Traverse İşlemi (Dolaşma)

Traverse, dizideki tüm elemanları baştan sona tek tek ziyaret etmektir. En temel dizi operasyonudur ve diğer birçok işlemin (arama, toplam hesaplama, yazdırma) temelini oluşturur.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);  // eleman sayısı: 5

    for (int i = 0; i < n; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

// Çıktı:
// arr[0] = 10
// arr[1] = 20
// arr[2] = 30
// arr[3] = 40
// arr[4] = 50

Başa Eleman Ekleme

C'de diziler sabit boyutludur. Başa eleman eklemek için mevcut tüm elemanları bir sağa kaydırmanız gerekir. Bu işlem O(n) zaman karmaşıklığına sahiptir çünkü n eleman taşınmalıdır.

#include <stdio.h>

void basaEkle(int arr[], int *n, int kapasite, int yeniEleman) {
    if (*n >= kapasite) {
        printf("Dizi dolu!\n");
        return;
    }

    // Tüm elemanları bir sağa kaydır
    for (int i = *n; i > 0; i--) {
        arr[i] = arr[i - 1];
    }

    arr[0] = yeniEleman;  // başa yerleştir
    (*n)++;               // eleman sayısını artır
}

int main() {
    int arr[10] = {10, 20, 30, 40};
    int n = 4;

    basaEkle(arr, &n, 10, 5);

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    // Çıktı: 5 10 20 30 40

    return 0;
}

Araya Eleman Ekleme

Belirli bir indekse eleman eklemek, başa ekleme işlemine benzer. Hedef indeksten itibaren tüm elemanlar bir sağa kaydırılır ve boşalan yere yeni eleman yerleştirilir. Kaydırılacak eleman sayısı hedef indekse bağlıdır, bu yüzden en kötü durumda O(n) karmaşıklığındadır.

void arayaEkle(int arr[], int *n, int kapasite, int index, int yeniEleman) {
    if (*n >= kapasite) {
        printf("Dizi dolu!\n");
        return;
    }
    if (index < 0 || index > *n) {
        printf("Geçersiz index!\n");
        return;
    }

    // Hedef index'ten itibaren sağa kaydır
    for (int i = *n; i > index; i--) {
        arr[i] = arr[i - 1];
    }

    arr[index] = yeniEleman;
    (*n)++;
}

// Kullanım:
int arr[10] = {10, 20, 30, 40};
int n = 4;
arayaEkle(arr, &n, 10, 2, 25);
// Sonuç: {10, 20, 25, 30, 40}

Sona Eleman Ekleme

Sona eleman eklemek çok daha basittir. Hiçbir elemanı kaydırmanıza gerek yoktur, sadece son boş pozisyona yeni değeri yazarsınız. Bu işlem O(1) zaman karmaşıklığına sahiptir.

void sonaEkle(int arr[], int *n, int kapasite, int yeniEleman) {
    if (*n >= kapasite) {
        printf("Dizi dolu!\n");
        return;
    }

    arr[*n] = yeniEleman;  // son pozisyona yaz
    (*n)++;
}

// Kullanım:
int arr[10] = {10, 20, 30, 40};
int n = 4;
sonaEkle(arr, &n, 10, 60);
// Sonuç: {10, 20, 30, 40, 60}

Eleman Silme

Belirli bir indeksteki elemanı silmek için, o indeksten sonraki tüm elemanları bir sola kaydırmanız gerekir. Baştan silme O(n), sondan silme O(1) karmaşıklığındadır.

void elemanSil(int arr[], int *n, int index) {
    if (index < 0 || index >= *n) {
        printf("Geçersiz index!\n");
        return;
    }

    // Silinen yerden itibaren sola kaydır
    for (int i = index; i < *n - 1; i++) {
        arr[i] = arr[i + 1];
    }

    (*n)--;  // eleman sayısını azalt
}

// Kullanım:
int arr[] = {10, 20, 30, 40, 50};
int n = 5;
elemanSil(arr, &n, 1);  // index 1'i sil (20)
// Sonuç: {10, 30, 40, 50}

Eleman Arama (Linear Search)

Sırasız bir dizide eleman aramak için baştan sona tek tek bakmak gerekir. Buna doğrusal arama (linear search) denir ve O(n) karmaşıklığındadır. Aranan eleman dizinin başındaysa şanslısınızdır ve hemen bulursunuz (en iyi durum: O(1)). Ancak sondaysa veya dizide yoksa tüm elemanları kontrol etmeniz gerekir (en kötü durum: O(n)).

Linear search basit görünse de küçük dizilerde gayet yeterlidir. Ayrıca sırasız veriler üzerinde çalışan tek arama yöntemidir; veriyi önceden sıralamak gerekmez.

int elemanAra(int arr[], int n, int aranan) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == aranan)
            return i;  // bulundu, indeksini döndür
    }
    return -1;  // bulunamadı
}

// Kullanım:
int arr[] = {10, 20, 30, 40, 50};
int sonuc = elemanAra(arr, 5, 30);
// sonuc = 2 (index 2'de bulundu)

Diziyi Tersine Çevirme

Diziyi tersine çevirmek için iki işaretçi (pointer) kullanırız: biri baştan, diğeri sondan başlar. Her adımda bu iki elemanı yer değiştirir ve birbirlerine doğru ilerlerler.

void tersineCevir(int arr[], int n) {
    int sol = 0;
    int sag = n - 1;

    while (sol < sag) {
        // swap işlemi
        int temp = arr[sol];
        arr[sol] = arr[sag];
        arr[sag] = temp;

        sol++;
        sag--;
    }
}

// Kullanım:
int arr[] = {10, 20, 30, 40, 50};
tersineCevir(arr, 5);
// Sonuç: {50, 40, 30, 20, 10}

Sıralı Dizide Arama (Binary Search)

Eğer diziniz sıralıysa, her seferinde ortadaki elemana bakarak arama yapabilirsiniz. Bu yöntem olan binary search, O(log n) karmaşıklığıyla çalışır ve büyük dizilerde muazzam bir performans farkı yaratır.

int binarySearch(int arr[], int n, int aranan) {
    int sol = 0;
    int sag = n - 1;

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

        if (arr[orta] == aranan)
            return orta;        // bulundu
        else if (arr[orta] < aranan)
            sol = orta + 1;     // sağ yarıya git
        else
            sag = orta - 1;     // sol yarıya git
    }

    return -1;  // bulunamadı
}

// Kullanım:
int arr[] = {10, 20, 30, 40, 50};
int sonuc = binarySearch(arr, 5, 40);
// sonuc = 3 (index 3'te bulundu)

Zaman Karmaşıklığı Özeti

Diziler Nerelerde Kullanılır?

Diziler soyut bir kavram gibi görünebilir ancak günlük kullandığınız yazılımların birçoğunun temelinde diziler yatar. İşte somut örnekler:

Görüntü İşleme

Ekranınızdaki her görüntü aslında piksellerden oluşan bir dizidir. 1920×1080 çözünürlüklü bir ekran, 2.073.600 pikselden oluşur ve her piksel RGB değerlerini tutan bir dizi elemanıdır. Bir fotoğrafa filtre uygulamak, dizideki her elemanın değerini matematiksel bir işlemle değiştirmekten ibarettir.

Ses İşleme

Dijital ses dosyaları (WAV, MP3) dalga formlarını sayısal örnekler halinde dizilerde saklar. Saniyede 44.100 örnek alınan (44.1 kHz) bir ses dosyasında, 3 dakikalık bir şarkı yaklaşık 7.9 milyon elemanlı bir dizidir.

Veritabanı Sonuçları

SQL sorgusu çalıştırdığınızda dönen satırlar genellikle bir dizi yapısında tutulur. Sorgu sonuçları üzerinde sayfalama (pagination) yapmak, dizinin belirli bir aralığına erişmektir.

Oyun Geliştirme

Oyun haritaları, envanter sistemleri, skor tabloları ve parçacık sistemleri dizilerle yönetilir. Bir satranç tahtası 8×8'lik bir dizi, bir Tetris oyun alanı 10×20'lik bir dizidir.

Sık Yapılan Hatalar

1. Sınır Dışı Erişim (Out of Bounds)

C dilinin en tehlikeli özelliklerinden biri, dizi sınır kontrolü yapmamasıdır. Geçersiz bir indekse eriştiğinizde program çökmeyebilir ama bellekte başka bir değişkenin verisini okur veya değiştirir. Bu tür hatalar tespit edilmesi en zor hatalardandır.

int arr[3] = {10, 20, 30};

// ❌ Tehlikeli: dizi sınırı dışı
arr[3] = 99;    // tanımsız davranış — başka verinin üzerine yazabilir
arr[-1] = 50;   // tanımsız davranış — diziden önceki belleğe yazar
arr[100] = 77;  // tanımsız davranış — segmentation fault olabilir

// ✅ Güvenli: her zaman sınır kontrolü yapın
int index = 3;
if (index >= 0 && index < 3) {
    arr[index] = 99;
} else {
    printf("Hata: geçersiz index %d\n", index);
}

2. Başlatılmamış Dizi Kullanımı

C dilinde lokal değişkenler otomatik olarak sıfırlanmaz. Başlatılmamış bir diziyi okumak, bellekte o anda ne varsa onu gösterir. Bu değerler her çalıştırmada farklı olabilir ve hata ayıklamayı zorlaştırır.

// ❌ Başlatılmamış: içinde çöp değerler var
int arr[5];
printf("%d\n", arr[0]);  // rastgele bir sayı basabilir: -1297834, 0, 42...

// ✅ Sıfırlanmış dizi
int arr[5] = {0};        // tüm elemanlar 0 olur

// ✅ memset ile sıfırlama
int arr[5];
memset(arr, 0, sizeof(arr));  // tüm byte'ları 0 yapar

3. Döngü Sınır Hatası (Off-by-One)

En yaygın hatalardan biri, döngüde <= yerine < kullanmayı unutmaktır. 5 elemanlı bir dizide i <= 5 yazmak, arr[5]'e erişmeye çalışır ki bu sınır dışıdır.

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

// ❌ YANLIŞ: i = 5 olduğunda arr[5] sınır dışı
for (int i = 0; i <= 5; i++) {
    printf("%d ", arr[i]);
}

// ✅ DOĞRU: i < 5 (veya i < n)
for (int i = 0; i < 5; i++) {
    printf("%d ", arr[i]);
}

Dizilerin Avantajları ve Dezavantajları

Avantajları

• İndeks ile O(1) erişim sağlar, bu en büyük avantajıdır
• Bellekte ardışık saklandığı için cache-friendly'dir, yani CPU önbelleğiyle çok iyi çalışır
• Basit ve anlaşılır bir yapıya sahiptir
• Ekstra bellek (pointer vs.) gerektirmez

Dezavantajları

• Boyutu sabittir, tanımladıktan sonra büyütemez veya küçültemezsiniz
• Başa veya ortaya ekleme/silme işlemleri yavaştır (O(n))
• Kullanılmayan alanlar boşta kalır ve bellek israf olur
• Sadece aynı türde veri saklayabilir

Sonuç

Tek boyutlu diziler, veri yapılarının en temel yapı taşıdır. İndeks ile doğrudan erişim sağlaması onu birçok senaryoda vazgeçilmez kılar. Ancak sabit boyut ve kaydırma maliyeti gibi sınırlamaları, bizi ilerleyen konularda linked list, stack ve queue gibi dinamik yapılara yönlendirecektir.

Diziler ile linked list arasındaki temel farkı şöyle özetleyebiliriz: dizide elemanlara hızlı erişirsiniz ama ekleme/silme yavaştır; linked list'te ekleme/silme hızlıdır ama erişim yavaştır. Hangi yapının daha iyi olduğu sorusunun cevabı yoktur, her şey çözdüğünüz probleme bağlıdır. Bu bakış açısını kazanmak, veri yapılarını gerçekten anladığınız anlamına gelir.

Bir sonraki bölümde çok boyutlu dizileri (matrisleri) ve onların bellekteki davranışlarını inceleyeceğiz.