Algoritma: Akış Şemaları

Geçen yazıda algoritmayı kelimelerle yazdık ve sonunda akış şemalarının şekilleriyle tanıştık. Şimdi sıra o şekilleri kullanıp kendi algoritmanı çizmeye geldi.

Çünkü bir algoritma büyüdükçe, özellikle “şu olursa şunu yap, olmazsa bunu yap” gibi dallanmalar girince, düz cümleler kafa karıştırmaya başlar. Akış şeması tam da burada bir harita gibi devreye girer: nereye gittiğini tek bakışta görürsün.

Akış şeması (flowchart), bir algoritmanın adımlarını kutular ve oklarla, akışın yönünü gösteren bir diyagram hâlinde çizme biçimidir. Hangi programlama dilini kullanırsan kullan aynı şema okunur; bu yüzden bir fikri tek satır kod yazmadan tasarlamanın en hızlı yoludur.

Önce kısa bir hatırlatma

Geçen yazıdan aklında kalsın diye, sürekli kullanacağımız dört temel şekil ve onları birbirine bağlayan ok şöyleydi:

flowchart LR
    T([Başla / Bitir]) --> Td[Akışın başladığı ve bittiği yer]:::note
    P[İşlem] --> Pd[Yapılacak bir iş — örn. Suyu ısıt]:::note
    D{Karar?} --> Dd[Evet/Hayır sorusu; akışı dallandırır]:::note
    IO[/"Girdi / Çıktı"/] --> IOd[Veri al ya da sonuç ver]:::note
    classDef note fill:transparent,stroke:transparent

Ok (-->) akışın yönünü gösterir; bir karardan sonra okun üzerindeki etiket (Evet / Hayır) hangi yoldan gidileceğini söyler. Şimdi asıl meseleye gelelim: bu şekilleri birbirine nasıl dizeceğiz?

Her algoritma üç yapı taşından kurulur

İyi haber şu: bir algoritma ne kadar karmaşık görünürse görünsün, aslında yalnızca üç temel yapının birleşiminden oluşur. Bunları öğrendiğinde, dünyadaki her akış şemasını okuyabilir hâle gelirsin.

Bu üçünü tek tek, bolca örnekle inceleyeceğiz. Acele etme; her şemayı parmağınla takip ederek oku.

1) Sıra — adımları birbiri ardına yapmak

En basiti. Adımlar yukarıdan aşağıya, tek tek, hiç dallanmadan akar. Geçen yazıdaki “sabah rutini” tam olarak buydu.

flowchart TD
    A([Başla]) --> B[Alarmı kapat]
    B --> C[Yataktan kalk]
    C --> D[Dişlerini fırçala]
    D --> E([Bitti])

Burada karar yok, tekrar yok; sadece düz bir yol var. Çoğu algoritmanın iskeleti böyle başlar, sonra araya karar ve döngü serpiştiririz.

Bir örnek daha — bankamatikten para çekmenin en yalın hali, hiç “ya olmazsa?” demeden:

flowchart TD
    A([Başla]) --> B[Kartı tak]
    B --> C[Şifreyi gir]
    C --> D[Tutarı seç]
    D --> E[Parayı al]
    E --> F[Kartı geri al]
    F --> G([Bitti])

Gerçek hayatta “şifre yanlışsa?” diye sorman gerekir; ama o, bir sonraki yapının işi.

2) Karar — bir koşula göre yol ayrımı

İşin rengi burada değişir. Karar, evet/hayır ile yanıtlanan bir sorudur ve akışı ikiye böler. Baklava şekliyle ({ ... }) çizilir ve içinden en az iki ok çıkar. Kararın üç farklı tadı var; üçünü de görelim.

Tek kollu karar — “şu olursa şunu yap”

Bazen yalnızca koşul sağlandığında fazladan bir iş yaparız; sağlanmadığında hiçbir şey yapmadan devam ederiz. Klasik örnek: dışarı çıkmadan önce hava kontrolü.

flowchart TD
    A([Başla]) --> B{Yağmur yağıyor mu?}
    B -- Evet --> C[Şemsiyeni al]
    B -- Hayır --> D[Dışarı çık]
    C --> D
    D --> E([Bitti])

“Hayır” yolu hiçbir ek iş yapmadan doğrudan Dışarı çık adımına gidiyor; “Evet” yolu ise araya Şemsiyeni al adımını sıkıştırıyor. İki yol yine aynı noktada birleşiyor.

Çift kollu karar — “ya bunu ya şunu”

Bu sefer iki yol da kendi işini yapar. Geçen yazıda da gördüğümüz çift/tek kontrolü tam buna örnek:

flowchart TD
    A([Başla]) --> B[/"Bir sayı al"/]
    B --> C{Sayı 2'ye<br/>tam bölünüyor mu?}
    C -- Evet --> D[/"Çift" yaz/]
    C -- Hayır --> E[/"Tek" yaz/]
    D --> F([Bitti])
    E --> F

Çok kollu karar — “şıklardan biri”

Bazen ikiden fazla seçenek vardır. Bir notu harf karşılığına çevirelim. Bunu, her biri bir öncekinin “Hayır” yoluna bağlanan kararlar zinciri olarak çizeriz:

flowchart TD
    A([Başla]) --> B[/"Notu al"/]
    B --> C{Not ≥ 90?}
    C -- Evet --> D[/"AA" yaz/]
    C -- Hayır --> E{Not ≥ 80?}
    E -- Evet --> F[/"BA" yaz/]
    E -- Hayır --> G{Not ≥ 70?}
    G -- Evet --> H[/"BB" yaz/]
    G -- Hayır --> I[/"Kaldı" yaz/]
    D --> Z([Bitti])
    F --> Z
    H --> Z
    I --> Z

Akışı bir kez yukarıdan aşağı oku: not 85 olsaydı, ilk soruda “Hayır” deyip ikinci soruya iner, orada “Evet” deyip BA yazardı. İşte koddaki if / else if / else zincirinin görsel hâli tam olarak budur.

3) Döngü — bir iş bitene kadar tekrarlamak

Bazen aynı adımı bir koşul sağlanana kadar tekrar tekrar yaparız. Geçen yazıdaki “su kaynayana kadar bekle” tam olarak buydu. Döngünün sırrı, bir karardan geriye dönen bir oktur. Döngünün de iki yaygın türü var.

Sayaçlı döngü — “tam N kere yap”

Kaç kere döneceğini baştan biliyorsak bir sayaç kullanırız. 1’den 5’e kadar sayalım:

flowchart TD
    A([Başla]) --> B[sayı = 1]
    B --> C{sayı ≤ 5 mi?}
    C -- Evet --> D[/"sayı"yı yaz/]
    D --> E[sayı = sayı + 1]
    E --> C
    C -- Hayır --> F([Bitti])

Bu şemayı yavaşça takip et: sayı 1’ken yazdırılıyor, sonra 2 oluyor, ok geri dönüp koşulu tekrar soruyor… Bu, ta ki sayı 6 olup koşul “Hayır” diyene kadar sürüyor. İşte bir döngünün üç olmazsa olmazı bu şemada gizli:

Üçüncü adım hayati. Eğer sayıyı hiç artırmasaydık, koşul sonsuza kadar “Evet” derdi ve döngü asla bitmezdi. Buna sonsuz döngü denir; birazdan tuzaklar bölümünde tekrar karşılaşacağız.

Koşullu döngü — “olana kadar yap”

Bazen kaç tur süreceğini bilmeyiz; sadece bir koşul sağlanana kadar devam ederiz. Doğru şifre girilene kadar tekrar tekrar soran bir kapı düşün:

flowchart TD
    A([Başla]) --> B[/"Şifreyi iste"/]
    B --> C{Şifre doğru mu?}
    C -- Hayır --> B
    C -- Evet --> D[Kapıyı aç]
    D --> E([Bitti])

“Hayır” oku doğrudan Şifreyi iste adımına geri dönüyor; kullanıcı doğru şifreyi girene kadar bu döngü dönmeye devam eder. Sayaç yok, çünkü kaç deneme süreceğini önceden bilemeyiz — sadece “doğru olana kadar”.

İç içe yapılar: döngünün içinde karar

Asıl güç, bu üç yapıyı iç içe koyduğunda ortaya çıkar. 1’den 10’a kadar olan sayılardan yalnızca çift olanları yazdıralım. Burada bir döngünün içine bir karar yerleştiriyoruz:

flowchart TD
    A([Başla]) --> B[sayı = 1]
    B --> C{sayı ≤ 10 mu?}
    C -- Hayır --> H([Bitti])
    C -- Evet --> D{sayı çift mi?}
    D -- Evet --> E[/"sayı"yı yaz/]
    D -- Hayır --> F[sayı = sayı + 1]
    E --> F
    F --> C

Dikkatle bak: dıştaki döngü 1’den 10’a kadar her sayıyı geziyor; içerdeki karar ise her sayı için “çift mi?” diye soruyor. Çiftse yazdırıyor, değilse yazdırmadan bir sonrakine geçiyor. İki yapı birlikte çalışıyor — gerçek programların neredeyse tamamı işte böyle, basit parçaların iç içe geçmesinden doğar.

Bir şemayı sıfırdan adım adım kurmak

Hazır örnekleri okumak başka, boş bir kâğıttan başlamak başka. İşte her seferinde işe yarayan dört adımlık bir tarif. Problemimiz şu olsun:

“Kullanıcıdan şifre iste. En fazla 3 deneme hakkı olsun. Doğru girerse içeri al, üç kez de yanlış girerse hesabı kilitle.”

Adım 1 — Girdi ve çıktıyı belirle. Girdi: kullanıcının yazdığı şifre. Çıktı: ya “içeri alındı” ya “hesap kilitlendi”.

Adım 2 — Ana adımları sırala. En kaba hâliyle: şifre iste → kontrol et → sonucu söyle.

Adım 3 — Kararı ekle. “Şifre doğru mu?” bir karar kutusu. Doğruysa içeri al.

Adım 4 — Tekrarı döngüye çevir. Yanlışsa tekrar sor — ama sonsuza kadar değil, en fazla 3 kez. Demek ki bir sayaca ihtiyacımız var: her yanlış denemede artan, 3’e ulaşınca döngüyü kıran bir sayaç.

Hepsini birleştirince şema şu hâle gelir:

flowchart TD
    A([Başla]) --> B[deneme = 0]
    B --> C[/"Şifreyi iste"/]
    C --> D{Şifre doğru mu?}
    D -- Evet --> E[İçeri al]
    E --> Z([Bitti])
    D -- Hayır --> F[deneme = deneme + 1]
    F --> G{deneme = 3 mü?}
    G -- Hayır --> C
    G -- Evet --> H[Hesabı kilitle]
    H --> Z

Tek başına korkutucu görünen bir problemi, dört küçük soruyla adım adım çözülebilir parçalara böldük. Bütün mesele bu: böl, sırala, kararları ve döngüleri yerine koy.

Karmaşık dallanmaları sade tutmak

Şemalar büyüdükçe spagettiye dönebilir. Birkaç basit alışkanlık onları okunur tutar:

• Tek yönde ak. Genelde yukarıdan aşağıya (ya da soldan sağa) ilerle; okların birbirini kesmesini elinden geldiğince azalt.
• Her yol bir yerde birleşsin ya da bitsin. Havada kalan, hiçbir yere gitmeyen ok bırakma.
• İç içe çok fazla karar varsa böl. Üst üste dört-beş kararı yığmak yerine, bir parçayı alt-işlem olarak ayır (geçen yazıdaki [[Alt-işlem]] şekli) ve onu ayrı bir şemada çiz.
• Soruları “Evet/Hayır” ile yanıtlanır yaz. “Kullanıcı?” değil, “Kullanıcı giriş yaptı mı?”. Net soru, net dallanma demektir.

Sık yapılan hatalar

Yeni başlayanların akış şemalarında en çok düştüğü tuzaklar şunlar:

İlk yazıdaki kuralı hatırla: bilgisayar zeki değil, itaatkârdır. Şemandaki bu boşlukları o senin yerine doldurmaz; tam tersine, eksik bıraktığın her yer ileride bir hataya dönüşür.

Kendin dene

Okuyup geçme — bir kâğıt ve kalem al, hiçbir araca ihtiyacın yok. Aşağıdaki üç problemi kolaydan zora çiz. Çözümü bir sonraki yazıya saklamıyoruz; ipuçları hemen altlarında.

Egzersiz 1 — Kapıdan geçmek (kolay)

Bir kapıdan içeri girmeye çalışıyorsun. Kapı kilitliyse önce anahtarla aç, sonra içeri gir. Açıksa doğrudan içeri gir.

Egzersiz 2 — Çarpım tablosu (orta)

Bir sayının (örneğin 7’nin) 1’den 10’a kadar çarpımlarını alt alta yazdır: 7×1, 7×2, … 7×10.

Egzersiz 3 — En büyüğü bul (zor)

Kullanıcı arka arkaya sayılar giriyor; 0 girince duruyor. Sen de en sonunda girdiği en büyük sayıyı söyle.

Üçünü de çizdiğinde, her birini “robot arkadaşına” yüksek sesle okuyup test et: Her ok bir yere gidiyor mu? Döngü bir yerde bitiyor mu? Karardan iki çıkış var mı?

Özet