
## Dinamik Bellek Yönetimi ve İşaretçiler

### Struct Yapısı

C dilinde `struct` anahtar kelimesi, birden fazla veri tipini tek bir çatı altında toplamak için kullanılır. Yapılar (structures), aynı ya da farklı türden veri elemanlarının bir arada bulunduğu veri yapılarıdır ve nesneye yönelik programlamadaki sınıfların basit bir versiyonu olarak düşünülebilir. Ancak `struct` yapıları, sadece veri saklar ve metod içermez.

#### Örnek: struct Kullanımı

```c
#include <stdio.h>
#include <stdlib.h>

struct Kisi {
    int yas;
    char cinsiyet;
};

int main() {
    struct Kisi birey;
    birey.yas = 30;
    birey.cinsiyet = 'E'; // Erkek

    printf("Yaş: %d\n", birey.yas);
    printf("Cinsiyet: %c\n", birey.cinsiyet);

    return 0;
}
```

Bu örnekte, `Kisi` adlı bir yapı tanımlandı ve içerisinde bir `yas` ve bir `cinsiyet` değişkeni barındırıyor. Bu yapının bir örneği olan `birey` değişkeni oluşturulup değer ataması yapıldı.

### İşaretçiler (Pointer)

İşaretçiler, bellekteki başka bir değişkenin adresini tutan değişkenlerdir. C dilinde işaretçileri kullanmak için `*` ve `&` operatörleri kullanılır:

- `*` (yıldız) operatörü, işaretçi tanımlarken kullanılır ve bir işaretçinin tuttuğu adresteki değere erişmek için de kullanılır.
- `&` (ampersand) operatörü, bir değişkenin bellek adresini almak için kullanılır.

#### Örnek: İşaretçi Kullanımı

```c
#include <stdio.h>

int main() {
    int sayi = 10;
    int *isaretci = &sayi;

    printf("Sayı değeri: %d\n", sayi);
    printf("Sayı adresi: %p\n", (void*)&sayi);
    printf("İşaretçinin gösterdiği değer: %d\n", *isaretci);
    printf("İşaretçinin tuttuğu adres: %p\n", (void*)isaretci);

    return 0;
}
```

Bu örnekte, `sayi` değişkeninin adresi `isaretci` işaretçisine atanıyor ve işaretçi üzerinden bellekteki değere erişiliyor.

---

## Dinamik Bellek Yönetimi (malloc, calloc, realloc, free)

Dinamik bellek yönetimi, belleğin çalışma zamanında (runtime) ayrılması ve serbest bırakılması anlamına gelir. C dilinde bu işlemler için standart kütüphanede `malloc`, `calloc`, `realloc` ve `free` fonksiyonları bulunur.

### malloc (Memory Allocation)

`malloc` fonksiyonu, belirli bir bellek boyutunu ayırır ve başlangıç adresini döner. Bellek ilk başta rastgele değerler içerir. 

#### Örnek: malloc ile Dinamik Bellek Ayırma

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *dizi;
    int boyut = 5;

    dizi = (int*)malloc(boyut * sizeof(int));

    if (dizi == NULL) {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    for (int i = 0; i < boyut; i++) {
        dizi[i] = i * 2;
    }

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

    free(dizi); // Belleği serbest bırak
    return 0;
}
```


## Dinamik Bellek Ayırmada Tip Dönüşümü (int*)

C dilinde dinamik bellek yönetimi için kullanılan `malloc`, `calloc`, ve `realloc` fonksiyonları, herhangi bir veri tipiyle doğrudan ilişkili değildir ve dönüş tipi olarak `void*` dönerler. `void*`, herhangi bir veri tipine işaret edebilen genel bir işaretçi türüdür. Bu nedenle, döndürülen işaretçiyi istediğimiz veri türüne dönüştürmemiz gerekir.

### (int*) Neden Kullanılır?

`(int*)` ifadesi, `malloc` fonksiyonunun döndürdüğü `void*` türündeki genel işaretçiyi, bir `int*` türüne dönüştürmek için kullanılır. Böylece, ayrılan belleğin bir `int` türünde veri tutacağını belirlemiş oluruz. 

Örneğin:

```c
int *dizi;
dizi = (int*)malloc(boyut * sizeof(int));
```

Bu ifadede:
- `malloc` fonksiyonu `boyut * sizeof(int)` kadar bellek ayırır ve bu bellek alanının başlangıç adresini bir `void*` işaretçi olarak döndürür.
- `(int*)` ifadesi, `void*` türündeki bu işaretçiyi `int*` türüne dönüştürerek, işaretçinin bir `int` dizisini işaret ettiğini belirtir.

### Tip Dönüştürme Kullanılmadığında Ne Olur?

C dilinde `(int*)` gibi tip dönüşümlerini kullanmak zorunlu değildir. Örneğin, aşağıdaki kod da çalışacaktır:

```c
int *dizi;
dizi = malloc(boyut * sizeof(int));
```

Bu kod, tip dönüşümü olmadan da derlenir ve çalışır. C dilinde, `void*` türündeki bir işaretçi herhangi bir türe otomatik olarak dönüştürülebilir, bu yüzden tip dönüşümü kullanılmasa bile bellek doğru şekilde ayrılacaktır.

### Peki, Neden Tip Dönüştürme Kullanılır?

1. **Kodun Okunabilirliğini Artırır:** Tip dönüşümü kullanarak, bellek alanının hangi türdeki veriyi tutacağını açıkça belirtmiş oluruz. Bu, kodun okunabilirliğini artırır ve diğer geliştiricilerin kodun amacını daha iyi anlamasına yardımcı olur.

2. **C++ ile Uyumluluk:** C++ dilinde, `void*` türündeki işaretçiler otomatik olarak başka bir türe dönüştürülmez. Bu yüzden, C++ ile yazılmış bir programda `malloc` kullanılırken tip dönüşümü zorunludur. `(int*)malloc(...)` gibi bir ifade, C kodunun hem C hem de C++'ta sorunsuz çalışmasını sağlar.

3. **Derleyici Uyarılarından Kaçınma:** Bazı derleyiciler, tip dönüşümü kullanılmadığında uyarı verebilir. Bu, özellikle kodun güvenliğini ve taşınabilirliğini artırmak amacıyla yapılan derleme ayarları sıkı olduğunda geçerlidir.

### Örnek: Tip Dönüştürme ile ve Olmadan

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int boyut = 5;

    // Tip dönüştürme ile
    int *dizi1 = (int*)malloc(boyut * sizeof(int));
    if (dizi1 == NULL) {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    // Tip dönüştürme olmadan
    int *dizi2 = malloc(boyut * sizeof(int));
    if (dizi2 == NULL) {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    for (int i = 0; i < boyut; i++) {
        dizi1[i] = i;
        dizi2[i] = i + 10;
    }

    printf("Dizi1: ");
    for (int i = 0; i < boyut; i++) {
        printf("%d ", dizi1[i]);
    }

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

    free(dizi1);
    free(dizi2);

    return 0;
}
```

Bu örnek, hem tip dönüşümü ile hem de tip dönüşümü olmadan dinamik bellek ayırmanın mümkün olduğunu gösterir.

---

### Sonuç

- `(int*)` kullanımı, bellekten dönen `void*` türündeki işaretçinin istenen veri tipine dönüştürülmesini sağlar.
- C dilinde tip dönüşümü kullanımı zorunlu değildir, ancak kodun okunabilirliğini artırır ve C++ uyumluluğu sağlar.
- Tip dönüşümü kullanarak hangi türde bir bellek alanı ayrıldığını açıkça belirtmek, iyi bir programlama pratiği olarak kabul edilir.


### calloc (Contiguous Allocation)

`calloc`, `malloc` ile benzer bir işlev görür ancak bellek sıfırlanarak ayrılır. Bellek blokları belirli bir boyutta ve sayıda ayrılır.

#### Örnek: `calloc` ile Bellek Ayırma

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *dizi;
    int boyut = 5;

    dizi = (int*)calloc(boyut, sizeof(int));

    if (dizi == NULL) {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    for (int i = 0; i < boyut; i++) {
        printf("%d ", dizi[i]); // Sıfırlanmış değerler
    }
    printf("\n");

    free(dizi);
    return 0;
}
```

### realloc (Reallocation)

`realloc`, daha önce ayrılmış bir bellek bloğunun boyutunu değiştirmek için kullanılır.

#### Örnek: realloc ile Bellek Boyutunu Değiştirme

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *dizi;
    int boyut = 5;

    dizi = (int*)malloc(boyut * sizeof(int));

    if (dizi == NULL) {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    for (int i = 0; i < boyut; i++) {
        dizi[i] = i * 2;
    }

    boyut = 10;
    dizi = (int*)realloc(dizi, boyut * sizeof(int));

    if (dizi == NULL) {
        printf("Bellek yeniden ayrilamadi!\n");
        return 1;
    }

    for (int i = 5; i < boyut; i++) {
        dizi[i] = i * 2;
    }

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

    free(dizi);
    return 0;
}
```

### free (Bellek Serbest Bırakma)

Dinamik olarak ayrılmış belleği serbest bırakmak için `free` fonksiyonu kullanılır. Belleğin serbest bırakılması, bellek sızıntılarını (memory leaks) önlemek için önemlidir.

### Özyinelemeli (Recursive) Fonksiyonlar

Özyineleme (recursive) bir fonksiyonun kendisini çağırarak problemi daha küçük parçalara bölmesi yöntemidir. Bu teknik, özellikle yinelenen işlemleri gerçekleştirirken, karmaşık problemleri daha basit ve yönetilebilir alt problemlere ayırmak için kullanılır. 

Bir özyinelemeli fonksiyonun çalışabilmesi için iki temel bileşen gerekir:
1. **Sonlanma Şartı (Base Case):** Fonksiyonun özyinelemeyi durduracağı durum. Sonlanma şartı sağlandığında fonksiyon kendini çağırmayı bırakır.
2. **Özyinelemeli Çağrı (Recursive Call):** Fonksiyonun kendisini daha küçük bir problem için çağırması.

Özyinelemeli fonksiyonlar yazılırken dikkat edilmesi gereken en önemli husus, sonlanma şartının doğru belirlenmesi ve sonsuz döngüye girilmemesidir.

#### Özyineleme ile Faktöriyel Hesaplama

Bir sayının faktöriyeli, 1'den o sayıya kadar olan tüm sayıların çarpımına eşittir. Özyinelemeli bir fonksiyon kullanarak faktöriyel hesaplaması şu şekilde yapılabilir:

```c
#include <stdio.h>

// Özyinelemeli fonksiyon tanımı
int faktoriyel(int n) {
    if (n <= 1) // Sonlanma şartı
        return 1;
    else
        return n * faktoriyel(n - 1); // Özyinelemeli çağrı
}

int main() {
    int sayi = 5;
    printf("%d! = %d\n", sayi, faktoriyel(sayi));
    return 0;
}
```

Bu örnekte, `faktoriyel` fonksiyonu kendini çağırarak `n! = n * (n-1)!` hesaplamasını gerçekleştirir. Sonlanma şartı olan `n <= 1` sağlandığında özyinelemeyi durdurur.

#### Özyineleme ile Fibonacci Serisi

Fibonacci serisi, her sayının kendisinden önceki iki sayının toplamı olduğu bir sayı dizisidir. İlk iki sayı genellikle 0 ve 1 olarak başlar. Özyinelemeli bir fonksiyon kullanarak Fibonacci serisini hesaplayabiliriz.

```c
#include <stdio.h>

// Özyinelemeli Fibonacci fonksiyonu
int fibonacci(int n) {
    if (n <= 1) // Sonlanma şartı
        return n;
    else
        return fibonacci(n - 1) + fibonacci(n - 2); // Özyinelemeli çağrı
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci(n));
    return 0;
}
```

Bu örnek, Fibonacci serisinin `n`'inci elemanını özyinelemeli olarak hesaplar.

---

### Dinamik Bellek Yönetimi ve Malloc, Calloc, Realloc Örnekleri

Dinamik bellek ayırma fonksiyonları, bellekte programın çalışma zamanında veri yapıları oluşturmayı sağlar. `malloc`, `calloc`, ve `realloc` fonksiyonları ile dinamik bellek ayırma yapabiliriz.

#### malloc ile Dinamik Bellek Ayırma

`malloc` fonksiyonu, belirtilen boyutta bellek ayırır ve ayrılan belleğin başlangıç adresini döner. Ayrılan bellek sıfırlanmaz, rastgele veri içerebilir.

```c
int *dizi;
dizi = (int*)malloc(5 * sizeof(int)); // 5 elemanlık bir int dizisi için bellek ayırır
```

#### calloc ile Bellek Ayırma

`calloc`, bellek ayırırken aynı zamanda ayrılan belleği sıfırlarla doldurur. İki parametre alır: kaç tane eleman olduğu ve her bir elemanın boyutu.

```c
int *dizi;
dizi = (int*)calloc(5, sizeof(int)); // 5 elemanlık bir int dizisi için sıfırlarla dolu bellek ayırır
```

#### realloc ile Bellek Yeniden Boyutlandırma

`realloc` fonksiyonu, önceden ayrılmış bir bellek alanını belirtilen yeni boyuta göre yeniden boyutlandırır. Önceki bellek alanındaki veriler korunur.

```c
int *dizi;
dizi = (int*)malloc(5 * sizeof(int));
dizi = (int*)realloc(dizi, 10 * sizeof(int)); // Bellek alanını 10 elemanlık yapar
```

---

### Pratik Ödevler

1. **Özyinelemeli Faktöriyel ve Fibonacci Fonksiyonları**
   - Hem özyineleme hem de döngü ile faktöriyel ve Fibonacci hesaplamaları yapınız.
   - Her iki yöntemin performansını karşılaştırın ve sonuçları açıklayın.

2. **Dinamik Bellek Ayırma ve Yönetimi**
   - Kullanıcıdan bir dizi boyutu isteyin ve `malloc` veya `calloc` ile bu boyutta bir dizi için bellek ayırın.
   - Kullanıcıdan dizi elemanlarını girmesini isteyin ve elemanları ekrana yazdırın.
   - `realloc` kullanarak dizinin boyutunu artırın ve ek bellek alanını kullanarak yeni elemanlar ekleyin.
   - Bellekteki tüm veriyi ekrana yazdırdıktan sonra belleği serbest bırakın (`free`).

3. **Özyinelemeli Sayı Toplamı**
   - 1'den n'e kadar olan sayıların toplamını özyinelemeli bir fonksiyon ile hesaplayın.
   - Örneğin, `toplam(5)` fonksiyonu `1 + 2 + 3 + 4 + 5 = 15` sonucunu döndürmelidir.

4. **Dizi Elemanlarını Tersine Çevirme**
   - Kullanıcıdan dizi boyutunu ve elemanlarını isteyin, dinamik bellek kullanarak bu diziyi oluşturun.
   - Diziyi tersine çeviren bir özyinelemeli fonksiyon yazın ve sonucu ekrana yazdırın.

5. **Dinamik Bellek ile Matris İşlemleri**
   - `malloc` veya `calloc` kullanarak dinamik bir iki boyutlu matris (örneğin 3x3) oluşturun.
   - Matris elemanlarını kullanıcıdan alın ve matrisin transpozunu hesaplayıp ekrana yazdırın.
   - Bellek serbest bırakmayı unutmayın (`free`).


Pointerı tanımak ve Özyinelemeli Fonksiyonları anlamak üzerine bir çalışma

Özyinelemeli Fonksiyonlar ve Pointer Kavramı


# Diziler ve Matrisler

## Bellek Düzeni ve Diziler
Yazılımcı açısından bellek, her birinde belirli uzunlukta verilerin saklandığı gözlerden oluşan veri tutma birimidir. Her bellek gözünün kendine ait bir **bellek adresi** bulunur ve bu adres aracılığıyla bellekteki veriye erişilir.

Aşağıdaki kodu inceleyelim. Kodun altında açıklamalarını bulabilirsiniz:

```c
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int var = 10;
    int *ptr;
    ptr = &var;

    // Var'ın adresini yazdırır
    printf("var address: %p\n", ptr);
    
    // Var'ın değerini yazdırır
    printf("var value: %d\n", *ptr);

    return 0;
}
```

### Açıklamalar:
1. `int var = 10;`  
   `var` isminde bir tam sayı değişkeni tanımlanıyor ve değeri `10` olarak atanıyor. Bu, bellekte bir alan ayırır ve bu alan içinde `10` değeri saklanır.

2. `int *ptr;`  
   `ptr` adında bir **pointer** (gösterici) değişkeni tanımlanıyor. Pointer, bellekte bir adresi tutabilen bir değişken türüdür.

3. `ptr = &var;`  
   Bu satırda, `ptr` pointer'ına `var` değişkeninin adresi atanıyor. `&` operatörü, bir değişkenin bellekteki adresini alır. Böylece `ptr`, `var`'ın bellekteki yerini gösterir.

4. `printf("var address: %p\n", ptr);`  
   `printf` fonksiyonu, `var` değişkeninin bellekteki adresini yazdırır. `%p`, pointer türündeki bir veriyi yazdırmak için kullanılır. 

5. `printf("var value: %d\n", *ptr);`  
   Bu satır, `ptr`'nin işaret ettiği adresteki değeri ekrana yazar. `*ptr`, `ptr`'nin gösterdiği adresin içindeki değeri temsil eder, yani bu durumda `var`'ın değerini yazdırır.

6. `return 0;`  
   Program başarılı bir şekilde sonlanır ve işletim sistemine `0` değeri döner.

### Özet:
Bu örnekle pointer kullanarak bir değişkenin bellekteki adresine ve değerine nasıl erişileceğini öğrendik.

---

## Diziler

### 1. Statik Dizi Bildirimi
Dizinin boyutu biliniyorsa, **statik** olarak tanımlanabilir. Bellekte sabit bir alan ayrılır.

```c
#include <stdio.h>

int main()
{
    int var[3] = {1, 2, 3};  // 3 elemanlı bir dizi

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

    return 0;
}
```
Bu örnekte, `var[3]` dizisi bellekte sabit bir yer kaplar ve içerisine 3 adet tam sayı değeri atanır.

### 2. Dinamik Bellek Kullanımı ile Dizi
Eğer dizinin uzunluğu çalışma anında belirlenmesi gerekiyorsa, **dinamik bellek** kullanılarak dizi oluşturulabilir.

```c
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *var;
    int size = 3;

    var = (int*)malloc(size * sizeof(int));  // Dinamik bellek ayırma

    if (var == NULL)
    {
        printf("Bellek ayrilamadi!\n");
        return 1;
    }

    var[0] = 1;
    var[1] = 2;
    var[2] = 3;

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

    free(var);  // Belleği serbest bırakma
    
    return 0;
}
```

Dinamik bellek kullanımı, bellekte çalışma anında yer ayırmayı sağlar. Örnekte, `malloc` fonksiyonu ile bellek ayrıldı ve `free` fonksiyonu ile bu bellek serbest bırakıldı.

---

### Dizi Bildirimi
Diziler tek boyutlu yapılar olup şu şekilde bildirilir:

```c
int var[10];  // 10 eleman tutacak bir dizi
```

Bir dizinin bellekte işgal ettiği alan, dizi boyutunun veri tipi uzunluğuyla çarpılmasıyla hesaplanır. Örneğin, `var[10]` dizisi 10 elemandan oluşur ve her eleman `int` tipinde olduğundan her biri 4 bayt yer kaplar. Toplamda:
```
10 * 4 = 40 bayt
```

### Dizi Elemanlarına Erişim
Bir dizinin elemanlarına indeks numaralarıyla erişilir. İndeksler `0`'dan başlar ve dizinin boyutunun bir eksiğine kadar gider. Örneğin, `var[10]` dizisinde son eleman `var[9]` olur.

```c
#include <stdio.h>

int main()
{
    int var[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};  // 10 elemanlı bir dizi

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

    return 0;
}
```

---

## Matrisler

### İki Boyutlu Dizi (Matris) Tanımlama
C dilinde çok boyutlu diziler tanımlanabilir. İki boyutlu diziler (matrisler), satır ve sütunlardan oluşur.

```c
int matris[3][4];  // 3 satır, 4 sütunluk bir matris
```

Bu matris bellekte toplamda `3 * 4 = 12` eleman içerir. Her eleman `int` olduğundan her biri 4 bayt yer kaplar. Toplam bellek boyutu:
```
3 * 4 * 4 = 48 bayt
```

### Matris Elemanlarına Erişim
Matrisin elemanlarına satır ve sütun numaralarıyla erişilir. Örneğin, `matris[1][2]`, matrisin 2. satırındaki 3. sütundaki elemana erişir.

```c
#include <stdio.h>

int main()
{
    int matris[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    for (int i = 0; i < 3; i++)  // Satırları dolaş
    {
        for (int j = 0; j < 4; j++)  // Sütunları dolaş
        {
            printf("matris[%d][%d] = %d\n", i, j, matris[i][j]);
        }
    }

    return 0;
}
```

Bu örnekte, `for` döngüsü ile matrisin her bir elemanına erişerek ekrana yazdırıyoruz. 

--- 

Bu yazı diziler ve matrislerle ilgili temel kavramları içermektedir. İlerleyen derslerde bu konuları daha ayrıntılı inceleyeceğiz.

## Alıştırmalar:

1. C programlamada tek boyutlu ve iki boyutlu veri yapıları arasındaki temel farklar nelerdir?
   
2. Kayan noktalı sayıları saklamak için bir dizi nasıl oluşturursunuz ve bu dizideki çift sayıların toplamını hesaplamak için hangi yöntemleri kullanabilirsiniz?
   
3. Bir dizide saklanan pozitif tam sayıların ortalamasını hesaplama sürecini tanımlayın. Bunu C'de uygulamak için hangi adımları izlersiniz?
   
4. C'de iki vektör arasındaki skalar çarpımı nasıl gerçekleştirirsiniz? Bir kod örneği verebilir misiniz?
   
5. Çok boyutlu dizilerin programlamadaki önemi nedir ve belirli değerlerle bir matris nasıl başlatılır?
   
6. Farklı markaların aylık satış verilerini görüntüleyen bir program tasarlamak için hangi işlemleri dahil edersiniz?
   
7. İki boyutlu bir dizide, her marka için hangi ayın en yüksek satışları olduğunu nasıl belirlersiniz?
   
8. Bir matrisin maksimum değerini bulmak ve ardından ilgili sütunda minimum değeri belirlemek için hangi yaklaşımı benimseyeceksiniz?
   
9. Farklı dersler için öğrencilerin notlarını saklamak amacıyla üç boyutlu bir dizi nasıl uygularsınız? Ortalama notları bulmak için hangi hesaplamaları yaparsınız?
   
10. Dizi ve matris işlemleri için kodun düzenlenmesinde fonksiyonların önemi hakkında tartışın. Kodun okunabilirliğini ve tekrar kullanılabilirliğini nasıl artırır?


Diziler ve matrislerin temel yapılarını hatırladığımız ön hazırlık dersi.

Diziler ve Matrisler


# Bilgisayar ve Yazılım Dünyası

## Giriş

Yazılım dünyasına adım attığınızda, temel programlama becerilerini kazandıktan sonra sıradaki adım, programları çalıştıran bilgisayarı tam anlamıyla tanımaktır. Bu süreci, bir müzisyenin enstrümanını öğrenmesine benzetebilirsiniz. Bir müzisyen, enstrümanını ne kadar iyi tanırsa, ondan o kadar iyi performans alır.

Diyelim ki elinizde, piyano çalmaya hevesli bir öğrenci var. Bu öğrencinin yeteneklerini en üst düzeye çıkarmak için, piyanoyu ve müzik teorisini iyi anlaması gerekir. Hangi tuşlara nasıl basacağını, hangi notaların hangi duyguları ifade ettiğini kavramadan, etkili bir müzik icrası mümkün olmaz.

Aynı şekilde, bir bilgisayara işlem yaptırırken, bu işlemi en verimli ve doğru şekilde gerçekleştirmek için bilgisayarın çalışma prensiplerini anlamanız gerekir. Bilgisayarın hangi koşullar altında nasıl tepki verdiğini, hangi işlemleri hangi hızda gerçekleştirdiğini kavramadan, ona doğru komutlar vermek zordur. Bu nedenle, bir yazılımcı olarak bilgisayarın temel işleyişini, yani donanım ve yazılım arasındaki ilişkiyi anlamak, yazılım geliştirme sürecinizin ayrılmaz bir parçasıdır.

Bizde bu yüzden çalıştığımız bilgisayarı daha iyi bir şekilde tanıyacağız ama önce yazılım ve programın ne olduğunu bi açıklayalım.

# Bilgisayar:
## Donanım ve Bellek:
Donanım dediğimizde, bilgisayarın fiziksel parçalarını, yani aktif ve pasif elektronik bileşenlerin bir araya gelerek oluşturduğu birimleri kastediyoruz. Bu birimler arasında:

* İşlemci (CPU): Bilgisayarın beynidir; tüm işlemleri gerçekleştirir.
* Ana Kart: Tüm donanım bileşenlerini bir araya getiren ana platformdur.
* Disk: Verilerin kalıcı olarak saklandığı yerdir.
* RAM (Bellek): Verilerin geçici olarak saklandığı, hızlı erişim sağlayan bellek birimidir.

Dersimiz kapsamında en çok tanıyacağımız bellek, program parametreleri ve kodlarının üzerinde saklandığı donanım birimidir. __Bellek ve saklama birimleri kesinlikle birbirleri ile karıştırılmamalıdır.__ Saklama birimleri, verilerin kalıcı olarak depolandığı Disk, USB gibi cihazlara verilen isimdir. Bu cihazlar, bir kitabın kütüphanede saklanması gibi, verilerin uzun süreli muhafazasını sağlar. Buna karşın, bellek (RAM), kısa süreli olarak veri depolayan ve bilgisayarın hızlı bir şekilde işlem yapmasına olanak tanıyan birimdir.

Bellek, ders notlarını sınav esnasında hatırlamak için geçici olarak kullandığınız hafıza gibidir; işiniz bittiğinde, veriler kalıcı olarak saklanmaz.

Ancak daha bellek normal saklama birimlerine göre veriye daha hızlı erişim sağlar.


![gucci takımı](https://notes.joeyh.dev/cs132/img/hierarchy.png)

## İşletim Sistemi:
İşletim sistemi bilgisayar donanımı ile kullanıcının programlar arasında etkileşim kurmasını sağlayan yazılım ağırlıklı sistemlerdir.

## Veri Yapıları:
Veri yapısı verinin veya bilginin bellekte tutulma şeklini veya düzenini gösterir.
Tüm programlama dillerinin;
* Tamsayı (int),
* kesirli sayı (float),
* karakter (char) ve
* sözcük (string) saklanması için temel veri yapıları vardır

Ayrıca, programcıda temel veri yapıları dışında yeni veri yapıları tanımlanması için programlama
dillerinde bir çok özellik vardır.

* Struct
* Class
* Union

## Veri Modeli:
Veri modeli, verilerin birbirleriyle ilişkisel veya sırasal
durumunu gösterir.

Bilgisayar ortamında uygulanacak tüm matematik ve mühendislik problemleri veri modelleri ile çözülebilmektedir. _Problemlerin çözümlerinde veri modellerinin kullanılmaması durumunda program tasarımcısı işte "BELLEK YETMİYOR" "BİLGİSAYAR YAVAŞ" diyerek çekiliyor :)

Önümüzdeki derslerde bu veri modellerini de öğreniyor ilgili uygulamalar ile pratik ediyor olacağız. Ancak kulak aşinalığı olması açısından __Graf__ ve __Ağaç__ modellerini bir kenarda tutabilirsiniz

![ağaç yapısı](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAANIAAADwCAMAAABCI8pNAAABAlBMVEX///8AAAD8/Pz5+fnz8/Pq6ur6+vqMjIx/f3/u7u7x8fHT09Pb29vm5ubh4eH29vZOTk6ysrIqKiq6urpjY2OoqKg0NDQ/Pz8vLy+wsLDDw8N5eXkfHx9aWlrQ0NA6OjqYmJhtbW2goKAmJiaSkpJnZ2fAwMBKSkqbm5sSEhJWVlaEhIRzc3MZGRnv3NwTExPmx8fb59vPl5etPj7arq7pz8/AcnLw3Ny0UlKwR0fSo6P47e25YmLJiIiqKyuoMTG9a2uIwojP5M++2r4xlTGVwpVormhFo0W8X1+Ju4ndurqnz6fDfn4AiQDt9u3Ljo5UoVSjTU2cOjqPdHSVbGwAHBwFzv7mAAAVEklEQVR4nO1dB5fbNrYWKXJIir33ql7G4+cysT32JrtJdr2ON8nue+///5UnaiYeAgTAIkozOi/fcTkiCRLl4uLiNoxGf+JP/D8Erd69ePvly9sXd3f0U9dlENy9fPX++/fvPn78/P71+08v7566Pkfj7sPHv3z98mI/QHu8ePnpL+9eXXijXn7/+tW4Qm303Zv3r988XX2Ohvrq+w9q7eqH118vdqDGtz+8RV1/cfvDpbbp9hZTc/rrZbZpfHuLv/n1hzpBPn+8IY2E+sOH89VkKNy9f0m6/d3ryyO9V5+An3/761//Bt7/es7aDIJ3wCD9+NPPP//0Y/XK3btLG6a376ri3NXffx6Nfv5H9QH6M5EwnyFegezuav/3n/8An3h1xuoMgU+1Cv/4EziZvny9OlttBsFXWJD78adfwAtvL21puoVmyi8gc9jj7ccL4w/QKP3yrx9//fVX4NLb2wsbpd9+q/769ad//f77738Hnvjy6cK2uG9+qP6i/+sA4InfLm3bdPe+YaZcvUduPJ4zPjcMwsuPFzaV9lVuEHg+X54ofnVLlA4+vDtXRQbEC9Jkefvu4mZSibf4Nr1ommnPFS9fY4Tt795faIvKNqH0kOMPl9uig3qrNlBvbz9+9xR1GQrjN//+CMyol7f/eXNxCxKISfzfn19/fvXmy9sXL9+8+vj64//87/ip63Qkso06+u7Lh99uP7+7/fThy3f0aM4/dZ2OA7sODv/T6t2dei95s1TwlDU6Gkuufq3QhPNXZDDYHkK/oGrZ2SsyGGRjgbocXMvnrslgCEP0xnWrnbkigyGIFPSNsWOftyZDYewWuFsLD9PYZ45Zir1F7y5ycUpwZFdCiS5wcbqKZ6Tbdnp5cpG/ZEm3aSc7U0UGA0shl6RHyOsLIz16t2t6hIsvi/QCqlGOY5cXtTixjtn8kEkxp6/JYNhabWq7yy9H0S+txTaPCU0s5PngakNckh7hu0RG/4xQOC0fVK3tSSsyGBSv9Yoj3kinrMlgmG/bz3ouPmFFBkNgdNmzGtgNyPOB0GZJekSQPv+d02rZ6XGab5ScnhpJ1JEvy15ympoMhrjz3DDTZysXTUqJwV92r99mtf9HfI66/8SbT9g+VCRPRZWnniOXMCnKS3tJA7Y1pajnuNNYUXvkPaQBZVeWtIav0bFgrLJi1DTrule1jUPB9UlqdRTY9aFm1LKjvluZ35ejnp+eXLqv2LazoYXh7kv6p6jVUSgO9Sp67FPp+6LPT/+63Ncq7SkIiG7JH57Frp2WJTGRlAOt7Ss17735kfe8JS1LTxQpESXlqdZdiYsdz9v/cXN9zFJUeIS9crKl1sFID5eHF3oa9wR6S9VMvTwY0yXkzDVc6siNj045nssphxeOktyJ/POKfrTpLO3qJxPL4I5SjQir6011o6X6mnFOHkiHkQ1RmZDE7hG7BElzE6hLBP26+4rQF8xGQzACuoh6d2tCcQgymyy1MwmzkxgjjwVGpz36I0QKU3C7PM84hTFu4vpOr15VDJwYzuRn2cYnBAVIL+s/HeIFh6v+xNweaqTjb9J4IzoegUeQWBPv9MrLzCXdXaTdBWqH1A10jvBCGhYMqC/RZ1lWndpX3Y0RogFwb1qfFdULi+jU0lGyrvIGQct3LrA557iu0ucW5J+BZQEMXU5PTXl6XPXdkvY9uAVW2CTtyHbpGJib6hbm5/ypKW8F6/BpkMlBZNQM1gVGgfXWkPg7m3d7YVfQW3gum2AnSiT2hYLigXNlLLs7QH2x2nR7YVfQIbxObEFSV7qyPGkKTz4mBcyidjcle3fMMvA3G06A35LTVSdem3zjHFjLV6c2QfmQ12AAEaLYtUmqBrAXRRqJGfAAd2qZyNyAejoT2lEEGjhqzZgDAp653EECX7jq+MKuED1QZlWhmcC1NKY/YgauS2PohbJ76nWJtggi3h7TztKD7BFXsiA9uW7FrnEo4G5nukP7kn+Dqp1e/z92CbTNRj02gcGUQFp6Dzm4MxIK601D872WRUIpeXoWnUqxxvQqzRm99tUCbuc/UpbnUSvTmYHc144x15vBaiFy7y9tzmVuV+cRgq+xodGb3SqbDWLKBGl4Jk2yuk2DqOZwp0+t7szuGyZ8ZEOcVODPZp8R5u5kJOXUTPrWBFoJ3GONrb7nmMo3yWQi2dSmlVPfAGCtuOQBV2ZuxJm9EKVAL0LHXR2t9lDsZbpb6YEkLvwsNjaLc+nEZc166EpVTrTUiSLDtWxZGO12RzsUTxQ9d40ocqJ5IJ9NyS/eVJZ6pqoFZwyypNQF3Mm1Qo9IbqqWSxYgNtMbrGOL88U3BRQwEgHA9mhrsGVxYQz1pib4kJJuB24k2OlQpjuhn269M2gbjh71oHVjuFDM5VlWJDqjIDatwhK0uhlqI5CfxTN5V9N6mjXteHI9kN+3fWLdXQnBimtC2DavPTYbSJvTWXXWHexmXhfgrDqZTbyedkAI9PWpvUMnBkL4V1A6g2Cg7k2H6RospDVK7bOIUM8ONLH502q6EiNDXbaR80Y5xlXgEWaraKG+CNZIK904RHPsFdFK2BadlbZd4K/RZM16mO1MnA3wVeWE4dGZg5FysB+VogHUo4x1smgtHutip89x1M4dv3Pav+REqqGr3RI7/jGWJwnLAXrYbhvW1Q3CfInXkGCmWIlgerxiJziJR7K6ifFsRyXFhw3gq8Cegj/I2pzQ2TrJ3KgOEKx9AvV+4hI1nbuQdNeOj9Dp3WP4uKYkJftkLInKE9U6Oh7OH9qQHlyT6yRdkzlAEB07TEKnkMJm2AR+doB+0/CG2dFKnmGTJ9hE82RJkKumQBa1W5QjAqX+gR7KHb7AG8VKBBa3aJZXFs6RhDPb6WE8jFpc3UbkygRlhITBB2RZmd6VOyehp85osXUPgRiD7FSYndvQvclDdE7DeqpME1qPeq4u8f0nnCEcBIScnMZlVOrF2wUq2e6ud7yLGB2+gTKkdcBhJspa3JiLXXIOn2vS6o+zQzxcz9Tuh8LU7qi9rVkaEZVo27wxkLXya0TpYY9geahU2nOCC4finV1dACyp7X64Vy1kaOEQ9dc07/OHGdeXly/KwkcpVcwy/sho9YqrsE2Y2x/xcL2lT+2YwqNSv92Ch/2BGUXlLUbTPIRi5n2ng3JNHZX46z4cb93OYJBRRqsZkpQd3XvFpWfUMfZfeflA+a2WNpvKWr62nHW9t3LCsrX+TFB4ZxrtYWi2fE9A2UOLUjzxMrIYlrbhPW7WGieyrTbjexr1VaVID9+buhXHgiYwiu1SZbGpw0lkXiQXqTvTA1GRksDeTee6WqYMu18F8LFqkh47caYHiagooq/73MbL/Tb9r7sbzQn9IJEUMdD5VPNbEeLEjI3Qz8SylLl1U8K36MLTgseXjqViHQcj/hDkm2D7Xcqn7gLsKkHyXY9vrp4ZUabyKE/LpkOghG9YLCO7WipIHdwSxcT1hDrczYxaOyv8EstkUYisuzRfw14ytZdf10Z+ccM3McHVdQFVh144aL2h4oUIAW6/qJFqlixjLNMINjGJ+ibzJYJnKRpB8zQqte0ofagQo6Lo5JRDjcVYTFf4Ji0im9CpAkeyVFgWcnQnFkn3NOLR+lAmdGul1HSLkSEVvKbBbuLrvoFdD3cbzGjQyx2+TTOcnyKdb+CeD/FLPjZVmk7yO71HgjME+A6W9xJSuppTPM/ZQOKNSEo6ukJrP5Q2NlNMokw5JWzmAw8zgCopt6EEihPjOUmCo5FBk2orWxHNI/tjRdx57erm+AMKbDhoidm8SnoBVf2l8gY4df0N4lU2pGufcCW9JNsQJFMWlZB6Ak1Cwc6qXSxiUjCBIv6CC4HNiURVSxVAPgXbD0C33wmCxBjYDUBZzsrYZ+nKBWk4RHS5CNrWWVin5CIJTAIIUsmZiVvtvvG8MgfVOdBcpZyH1Qu0Vt+rKbUI2nDfJH3fFRoosssIRjADtA40n0H3t0itBBjZY/MjGowiySr3Jxo8Cj74zlm918QaiyyblIc1H6+RUx/iOcDTAsqeg0lIAqRPDQ+8uLDUfdcA06cinAsuxKbVLUjMfl2tb9Zy95VNKt3uQuhhtz7E4EDqU1nyAAWMoqH4QA50rOysgg3QNWLFOMjCKjEdWk2CvCZZwBFl900K96M0h3b0CGMQ6F/ix3DGQgHpxwLF3UhmAHrMKc5jLQUHHKXAHNFAG2y+Nkp+CLPhsklJPK6NilPXgIHTf5HS0OySkEkC5vASnIHVSiqjJACiIG2mRZYDjayFYu5HeQN9VY13471cYoqwQuGmLkCAS9pkvlDArYiJNBSEoL8Oa/LgdDYradfVuPrVcaD7PtCzdFyfDhKsN2AXi0m55zGhNWWCkAW2YOVkcwFS/gypCARDzpgkgGZDUTWk2WRd4jhCrUstrf0zxLokwWISRNdowUcC8v/VbTG7Ki0lEVGPaqJSYeseqcg3CCiFEUNOlScZaMGH7G0uTaulmA2xy5GeGWyrwxtoDqXJocn+6xnGv3KGORrjHj6oYjdTghhposeQEFH2iAD9kETyXMA6GhHzIDKwmmGOn01YL7pZc44ZGaf2Lgxsh6t5hrtlEiLVLHjgBQ2371LnOF/Hca41jFMSZbiahyFu+s7g5aHyxS3Wq8qu+6EnOI/R3MLudxl+SrQ9FBRebyFoGE2VTToHR8UFpZprBMWYEYoJyBYxM2lB4RU6kktssOTOEe1lOLJSmfEs1Adna+TkSNwcpqMrM61Ld2DFdtRKQlTtKtlSDcpJdukGcMoLSds0zE8hnCZwlSQLNwPkbTQDuiDJp3qT4W8cbKKdCY0k6+dU3mQsEbSdAyYJlfh10WhlH+tT8NUsT8iCRsuaEdvsIWfblci5U66Nun4s5ZTnhr44KcsJop27xnUoNNlhmf3eSuCvtYcccbSSbaa7VpYMlptqnHRfis1iY04uJWVz95BZz9FCv7UlYaJzuZYakWdERrrZcYvmrqD5uKQ6uSgz+RmG5y13q9ammUkRap7nTQ3P3WUt7EzsIf+h3NUHdVImYkwkpWWgXvbtNIGJovA7RenoKqUqkpTqyjM6zE1fV3lHT//bZ5Wa25wCRNa3Sc/osBxpCa5YPZt0tMPYcBi7GXihZ5NOHSLTHkwMt6Bnk9znkkeY3tU0Cz2b9GxONOLqlqWeTTpD6pRW8BG5G3s2aYM1RJ0VASqXRc8mDRI6dDT2Kz7ias8mWdlRdRkG9BTpL9azSflxLnmDgHHRlejZpN0Z8yRgoOIslj2bxD/9oVMznGNAzyZtn7xJKPZ9j55Nmp0ogK41gmusiqxnk1ZP3CQFlXLpAT2bVDR5Op8WLClPe88m+U964hSzxOpdR72bZOY9feeHgBoS9YE9mxTgFcEnBz1ziUqWnk1KiA44p8WqIa1uzybV7MXnw6LJEtWzScqZsvPXkcAJfWqY9RMDJk/VJJGcEnJSFPZGs4uioxu8FCyKiN/m+vlPyJm4DYnRHzzrpx31jJuHcsMlQGuLcd50MvVD5E/X7EIPIXq4ZBmnQaaXTtCNvgRSv8CfiXYfZdCzcv3gUcWISxvznEzu4y87LzE2dXRgVlcEa4oKEc54NRxO2OsedZ6UIVAoE+3pcAjWmLew6QRllGcPjX15ZOBp8nNgIKX3s745mqQ8NXDaQ7TR96/PuhfrD/2BybbInj+jqM4nYOxxdX1ETFcPqA8xyl4LhzBp3YfuStJ2B8iXQ8DVRGBZYfLQ3VJTZNofoBlB9ZbihOk8ToxEcezkdI1KfD7W0lSLt/pBQ1wGo665JtPwJLC31kaj1suNxdsNwfoAFJ2zNMrQ4tBOTiISLaw1FdqmmJh2TkVlTNOeg2soHw+g1M6l1rvCXyR6mYY3otK2foti7lFWYZqLhc2vqcFyPn4DHaxvqj4ZyZxyeaoph5I8oyLLBsiG1ucRhQoMgyBqVNU1VQqnlD/oSKkzioMErSCn3IaMD6bhojwWpGKz1hu23/bNHOImCkc1Btx1gYXIPKKa1IxUMTakbEybBT2qp66sIqOK+qsTtLtUP2ws5D6MTWvu/o+QPVJ+c4abEsTr2RS9FlnkIML2ULF7B8XBSpTJumE++0gr1AErnAspbWHTvXUD9gvlyoSx4SfNSRFMD9Om4BrLdYRhjh8QSLXL0CyCbZNmwcbkjCAd8x3cDLEdzEluzvQSaR62+DY6Uk5DPWWnJGGBR/lhdsQYtCXTibmodm6AitmRYS9iISgrL0EbK9pFUBhtQUQhAL/hcJg+gDIdS8trgJUqqC0tD1G8bJVxJ4kLGyn9ejTOSDIgRjlLq79qLe4B0FhKr+AtLOJAONaAHe/Egxo4hCeJgmDWOhQPvLCW0O9jleTQ4USC4a1ASkNkcg4o+Mp9k2p2VwERwr6CImpWNkgmSXpsTjcohpCWAih7cFHf/4GBkyUwo8TMa5MJPtKOm0CUn+BjqltCrnUKeMjASE9HMOpnxGGaNOIy+IoKtrLQGTsFTuKScHHTrcHWMnzR4Nnifj0spn4JQ3j0tiZijHfA9C8sywVPHBaPbtIYiE4bCexIBnUIiJMI6zmsxcOcrjWJQWSSAGMqVUatzaWj9f5gWKjv5Rm4PiLOuBPhnKsCX4bgS0s43wWLOHpN30GM3QQj4JELYTdAR1wyEAtVUZvUTUu9fII4ciFwyIJHdrxTkeQQe0VEhRvZLfWqOUISRI1cBTQuu0QXYM+aPmCFtDm3S04mIWVQVAz/I5IhMuWbhOOrRwo6D4ne5sAsFhl6NJIQsaPfQBtDeFESz4LB3KP5uJEvMTHG3DQjnC2YuYO4QYj4nsmuMTVnYpzH1x+gl7hdN7PEGpQWw+TTLMP9MBwsW+PHAplM6BGKwWO3RfISo9MI+imhUVhMM8R4Mxwxp1zhrbANZgpsQqsSkssjil6ZvVMiIhC4Vq1PFcttiJOyUFu8w+s2GzIB7d9d4y9jHh0M2BfM3Ciqk5ZWtxExTvnw0MJ1fVhHf6X6S5JH2D3Gs+stW3k/reoROvXUETAtY7sQFVlgZSUxdzdhmy6jzbm3KcpMcrIgyIokBoUV5XYbS4SYG5a5L8juy4nB1tucIJ5ETYo4ddyNljrO3G49T5MFF7uO42qb/b+pNjNbGyESPU/3Jcpy2io4Ouc6GqrAKuZCZoVOBh96X4yVTFNkBaHbJns8EdjA3A/U0zmw/Yk/UcX/AXWxa+kfXqbtAAAAAElFTkSuQmCC)

__Kullanım durumları__
* Veriniz üzerinde hızlı arama yapmak istiyorsunuz. yukarıdaki
gibi bir ağaç modeli kullanabilirsiniz.
* Şehirler arasındaki mesafeleri hesaplayan bir yazılım
geliştireceğiniz durumda ise graf modelini kullanabilirsiniz.

Elbette, "Algoritma ve Program Çalışma Hızı" ile ilgili bölümü ekleyerek metni genişletebilirim:

## Algoritma ve Program Çalışma Hızı:

Algoritma, bir problemin çözümüne yönelik adım adım talimatların verildiği bir süreçtir. Algoritmanın verimliliği, programın çalışma hızı üzerinde doğrudan etkilidir. 

- **Algoritmanın Zaman Karmaşıklığı:** Algoritmanın çalışması için gereken süreyi belirleyen en önemli faktörlerden biridir. Zaman karmaşıklığı, genellikle **Big O Notasyonu** ile ifade edilir ve algoritmanın en kötü durumda nasıl performans göstereceğini tahmin eder.
  
- **Algoritmanın Uzay Karmaşıklığı:** Bellek kullanımı ile ilgilidir. Programın ne kadar bellek harcadığı, algoritmanın verimliliğini etkileyen bir diğer önemli faktördür.

- **Veri Yapılarının Etkisi:** Seçilen veri yapıları, algoritmanın çalışma hızını doğrudan etkiler. Örneğin, bir arama işlemi için kullanılan veri yapısının uygunluğu, algoritmanın hızını artırabilir veya azaltabilir.

- **Programın Optimizasyonu:** Programların hızını artırmak için optimizasyon teknikleri kullanılabilir. Bu teknikler arasında döngülerin optimize edilmesi, gereksiz hesaplamaların kaldırılması ve bellek erişim hızının artırılması yer alır.

Programların verimli çalışması, algoritmaların doğru seçilmesi ve veri yapılarının etkin kullanılması ile mümkündür. İyi bir programcı, algoritma ve veri yapısı seçimlerinde dikkatli davranarak, hem zaman hem de bellek açısından optimal çözümler üretir.



Bu dersimizde bilgisayarı ve yazılımı tanıyor program geliştirme süreçlerinden bahsediyor olacağız.

Bilgisayarı ve Yazılım Dünyasını Tanıyalım - 2


# Veri Yapıları ve Algoritmalar Giriş

## İçindekiler
- [Giriş](#giriş)
- [Ders Kapsamında Öğrenilecekler](#ders-kapsamında-öğrenilecekler)
- [C Dilini Tanıyalım](#c-dilini-tanıyalım)
- [Editör Seçimi](#editör-seçimi)
- [Debugging Nedir?](#debugging-nedir)
- [Çalıştırma ve Debugging Süreci](#çalıştırma-ve-debugging-süreci)
- [Alıştırmalar](#alıştırmalar)
  - [Alıştırma 1: Döngüler ve Watches ile Debugging](#alıştırma-1-döngüler-ve-watches-ile-debugging)
  - [Alıştırma 2: Diziler ve Watches](#alıştırma-2-diziler-ve-watches)
  - [Alıştırma 3: Array Uzunluğunu Hesaplama](#alıştırma-3-array-uzunluğunu-hesaplama)

## Giriş
Veri yapıları ve algoritmalar, programlama sürecinde çok önemli bir yer tutar. Özellikle düşük seviyeli dillerle çalışırken bu konulara yatkın olmanız, kariyerinizde büyük bir avantaj sağlar.

Yalnızca bir programlama dili bilmek, yazılım geliştirmek için yeterli değildir. Projeleriniz büyüdükçe ve karmaşıklaştıkça, veri yapıları ve algoritmaların ne kadar temel taşlar olduğunu fark edeceksiniz.

## Ders Kapsamında Öğrenilecekler
Bu ders kapsamında aşağıdaki konuları öğreneceksiniz:
* Mevcut veri yapıları ve modellerin anlaşılması
* Algoritmaları incelemek, mevcut çözümleri anlamak
* __Liste ve Bağlantılı Liste, Ağaç, Çizge, Graf__ gibi veri modellerinin anlaşılması
* Bir programın bellek gereksinimi ve çalışma hızlarının hesaplanabilmesi
* Arama ve sıralama algoritmalarının kavranması
* Program/Yazılım Geliştirme sürecinin anlaşılması

## C Dilini Tanıyalım
C programlama dili, Unix/Linux gibi işletim sistemlerinin temel dili olması nedeniyle yazılım geliştirme alanında yoğun olarak kullanılmaktadır. Orta seviye bir programlama dili olan C, bellek adresleriyle esnek çalışabilme imkanı sunar ve bu ders kapsamında tercih edilmiştir.

Dersimizde aşağıdaki konulara hakim olmanız, dersin içeriğini daha iyi kavramanızı sağlayacaktır:
* Diziler ve Bellek Düzeni
* İşaretçiler (Pointer)
* Dinamik Bellek Kullanımı
* Yapısal Veri Tanımlaması (Struct ve Union)
* Recursive Fonksiyonlar
* Disk Saklama Birimlerine Erişim

Bu konulara ilerleyen derslerde değineceğiz, ancak önceden araştırarak bu başlıklar hakkında fikir sahibi olmanız faydalı olacaktır.

## Editör Seçimi
Editör seçimi ders kapsamında tamamen size bırakılmıştır. Eğer bu yazıyı okuyorsanız, muhtemelen konforlu hissettiğiniz bir editör vardır. Ancak dersimizde __Code::Blocks__ editörü üzerinden devam edeceğiz.

[Editörün resmi sayfasına giderek indirebilirsiniz.](https://www.codeblocks.org/downloads/)

## Debugging Nedir?
Debugging, geliştirdiğiniz yazılım veya programın kaynak kodunda bulunan hataları tespit etme sürecidir. Kodunuz üzerinde çalışırken bazı değişkenler kritik öneme sahiptir ve bunların doğru çalışıp çalışmadığını anlamak için debugging tekniklerini bilmek çok önemlidir.

Bu derste, değişkenleri izleyip hangi noktalarda manipüle edildiklerini gözlemleyerek temel debugging kavramlarını pratikte öğreneceğiz.

## Çalıştırma ve Debugging Süreci
Birçok IDE (Integrated Development Environment), debugging işlemleri için gerekli kısayolları sunar. Biz dersimizde Code::Blocks üzerinden devam edeceğiz.

Kod yazarken, kodunuzun yukarıdan aşağıya doğru satır satır çalıştığını bilmelisiniz. Kodunuzun belirli noktalarına breakpoint koyarak, bu satırlarda programın durmasını ve o anki durumu analiz etmenizi sağlayabilirsiniz.

__Breakpoint eklemek için, satır numarasının yanındaki boş alana tıklayabilirsiniz.__ Kırmızı bir işaret belirecektir. Aşağıda bir örnek görsel bulabilirsiniz.

![breakpoint](https://upload.wikimedia.org/wikipedia/en/8/84/Visual_Prolog_IDE_Screenshot.png)

Artık programınızı debug modunda çalıştırıp alıştırmalarımıza geçebiliriz.

### Kısayollar:

> __F5__ = BreakPoint

> __F8__ = Debug/Continue

> __F7__ = Next Line

> __Shift + F7__ = Step Into

> __F4__ = Run to Cursor

## Alıştırmalar
Şu ana kadar öğrendiğiniz konuları pekiştirmek adına birkaç alıştırma yapalım. Bu alıştırmaları tamamladığınızda temel debugging sürecine hakim olacaksınız.

Yapamayacak olursanız endişelenmeyin. YouTube kanalımdan birebir nasıl uygulandığını sizlerle paylaşıyor olacağım.

### Alıştırma 1: Döngüler ve Watches ile Debugging
Her şeyden önce, Code::Blocks'a gidip bir konsol aplikasyonu oluşturun.

* Verilen uygulamaları Code::Blocks programında yazarak değişkenlerini izleyiniz (watches).
* 10 defa dönecek bir for döngüsü oluşturunuz.
* İki adet değişken belirleyiniz.
* Döngüde, değişken sayısı tek ise bir değişkene, çift ise diğerine rastgele bir sayı atayın.
* Bu atanan değerleri watches ile izleyiniz.
* Rastgele sayı atama işlemi için internetten faydalanabilirsiniz.

#### Dikkat!
Cevaba geçmeden önce kodu kendiniz yazmayı deneyiniz. Bu süreç sizi zorlayabilir, ancak algoritmaları kurabilme kabiliyetinizi geliştirecektir.

```c
#include <stdio.h>
#include <stdlib.h>

int main(){
    int var1;
    int var2;

    for(int i=0; i<10; i++){
        if(i%2 == 0){
            var1 = rand();
            printf("var1 : %d\n", var1); // --> bu kısma break point atınız
        }else{
            var2 = rand();
            printf("var2 : %d\n", var2); // --> bu kısma breakpoint atınız
        }
    }

    return 0;
}
```

Kodu yazdıktan sonra F8 ile debug modunda çalıştırabilirsiniz. Debug menüsünün altında bulunan __Debugging Window__ > __Watches__ ile değişkenleri adım adım izleyiniz.

#### Sorun mu yaşıyorsunuz?
Code::Blocks'ta veya farklı IDE'lerde çalışırken GCC compiler'ı kodunuzu derlemek için, __GDB__'yi ise debug için kullanıyoruz. Eğer bilgisayarınızın dizinleri Türkçe ise veya Türkçe karakter içeren bir dosyanız varsa:

> C://Masaüstü//deneme-ürürü//main.c

Debug modunda hata alabilirsiniz. Ekranınız açılıp kapanır ve herhangi bir breakpoint devreye girmez. Dosya dizinlerinizin tamamen İngilizce karakterlerden oluşması gereklidir. Bunun dışında bir problem yaşıyorsanız, gdb.exe dosyanızın path (dosya dizini) doğru tanımlanmamış olabilir. İnternetten bu konuda yardım alabilirsiniz.

### Alıştırma 2: Diziler ve Watches
Son olarak, dizilerle çalışmayı pekiştirmek ve biraz daha pratik kazanmak adına bir çalışma yapalım.

* Code::Blocks'ta yeni bir konsol uygulaması oluşturun.
* 5 elemanlı bir `int` dizisi oluşturun ve bu dizinin her elemanına rastgele değerler atayın.
* Bu dizinin her elemanını bir for döngüsü içinde kontrol edin.
* Eğer bir eleman 50'den büyükse, o değeri bir değişkene ekleyin; eğer 50'den küçükse başka bir değişkene ekleyin.
* Döngü bittikten sonra iki değişkenin toplam değerlerini ekrana yazdırın.
* Her döngü adımında, elemanların değerini ve toplamların nasıl değiştiğini izlemek için watches kullanın.
* Dizinin her elemanı kontrol edilirken breakpoint koyarak adım adım izleyin.

```c
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int arr[5];
    int count_of;
    int var1 = 0;
   

 int var2 = 0;

    count_of = sizeof(arr) / sizeof(arr[0]);

    printf("Length of array: %d\n", count_of);
    printf("One item's size: %d\n", sizeof(arr[0]));

    for(int i = 0; i < count_of; i++){
        arr[i] = rand() % 100; // --> breakpoint
    }

    for(int i = 0; i < count_of; i++){
        if(arr[i] > 50){
            var1 += arr[i]; // --> breakpoint
        } else {
            var2 += arr[i]; // --> breakpoint
        }
    }

    printf("Sum of greater: %d \n", var1);
    printf("Sum of less: %d \n", var2);

    return 0;
}
```

### Alıştırma 3: Array Uzunluğunu Hesaplama
Şimdi, array uzunluğunu nasıl hesapladığımız konusuna bakalım. Aşağıdaki kodu inceleyiniz...

```c
count_of = sizeof(arr) / sizeof(arr[0]);
printf("Length of array: %d\n", count_of);
```
---
```c
count_of = sizeof(arr);
printf("Length of array: %d\n", count_of);
```

İlk bakışta hangi kodun doğru olduğunu düşünüyorsunuz? Eğer ilki diyorsanız ve nedenini biliyorsanız, buradan sonrasını okumanıza gerek yok.

__Nedenini merak eden arkadaşlar için açıklayalım:__

Bunu araştırarak öğrenelim arkadaşlar.

Öncelikle, aşağıdaki değişkenleri oluşturmanızı isteyeceğim:

* 5 elemanlı bir array oluşturun, herhangi bir atama yapmanıza gerek yok (int türünden olsun).
* `int size_arr;` adında bir değişken oluşturun.
* `int size_item;` adında bir değişken oluşturun.

* Array'inizin boyutunu `sizeof` ile ölçün ve `size_arr` değişkenine kaydedin.
* Ardından array'iniz içerisindeki ilk elemanın boyutunu ölçün ve bunu `size_item`'e atayın.
* Son olarak `sizeof(arr) / sizeof(arr[0])` işlemini gerçekleştirin.

Print işlemi yapmadan, bu satırlara breakpoint koyarak watches ekranı üzerinden sonuçları gözlemleyiniz.

#### Sonuç:
`int` veri tipindeki değişkenler bellekte 4 byte yer tutar. Bunu `size_item` değişkeninizde görebilirsiniz. Salt haliyle, 5 adet `int` değer tutan bir dizi:

5 x 4 = 20 byte yer kaplar. Bu durumda array uzunluğunu hesaplamak için:

> array_{size} / item_{size}

formülünü kullanabilirsiniz.

Anlamadığınız bir konu olursa ya da ders notlarında bir hata bulursanız, mail adresim üzerinden bana ulaşabilirsiniz.

Dr. Öğr. Üyesi Ensar Arif Sağbaş'ın ders notlarından faydalanılarak yazılmıştır. Kendisine teşekkürlerimi sunuyorum.


Veri yapıları algoritmalar Nedir & Debug Temelleri

Menu

Kategoriler

Özyinelemeli Fonksiyonlar ve Pointer Kavramı

Diziler ve Matrisler

Bilgisayarı ve Yazılım Dünyasını Tanıyalım - 2

Veri Yapıları Ve Algoritmalar - 1