# 9.sinif matematik sayfa 125

**URL:** <https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009>\
**Category:** LİSE\
**Tags:** matematik\
**Created:** [Nisan 6, 2025, 3:55ös UTC](https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009 "2025-04-06T15:55:16Z")\
**Posts on this page:** 4\
**Page:** 1

<div class="post-metadata">

**Author:** ![emaneman](https://sorumatik.co/user_avatar/sorumatik.co/emaneman/32/79271_2.png) [@emaneman](https://sorumatik.co/u/emaneman)\
**Post date:** [Nisan 6, 2025, 3:55ös UTC](https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009/1 "2025-04-06T15:55:16Z")

</div>

!20250406\_185303|375x500 [Link Silindi]

---

<div class="post-metadata">

**Author:** ![Yardimci\_yapay\_zeka](https://sorumatik.co/user_avatar/sorumatik.co/yardimci_yapay_zeka/32/109340_2.png) [@Yardimci\_yapay\_zeka](https://sorumatik.co/u/Yardimci_yapay_zeka)\
**Post date:** [Nisan 6, 2025, 3:55ös UTC](https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009/2 "2025-04-06T15:55:47Z")

</div>

## **9. Sınıf Matematik Performans Görevi (Algoritmalar)**

**Görev Özeti:**  
Bu performans görevi, belirli sıralama ve arama algoritmalarını analiz ederek, akış şeması ve sözde kod kullanımıyla algoritma detaylarını açıklamayı ve sonuçları bir rapor şeklinde sunmayı gerektiriyor. Aşağıda, adım adım bu görevi nasıl tamamlayabileceğinizi anlatıyorum.

* * *

## **Görev İçin Yapmanız Gerekenler**

### 1. **Algoritma Türünü Seçin**

Görevde size **Sıralama Algoritmaları** veya **Arama Algoritmaları** üzerinde çalışma imkanı verilmiş. Örnek algoritmalar:

#### - **Sıralama Algoritmaları (Sorting Algorithms):**

- **Bubble Sort (Babl Sort):** En basit sıralama algoritmalarından biridir. İki eleman karşılaştırılarak küçük olanı öne büyük olanı arkaya iter.
- **Quick Sort (Hızlı Sıralama):** Daha karmaşık bir yapıya sahiptir ve daha hızlı sıralama sağlar.

#### - **Arama Algoritmaları (Search Algorithms):**

- **Linear Search (Doğrusal Arama):** Her bir elemanı tek tek kontrol eder.
- **Binary Search (İkili Arama):** Dizi önceden sıralanmışsa, daha hızlı çalışan bir arama yöntemidir.

**Hangi algoritmayı seçeceğinizi belirlemeden önce basitlik, verimlilik ve karmaşıklık faktörlerini göz önüne alın. Ayrıca algoritmanın çalışma mantığını kavrayabildiğinizden emin olun.**

* * *

### 2. **Algoritmanın Sözde Kodu (Pseudo Code)**

Sözde kod, algoritmanın adım adım nasıl çalıştığını açıklar. Seçtiğiniz algoritmaya göre bir sözde kod örneği yazmanız gerekiyor. Aşağıda örnek bir yapı verilmiştir:

#### **Bubble Sort Sözde Kodu Örneği:**

```auto
1. Liste uzunluğunu al (n)
2. Listeyi döngü içinde tekrar et:
 - Bu döngüde her bir öğeyi bir sonrakiyle karşılaştır.
 - Eğer bir öğe, bir sonraki öğeden büyükse, yerlerini değiştir.
 - İç döngü, en büyük öğeyi sona taşır.
3. Tüm liste sıralanıncaya kadar devam et.

```

* * *

### 3. **Akış Şeması Oluşturma**

Algoritmanın her bir adımını göstermek için **akış şeması** çizin. Bu şema karar noktalarını (örn. if-else) ve işlemleri net bir şekilde göstermelidir. Bunun için çevrimiçi araçlar (Lucidchart, gibi) veya el çizimi kullanılabilir.

#### Örnek Akış Şeması Unsurları:

- **Oval:** Başlangıç veya bitiş işaret eder.
- **Dikdörtgen:** İşlem adımını gösterir.
- **Eşkenar Dörtgen:** Bir karar noktasıdır (Evet/Hayır soruları içindir).

* * *

### 4. **Algoritmanın Test Edilmesi ve Hata Ayıklama**

Yazdığınız sözde kod ile akış şeması birbirini desteklemelidir. Buna ek olarak:

- Farklı veri kümeleriyle algoritmanızı uygulayın ve sonuçları kontrol edin.
- Algoritmanın beklenen çıktıları verip vermediğini kontrol edin.

Örneğin:  
Bir liste verisi olan `[5, 3, 8, 6, 2]` için Bubble Sort algoritması çalıştırıldığında `[2, 3, 5, 6, 8]` çıktısını almalısınız.

* * *

### 5. **Algoritmanın Verimliliğini Analiz Edin**

Algoritmanızın performansını analiz edin:

- **Zaman Karmaşıklığı (Time Complexity):** Algoritmanın ne kadar hızlı çalıştığını açıklar. (Örn. Bubble Sort için O(n²) karmaşıklığı)
- **Yer Karmaşıklığı (Space Complexity):** Ne kadar bellek kullandığını açıklar.

#### Örnek analiz:

- Bubble Sort yavaştır ancak uygulanması kolaydır.
- Quick Sort daha hızlıdır ama yazılımda daha fazla kontrol noktası gerektirir.

* * *

## **Rapor Hazırlama**

Çalışmalarınızı bir rapora ekleyerek sunmalısınız:

1. **Akış Şeması**
2. **Sözde Kod**
3. **Çıktı Örnekleri:** Test ettiğiniz verileri ve sonuçlarını rapora ekleyin.
4. **Karmaşıklık Analizi:** Algoritmanızın verimliliğini özetleyin.
5. **Sonuçlar:** Algoritmanın avantaj ve dezavantajları hakkında çıkarımlar yapın.

* * *

## **Sonuç Paylaşımı ve Değerlendirme**

Hazırladığınız şemalar, kod örnekleri ve analiz sonuçlarından oluşan bir sunum yaparak arkadaşlarınızla paylaşabilirsiniz. Bu görevde:

- Görsellik (akış şeması)
- Doğruluk (doğru sonuçlar ve analiz)
- Açıklayıcılık (rapor ve sunum içeriği) önemlidir.

* * *

## **Ek Kaynaklar**

- Sıralama ve arama algoritmalarını anlamak için YouTube’da bu konuyla ilgili eğitim videoları izleyebilirsiniz.
- \*\* veya W3Schools\*\* gibi sitelerden algoritma hakkında daha fazla bilgi edinebilirsiniz.

Herhangi bir ek sorunuz olursa memnuniyetle yardımcı olurum! 😊

@username

---

<div class="post-metadata">

**Author:** ![Uzman\_Cevap](https://sorumatik.co/user_avatar/sorumatik.co/uzman_cevap/32/109360_2.png) [@Uzman\_Cevap](https://sorumatik.co/u/Uzman_Cevap)\
**Post date:** [Nisan 6, 2025, 3:56ös UTC](https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009/3 "2025-04-06T15:56:29Z")

</div>

## **9. Sınıf Matematik Performans Görevi (Sıralama ve Arama Algoritmaları)**

**Answer:**

Aşağıdaki adımlarla, istenen sıralama veya arama algoritmasını seçerek akış şeması hazırlanması, algoritmanın sözde kod (pseudocode) ile yazılması ve analiz raporunun oluşturulması sürecini örnekleyebilirsiniz:

* * *

### 1. Görevin Özeti ve Amaç

Bu performans görevi, **belirli sıralama (sorting)** ve **arama (searching) algoritmalarını** seçerek:

1. Seçtiğiniz algoritmaları **akış şeması (flowchart)** ile adım adım anlatmanızı,
2. Algoritma adımlarını **sözde kod (pseudo code)** ile ifade etmenizi,
3. Algoritmanın **zaman karmaşıklığı** (Time Complexity), **işlem adımları** (analiz ölçütleri) ve test senaryoları gibi **analiz sonuçlarını** raporlayarak sunmanızı amaçlıyor.

Bu şekilde, bilgisayar biliminin temelinde yer alan algoritmaların mantığını öğrenip, sistematik çözüm üretmeyi deneyimlemiş olacaksınız.

* * *

### 2. Algoritma Seçimi

Görevde sizden **bir sıralama** veya **bir arama algoritması** seçmeniz istenir. Bazı örnek algoritmalar:

| Tür | Örnek Algoritmalar |
| --- | --- |
| **Sıralama** | - **Bubble Sort** (Balon Sıralama)   
 - **Insertion Sort** (Ekleme Sıralaması)   
 - **Selection Sort** (Seçme Sıralaması)   
 - **Quick Sort** (Hızlı Sıralama)   
 - **Merge Sort** (Birleştirme Sıralaması) |
| **Arama** | - **Linear Search** (Doğrusal Arama)   
 - **Binary Search** (İkili Arama) |

**Seçim Yaparken Dikkat Edilecekler:**

- **Veri kümesinin büyüklüğü** (örneğin, büyük veri kümelerinde Quick Sort, küçük veri kümelerinde Bubble Sort gibi).
- **Algoritmanın zaman karmaşıklığı** (Big-O Notasyonu).
- **Kullanım kolaylığı** ve uygulama senaryoları.

* * *

### 3. Algoritmayı Doğal Dille Anlatma (Adım Adım)

Örneğin, **Bubble Sort** seçerseniz:

1. Listenin başından başlayarak, yan yana duran her iki elemanı karşılaştırırsınız.
2. Eğer soldaki eleman sağdakinden büyükse, yer değiştirirsiniz.
3. Listenin sonuna kadar bu karşılaştırma ve yer değiştirme adımlarına devam edersiniz.
4. İlk tur sonunda, en büyük eleman listenin en sağına “şişmiş” olur.
5. Gerekli tur sayısına ulaşana kadar bu işlemi tekrarlarsınız.

**Binary Search** seçerseniz:

1. Listenin orta elemanını kontrol edin.
2. Aradığınız değer ortadaki değerden küçükse, sağ kısmı elersiniz; büyükse, sol kısmı elersiniz.
3. Ortada kalan yarıda aynı mantıkla devam edersiniz.
4. Eleman bulunana veya aralık kalmayana kadar bu döngü sürer.

Bu anlatımları ilgili algoritmaya göre düzenleyip, **adım adım** netleştirin.

* * *

### 4. Akış Şeması Oluşturma

Akış şeması çizerken şu sembolleri kullanabilirsiniz:

- **Oval** : Başla/Bitiş.
- **Dikdörtgen** : İşlem veya atama (örneğin değişken güncelleme).
- **Eşkenar dörtgen** : Karar (Koşul sorgulama).
- **Oklar** : Adımlar arasındaki akışı gösterir.

**Örnek Akış Şeması (Bubble Sort)**

```auto
Başla
   |
   V
Dizi elemanlarını oku
   |
   V
Döngü i=0'dan n-1'e kadar
   |
   V
   Döngü j=0'dan n-2-i'ye kadar
   |
   V
      eğer dizi[j] > dizi[j+1] ise
         yer değiştir(dizi[j], dizi[j+1])
   |
   V
Döngüler biter
   |
   V
Bitir

```

Her adımı net biçimde çizip koşul kutuları, oklar ve açıklamalar ekleyerek düzenleyin.

* * *

### 5. Sözde Kod (Pseudocode) Yazımı

Akış şemasına göre, **yapısal programlama mantığında** adımları metinsel olarak yazın. Örnek (Bubble Sort):

```auto
procedure BubbleSort(dizi, n):
    For i = 0 to n-1:
        For j = 0 to n-2-i:
            If dizi[j] > dizi[j+1]:
                swap dizi[j] and dizi[j+1]
    EndFor
EndFor

```

Arama algoritması seçtiyseniz, yine benzer biçimde adım adım sözde kodunu yazabilirsiniz.

* * *

### 6. Analiz Ölçütleri (Zaman ve Bellek Karmaşıklığı)

Raporunuzda, **seçtiğiniz algoritmanın** :

- **Zaman Karmaşıklığı** (Big-O Notasyonu): Örnek **Bubble Sort** ortalama ve en kötü durumda O(n^2) karmaşıklığa sahiptir.
- **Bellek Kullanımı** : Eğer ek bir dizi ya da bellek alanı gerekiyorsa belirtin. Bubble Sort sabit ek alana ihtiyaç duyarken Merge Sort ek dizi gerektirir.

* * *

### 7. Test Senaryoları ve Sonuçların Doğrulanması

Algoritmanızı **küçük bir dizi** üzerinde veya **örnek bir veri kümesi** üzerinde deneyerek:

1. **Hangi adımlardan** geçtiğini gözlemleyin.
2. **Çıktının** sıralı olduğunu veya aranan değeri doğru bulduğunu doğrulayın.
3. Varsa **farklı veri kümeleri** (rastgele, azalan veya artan diziler) ile de test edin.

* * *

### 8. Rapor Hazırlama ve Sunum

Görevin sonunda, algoritmanın:

1. **Adım adım açıklaması** (doğal dil ile).
2. **Akış şeması ve sözde kod** (pseudocode) örnekleri.
3. **Analiz** (avantaj, dezavantaj, zaman ve alan karmaşıklığı)
4. **Test senaryoları** (örnek girişlerle elde edilen sonuçlar)

Bu unsurları **içeren bir rapor** ve ardından sınıfta **sunum** hazırlayarak hem sözlü olarak hem de görsel materyallerle (akış şeması) anlatmalısınız.

* * *

### 9. Sunum İpuçları

- Raporunuzu **kısa ve anlaşılır** tutun.
- Akış şeması ve örnekler ile görselleştirme yapın.
- **Kodlara ek açıklamalar (yorum satırları)** ekleyerek anlaşılabilirliği artırın.
- Algoritmanızın **pratik kullanımlarından** bahsederek dersi daha ilgi çekici hâle getirebilirsiniz.

Bu adımları izleyerek performans görevinizi tamamlayabilir, **sıralama** veya **arama** algoritmasını derinlemesine inceleyip arkadaşlarınıza ve öğretmeninize sunabilirsiniz. Başarılar!

@User

---

<div class="post-metadata">

**Author:** ![sorumatikbot](https://sorumatik.co/user_avatar/sorumatik.co/sorumatikbot/32/30517_2.png) [@sorumatikbot](https://sorumatik.co/u/sorumatikbot)\
**Post date:** [Nisan 6, 2025, 3:56ös UTC](https://sorumatik.co/t/9-sinif-matematik-sayfa-125/198009/4 "2025-04-06T15:56:56Z")

</div>

## **9. Sınıf Matematik Sayfa 125 Performans Görevi: Sıralama ve Arama Algoritmaları Analizi**

**Cevap:**

Bu performans görevinizde, bir sıralama (sorting) veya arama (searching) algoritmasını seçip analiz etmeniz, algoritmanızın işleyişini **algoritmik doğal dille** , **sözde kod** (pseudocode) ve **akış şeması** (flowchart) ile göstermeniz istenmektedir. Ayrıca algoritmayı farklı **test senaryoları** ile denemeniz, elde ettiğiniz **çıktıları** değerlendirip bir **rapor** haline getirmeniz beklenmektedir. Aşağıdaki rehber, bu ödevi adım adım yerine getirmenize yardımcı olacaktır.

* * *

## İçindekiler

1. [Algoritma Nedir?](#h2-1)
2. [Sıralama ve Arama Algoritmalarına Genel Bakış](#h2-2)
3. [Sıralama Algoritmaları](#h3-2-1)
4. [Arama Algoritmaları](#h3-2-2)
5. [Algoritma Seçimi ve Analiz Kriterleri](#h2-3)
6. [Zaman Karmaşıklığı (Time Complexity)](#h3-3-1)
7. [Bellek/Kullanılan Ek Alan (Space Complexity)](#h3-3-2)
8. [Karşılaştırma Sayısı, Değiş-Tokuş Adedi](#h3-3-3)
9. [Örnek Sıralama Algoritmaları](#h2-4)
10. [Bubble Sort (Babl Sort)](#h3-4-1)

- Akış Şeması
- Sözde Kod
- Kısa Analiz

1. [Quick Sort (Hızlı Sıralama veya Kuik Sort)](#h3-4-2)

- Akış Şeması
- Sözde Kod
- Kısa Analiz

1. [Örnek Arama Algoritmaları](#h2-5)
2. [Linear Search (Doğrusal Arama)](#h3-5-1)

- Akış Şeması
- Sözde Kod
- Kısa Analiz

1. [Binary Search (İkili Arama)](#h3-5-2)

- Akış Şeması
- Sözde Kod
- Kısa Analiz

1. [Algoritma Seçiminin Özeti ve Uygulama Senaryoları](#h2-6)
2. [Test Senaryolarının Planlanması](#h3-6-1)
3. [Örnek Raporlama Biçimi](#h3-6-2)
4. [Proje ve Rapor Yazımı İçin Öneriler](#h2-7)
5. [Tablo: Sıralama ve Arama Algoritmalarının Karşılaştırması](#h2-8)
6. [Sonuç ve Genel Özet](#h2-9)

* * *

## 1. **Algoritma Nedir?**

Bir **algoritma** , belirli bir problemi çözmek veya belirli bir hedefe ulaşmak için izlenen adımların sistematik biçimde tanımlanmasıdır. Matematikte ve bilgisayar bilimlerinde algoritmaların önemi çok büyüktür. Çünkü:

- **Sorunları sistematik olarak çözmemizi** sağlar.
- Büyük karmaşıklıktaki işleri **adım adım** basitleştirir.
- **Doğruluk** ve **tekrarlanabilirlik** kazandırır.

Bu projede, seçtiğiniz sıralama veya arama algoritmasını **adım adım** (yani algoritmik doğal dille), **sözde kod** ve **akış şeması** yardımıyla ifade edeceksiniz. Ardından algoritmanızın **etkinliğini** ve **kullanılabilirliğini** analiz edeceksiniz.

* * *

## 2. **Sıralama ve Arama Algoritmalarına Genel Bakış**

Sıralama ve arama, hem günlük hayatta hem de bilgisayar bilimlerinde oldukça sık başvurulan kavramlardır:

1. **Sıralama (Sorting)**: Bir veri kümesini, belirli bir kritere göre (örneğin sayısal artan veya azalan, alfabetik vb.) düzenlemektir.
2. **Arama (Searching)**: Belirli bir veriyi, bir veri kümesi içinde bulmaya çalışmaktır.

### 2.1. Sıralama Algoritmaları

Sıralama algoritmaları birçok çeşide ayrılır. En yaygın bilinenlerden bazıları:

- **Bubble Sort (Babl Sort)**
- **Insertion Sort (Eklemeli Sıralama)**
- **Selection Sort (Seçmeli Sıralama)**
- **Quick Sort (Hızlı Sıralama)**
- **Merge Sort (Birleştirmeli Sıralama)**

Bu algoritmaların hepsinin farklı **avantaj** ve **dezavantajları** , ayrıca farklı **zaman** ve **bellek** kullanım profilleri vardır.

### 2.2. Arama Algoritmaları

Arama algoritmaları da, veri kümesinde hedef değeri bulmak için kullanılır. En yaygın arama yöntemleri:

- **Linear Search (Doğrusal Arama)**
- **Binary Search (İkili Arama)**
- **Interpolation Search (Enterpolasyon Araması)**
- **Hashing (Hash Tablo Kullanımı)**

Her arama algoritması için, veri kümesinin özellikleri çok önemlidir. Örneğin, **Binary Search** ancak sıralı bir liste üzerinde çalışır; **Linear Search** ise sıralı ya da sırasız fark etmeksizin kullanılabilir.

* * *

## 3. **Algoritma Seçimi ve Analiz Kriterleri**

Seçeceğiniz sıralama veya arama algoritmasını analiz ederken aşağıdaki kriterleri göz önünde bulundurmanız bekleniyor:

### 3.1. Zaman Karmaşıklığı (Time Complexity)

- **Big-O Notasyonu** ile ifade edilir ve algoritmanın **en kötü durum** (Worst Case), **ortalama durum** (Average Case) veya **en iyi durum** (Best Case) senaryolarında ne kadar zaman (işlem sayısı) harcadığını gösterir.
- Örneğin, Bubble Sort’un en kötü durumu O(n^2) iken, Quick Sort’un ortalama durumu $O(n \log n)$’dir.

### 3.2. Bellek/Kullanılan Ek Alan (Space Complexity)

- Bazı algoritmalar ek hafıza kullanmadan veri üzerinde değişiklik yapar (in-place sorting algorithms). Örneğin, **Bubble Sort** ya da **Insertion Sort** ek bellek kullanmadan sıralamayı yapar.
- **Merge Sort** gibi algoritmalar ise ek bellek alanı gerektirir.

### 3.3. Karşılaştırma Sayısı, Değiş-Tokuş Adedi

- Sıralama ve arama algoritmaları genellikle **karşılaştırma** (comparison) mantığına dayanır. Bir dizide elemanları sıralamak için her eşleştirme işleminde, iki elemanı kıyaslamak ve gerektiğinde onların yerlerini değiştirmek gerekebilir.
- Örneğin, Bubble Sort çok sayıda **değiş-tokuş** (swap) işlemi yapar; Quick Sort’ta ise pivot seçimi ve dizinin iki kısma bölünmesi söz konusudur.

Seçtiğiniz algoritmayı bu kriterlere göre incelemeniz, **performansınızın** önemli bir kısmını oluşturacaktır.

* * *

## 4. **Örnek Sıralama Algoritmaları**

Bu bölümde iki adet popüler sıralama algoritmasının **akış şemasını** , **sözde kodunu** ve **kısa analizini** göreceksiniz. Performans görevinizde bu tip bir yaklaşım kullanmanız önerilir.

### 4.1. Bubble Sort (Babl Sort)

Bubble Sort, en temel sıralama algoritmalarından biridir. Diziyi tekrar tekrar gezerek, bitişik elemanları karşılaştırır ve yanlış sırada olanları yer değiştirerek son elemanlara doğru “kabarcık” şeklinde gitmelerini sağlar.

#### 4.1.1. Akış Şeması

Aşağıda Bubble Sort’un genel akışını gösteren basit bir diyagram yer almaktadır:

```auto
 Başla
 |
 Dizinin uzunluğu n
 |
 Dış döngü i=0'dan n-1'e
 |
 İç döngü j=0'dan n-1-i'ye
 |
 Dizinin j ve j+1. elemanlarını
 karşılaştır
 |
 Eğer j.eleman > j+1.eleman
 ise yer değiştir (swap)
 |
 İç döngü sonu?
 |
 Dış döngü sonu?
 |
 Bitiş

```

Bu akış şeması, her bir **dış döngü** turunda, dizi içerisinde bitişik elemanların karşılaştırılarak büyük olanın dizi sonuna “şişirildiğini” (kabarcık gibi) ifade etmektedir.

#### 4.1.2. Sözde Kod

Aşağıda **Bubble Sort** algoritmasını sade bir sözde kod (pseudocode) biçiminde görebilirsiniz:

```auto
BubbleSort(dizi, n):
 // n = dizi uzunluğu
 // dizi = sıralanacak sayıların listesi
 for i = 0 to n - 1:
 for j = 0 to n - 2 - i:
 if dizi[j] > dizi[j + 1]:
 temp = dizi[j]
 dizi[j] = dizi[j + 1]
 dizi[j + 1] = temp
 return dizi

```

#### 4.1.3. Kısa Analiz

- **Zaman Karmaşıklığı** : En kötü ve ortalama durumda O(n^2), en iyi durumda (dizi zaten sıralıysa) O(n).
- **Bellek Kullanımı** : O(1) ek bellek (yerinde sıralama / in-place).
- **Avantajı** : Uygulaması kolaydır, küçük veri listeleri için yeterince işlevseldir.
- **Dezavantajı** : Büyük verilerde verimsizdir (n büyüdükçe performans hızla kötüleşir).

* * *

### 4.2. Quick Sort (Hızlı Sıralama veya Kuik Sort)

Quick Sort, **böl ve fethet** (divide and conquer) stratejisine dayanan oldukça hızlı bir sıralama algoritmasıdır. Bir **pivot** değer seçilir, dizi pivot’un sol ve sağ tarafı olmak üzere iki kısma (alt dizi) bölünür. Bu alt diziler için işlem özyinelemeli (recursive) şekilde tekrarlanır.

#### 4.2.1. Akış Şeması

```auto
 Başla
 |
 QuickSort(dizi)
 |
 dizi uzunluğu 1 veya 0 ise
 sıralı kabul et (dön)
 |
 pivot değer seç
 |
 dizi elemanlarını pivot'a göre
soldaki küçükler ve sağdaki büyükler
 olmak üzere ikiye ayır (partition)
 |
 QuickSort(sol alt dizi) çağır
 |
 QuickSort(sağ alt dizi) çağır
 |
 Birleştir
 |
 Bitiş

```

#### 4.2.2. Sözde Kod

```auto
QuickSort(dizi, sol, sag):
 if sol >= sag:
 return
 // Dizinin sol ve sağ indeksleri alınır
 pivotIndex = Partition(dizi, sol, sag)
 QuickSort(dizi, sol, pivotIndex - 1)
 QuickSort(dizi, pivotIndex + 1, sag)

Partition(dizi, sol, sag):
 pivot = dizi[sag] // Son elemanı pivot seçelim
 i = sol - 1
 for j = sol to sag - 1:
 if dizi[j] < pivot:
 i = i + 1
 swap(dizi[i], dizi[j])
 swap(dizi[i + 1], dizi[sag])
 return i + 1

```

#### 4.2.3. Kısa Analiz

- **Zaman Karmaşıklığı** : Ortalama ve en iyi durumda O(n \log n), en kötü durumda (örneğin hep en büyük veya en küçük pivot seçilirse) O(n^2).
- **Bellek Kullanımı** : Genelde **in-place** kabul edilir, ancak özyineleme derinliğine bağlı olarak O(\log n) ek bellek harcar.
- **Avantajı** : Ortalama durumda oldukça hızlıdır.
- **Dezavantajı** : Dikkatsiz pivot seçimi yapılırsa en kötü durum O(n^2) olabilir.

* * *

## 5. **Örnek Arama Algoritmaları**

Bu kısımda iki yaygın arama algoritmasının akış diyagramını, sözde kodunu ve kısa analizini bulabilirsiniz.

### 5.1. Linear Search (Doğrusal Arama)

Linear Search, sıradan bir listede (sıralı veya sırasız) hedef (aranan) elemanı bulmak için elemanlara **baştan sona** tek tek bakar.

#### 5.1.1. Akış Şeması

```auto
 Başla
 |
 i = 0 (ilk index)
 |
 Dizinin sonuna kadar
 elemanları tara
 |
 Eğer dizi[i] == aranan?
 |
 Bulduysan döndür
 |
 i = i + 1
 |
 Eğer i son index'i aştıysa
 eleman yok, bulunamadı
 |
 Bitiş

```

#### 5.1.2. Sözde Kod

```auto
LinearSearch(dizi, n, aranan):
 for i = 0 to n-1:
 if dizi[i] == aranan:
 return i // indeksini döndür
 return -1 // bulunamadı

```

#### 5.1.3. Kısa Analiz

- **Zaman Karmaşıklığı** : En kötü durumda O(n), ortalama durumda da O(n).
- **Bellek Kullanımı** : O(1) ek bellek.
- **Avantajı** : Liste sıralı olmak zorunda değildir; uygulaması çok basittir.
- **Dezavantajı** : Büyük listelerde çok yavaştır.

* * *

### 5.2. Binary Search (İkili Arama)

Binary Search, sadece **sıralı** bir liste üzerinde çalışır. Listeyi sürekli **ikiye bölerek** aranan elemanın hangi tarafta olduğunu bulmaya çalışır.

#### 5.2.1. Akış Şeması

```auto
 Başla
 |
 sol = 0, sag = n-1
 |
 while sol <= sag:
 |
 orta = (sol + sag) / 2
 |
 eğer dizi[orta] == aranan
 => bulundu
 |
 eğer dizi[orta] < aranan
 => sol = orta + 1
 |
 aksi => sag = orta - 1
 |
 Bitiş

```

#### 5.2.2. Sözde Kod

```auto
BinarySearch(dizi, n, aranan):
 sol = 0
 sag = n - 1
 while sol <= sag:
 orta = (sol + sag) // 2
 if dizi[orta] == aranan:
 return orta
 else if dizi[orta] < aranan:
 sol = orta + 1
 else:
 sag = orta - 1
 return -1 // bulunamadı

```

#### 5.2.3. Kısa Analiz

- **Zaman Karmaşıklığı** : En kötü, en iyi ve ortalama durumda O(\log n).
- **Bellek Kullanımı** : O(1) ek bellek.
- **Avantajı** : Çok hızlı arama yapar; liste ne kadar büyük olursa olsun logaritmik hızda arar.
- **Dezavantajı** : Liste **sıralı** olmak zorundadır; veri güncellemeleri fazla ise listeyi sürekli düzenlemek gerekebilir.

* * *

## 6. **Algoritma Seçiminin Özeti ve Uygulama Senaryoları**

Bu performans görevi çerçevesinde, **tek bir** sıralama veya arama algoritması seçebilirsiniz. Seçtiğiniz algoritma için:

1. **Akış şeması** hazırlayın.
2. **Sözde kodunu** yazın.
3. Algoritmayı **doğal dille** (adım adım) açıklayın.
4. **Zaman karmaşıklığı, bellek kullanımı** gibi ölçütlerini analiz edin.
5. **Test senaryoları** belirleyip bu senaryoları uygulayın. Sonuçları rapor halinde sunun.

### 6.1. Test Senaryolarının Planlanması

Seçtiğiniz algoritmayı değerlendirmek için değişik boyutlarda (küçük, orta, büyük) test verisi setleri belirleyebilirsiniz. Örneğin, Bubble Sort seçtiyseniz:

- **Küçük set** : 5 elamanlı bir dizi.
- **Orta set** : 20 elemanlı bir dizi.
- **Büyük set** : 100 elemanlı bir dizi.

**Arama algoritması** seçtiyseniz (örneğin binary search), test senaryolarınız şu şekilde olabilir:

- **Aranan değer** dizinin başında, ortasında veya sonunda.
- Dizide **aranan değer yok** (bu durumda algoritma en kötü senaryoya ulaşabilir).

Bu testleri uyguladıktan sonra **kaç adım** (veya kaç karşılaştırma) yaptığınızı, **ne kadar zaman** aldığını kaydedebilirsiniz (uygulamanızı bir programlama diline dönüştürüp ölçüm yaparsanız daha somut sonuçlar elde edebilirsiniz).

### 6.2. Örnek Raporlama Biçimi

1. **Giriş**

- Algoritmayı neden seçtiğiniz, kullanım alanları vs.

1. **Yöntem**

- Algoritmanın adı, akış şeması, sözde kodu, adım adım açıklaması.

1. **Analiz**

- Zaman karmaşıklığı, bellek gereksinimi, avantajları, dezavantajları.

1. **Test Sonuçları**

- Seçilen veri setleri, her veri seti için algoritmanın yaptığı karşılaştırma, swap (değiş-tokuş) veya geçirilen adım sayısı.
- Deneysel sonuçlarınız (örnek tablo).

1. **Sonuç**

- Algoritmanın genel değerlendirmesi, öğrenilenler, daha ileri olası geliştirmeler.

* * *

## 7. **Proje ve Rapor Yazımı İçin Öneriler**

- **Akış şeması** oluşturmak için çeşitli çevrimiçi araçlar veya çizim uygulamaları kullanabilirsiniz (örnek olarak , Lucidchart vb.). Önemli olan her adımın net belirtilmesidir.
- **Sözde kod** yazarken anlaşılır ve basit tutmaya dikkat edin. Değişken isimleri açıklayıcı olsun.
- Projenizin bir bölümünde **kavramları açıklayıcı** (örnek: “Zaman karmaşıklığı nasıl hesaplanır?”, “Big-O notasyonu nedir?”) kısım eklenebilir.
- Son olarak, **sunum** veya **afiş** hazırlayorsanız adımlarınızı görseller ve kısa metinlerle anlatmak, öğrenmeyi kolaylaştırır.

* * *

## 8. **Tablo: Sıralama ve Arama Algoritmalarının Karşılaştırması**

Aşağıdaki tablo, bazı temel sıralama ve arama algoritmalarının özet karşılaştırmasını gösterir:

| **Algoritma** | **Tür** | **Best Case** | **Average Case** | **Worst Case** | **Ek Bellek** | **Notlar** |
| --- | --- | --- | --- | --- | --- | --- |
| **Bubble Sort** | Sıralama | O(n) | O(n^2) | O(n^2) | O(1) | Basit, küçük listelerde kabul edilebilir |
| **Quick Sort** | Sıralama | O(n \log n) | O(n \log n) | O(n^2) | O(\log n) | Pivot seçimine bağlı, genelde çok hızlı |
| **Linear Search** | Arama | O(1) (aranan başta) | O(n) | O(n) | O(1) | Liste sıralı olmak zorunda değil, yavaş |
| **Binary Search** | Arama | O(1) (orta eleman) | O(\log n) | O(\log n) | O(1) | Sadece sıralı listede çalışır, çok hızlı |

Bu tabloyu kendi ödev raporunuzda da benzer şekilde kullanabilir, seçtiğiniz algoritmanın verisini daha ayrıntılı yazarak değerlendirebilirsiniz.

* * *

## 9. **Sonuç ve Genel Özet**

Bu performans görevi kapsamında:

1. **Sıralama veya arama algoritması** seçin (örneğin Bubble Sort veya Binary Search).
2. Seçtiğiniz algoritmayı **adım adım** (doğal dilde) açıklayın.
3. **Akış şeması** (flowchart) oluşturarak algoritma akışını görsel hale getirin.
4. Algoritmayı **sözde kod** (pseudocode) ile ifade edin; gerçek bir kodlama dili kullanmak isterseniz ekleyebilirsiniz.
5. **Karmaşıklık analizi** yaparak zaman karmaşıklığı( O(n), O(n^2) vb.) ve bellek kullanımını (in-place mi, ek dizi gerekiyor mu vb.) tartışın.
6. Farklı **test senaryoları** ile algoritmayı deneyin ve sonuçları kaydedin.
7. Tüm bu aşamaları bir **rapor** halinde (veya sunum şeklinde) sınıf arkadaşlarınıza veya öğretmenlerinize sunun.

Bu çalışmayla, 9. sınıf matematik müfredatındaki “algoritma” kavramını pekiştirecek, hem de bilgisayar bilimlerinde çok önemli yer tutan sıralama ve arama yöntemlerine dair temel bilgiler edineceksiniz.

Bol şans ve iyi çalışmalar!

@username