Algoritma: Listeler

Önceki yazıda döngüleri öğrendik: aynı işi bir şart tuttuğu sürece tekrar tekrar yapmak. En sonunda 1’den 10’a kadar olan sayıları toplamıştık — ama fark ettin mi, o sayılar hep sırayla üretiliyordu (sayı ← sayı + 1). Ortada saklanan bir sayı yığını yoktu; her turda bir sonrakini hesaplıyorduk. Peki ya elimizde önceden verilmiş, belli değerler varsa? Diyelim ki senin beş sınav notun: 70, 85, 90, 60, 100. Bunlar bir kalıp değil — sadece bir avuç değer. Bilgisayara bunları nasıl veririz?

Değişkenler yazısından bir yol biliyoruz: her notu ayrı bir kutuya koyarız. not1 ← 70, not2 ← 85, not3 ← 90… Beş not için beş değişken, olur. Peki ya elli not? Elli ayrı isim mi uyduracaksın? Üstelik hepsini toplamak istesen, döngü de işe yaramaz — çünkü her kutunun farklı bir adı var, döngünün gezeceği bir sıra yok. İşte tam burada tıkanırız. Bu yazının konusu, bu tıkanıklığı açan fikir: birçok değeri tek bir isim altında, sıralı biçimde saklamak. Buna liste diyoruz.

Neden listeye ihtiyacımız var?

Az önceki soruna geri dönelim: beş sınav notunun ortalamasını bulmak istiyorsun. Ayrı değişkenlerle şöyle görünür:

not1 ← 70
not2 ← 85
not3 ← 90
not4 ← 60
not5 ← 100
ortalama ← (not1 + not2 + not3 + not4 + not5) / 5
YAZ ortalama

Beş not için katlanılır. Ama iki sıkıntı hemen göze çarpıyor. Birincisi: ölçeklenmiyor. Elli not olsa, elli satır atama ve upuzun bir toplama yazman gerekir. İkincisi — ve daha önemlisi: döngü kuramıyorsun. Döngüler tam da “aynı işi tekrarla” demek içindi, ama burada tekrarlanacak bir kalıp yok; not1, not2, not3 birbirinden bağımsız isimler. Döngünün üzerinde yürüyeceği bir sıra yok.

Oysa günlük hayatta bu tür “aynı türden çok şeyi” hep tek bir başlık altında toplarız:

• Alışveriş listesi: süt, ekmek, yumurta, peynir… Hepsi tek bir kâğıtta, alt alta.
• Sınıf yoklaması: otuz öğrenci adı, bir defterde sırayla.
• Çalma listesi: yüzlerce şarkı, tek bir isim altında, 1. sıra, 2. sıra diye.

Hiçbirinde her şeye ayrı bir isim vermeyiz; tek bir liste yapar, içindekilere sırasıyla bakarız. Bilgisayarda listenin yaptığı iş tam olarak budur.

Liste nedir?

Bir listeyi, yan yana dizilmiş bir sıra kutu gibi düşün — ve bütün bu sıra, tek bir isim taşır. Değişkenler yazısında bir değişkeni “üstünde etiket olan tek bir kutu” olarak hayal etmiştik; liste, o kutulardan bir dizisidir. Beş notumuzu bir listeye koyalım:

notlar ← [70, 85, 90, 60, 100]

Bu satır tanıdık: sağdaki değeri sol taraftaki isme koyan aynı atama oku (←). Tek fark, bu kez kutuya tek bir sayı değil, köşeli parantez içinde bir sıra sayı koyuyoruz. Artık notlar adında tek bir ismimiz var ve içinde beş değer, belli bir sırayla duruyor. Bu sırayı bir tabloyla görelim:

Üstteki satır her kutunun konumu (sıra numarası), alttaki satır o kutudaki değer. İkisini birbirine karıştırmamak, bu yazının en önemli noktası — birazdan tekrar tekrar döneceğiz buna. Bir liste sadece sayı tutmak zorunda da değil; değişkenlerdeki gibi metin de tutabilir:

alışveriş ← ["süt", "ekmek", "yumurta"]

Kural aynı: tek isim (alışveriş), içinde sıralı değerler. İster sayı ister metin olsun, liste “aynı türden birçok şeyi tek çatı altında, sırayla tut” demektir.

Listeler neden bu kadar önemli?

Ne olduğunu artık biliyorsun; şimdi bir adım geri çekilip neden bu kadar önemli olduğunu görelim. Çünkü liste, kenarda kalmış küçük bir konu değil — kullandığın hemen her yazılımın altında sessizce çalışan temel taşıdır. Bir düşün:

Gördüğün gibi, gerçek programların yaptığı işin büyük kısmı “aynı türden birçok şeyi” tutmak, gezmek, süzmek ve değiştirmektir — ve bunların hepsi listedir. İşte bu yüzden önceki yazıdaki döngü ile bu yazıdaki liste, bir araya geldiğinde programlamanın en çok kullanılan ikilisini oluşturur: liste veriyi tutar, döngü onu işler. Bu ikiliyi kavradığında, gerçek yazılımların nasıl çalıştığının yarısını çözmüş olursun.

Bir elemana nasıl ulaşırız? Konum (index)

Listeyi kurduk; peki içindeki tek bir değere nasıl ulaşırız? İşte listenin sihri burada: her kutunun bir konumu (sıra numarası) var ve o numarayı söyleyerek istediğin kutuya doğrudan uzanırsın. Bunu köşeli parantezle yazarız:

notlar ← [70, 85, 90, 60, 100]
YAZ notlar[1]      → 70   (birinci not)
YAZ notlar[3]      → 90   (üçüncü not)
YAZ notlar[5]      → 100  (beşinci, yani son not)

notlar[3] şöyle okunur: “notlar listesinin 3. sırasındaki değer.” Parantez içindeki sayı konumdur, cevap ise o konumdaki değerdir. Bu ikisi bambaşka şeyler:

Konumun asıl gücü şurada ortaya çıkar: parantezin içine sabit bir sayı yerine bir değişken koyabilirsin. notlar[i] dersen, i neyse o konumdaki elemanı verir — i 1 iken 70, i 4 iken 60. Aklına bir şey geldi mi? i’yi bir döngüyle 1, 2, 3… diye artırırsak, tek satırla bütün listeyi gezebiliriz. Birazdan tam da bunu yapacağız. Ama önce, yeni başlayanların başına bela olan o meşhur ayrıntıyı konuşmalıyız.

Listeyi döngüyle gezmek

Şimdi bu yazının kalbindeki fikre geldik: liste ile döngü el ele. Bir listenin bütün elemanlarına baştan sona tek tek bakmaya, listeyi gezmek (dolaşmak) diyoruz. Kalıp şu: bir sayaç 1’den başlar, listenin uzunluğuna kadar ilerler ve her turda liste[sayaç] ile o sıradaki elemana uzanır.

Bir listenin kaç elemanı olduğunu soran küçük bir yardımcıya ihtiyacımız var; ona uzunluk(...) diyeceğiz. uzunluk(notlar), beş elemanlı listemiz için 5 verir. Şimdi bütün notları ekrana yazdıralım — döngüler yazısındaki sayaçlı döngünün ta kendisi, sadece sayaç artık bir konuma dönüşüyor:

notlar ← [70, 85, 90, 60, 100]
i ← 1
ZAMAN i ≤ uzunluk(notlar) DOĞRU İKEN
    YAZ notlar[i]
    i ← i + 1
DÖNGÜ SONU

Üç parçayı döngülerden tanıyorsun: başlangıç (i ← 1), koşul (i ≤ uzunluk(notlar)) ve ilerletme (i ← i + 1). Tek yenilik, döngünün gövdesindeki notlar[i] — yani “şu an kaçıncı turdaysak, o sıradaki not.” Aynı fikri akış şemasıyla da görelim; önceki yazıdaki döngü şemasının neredeyse aynısı, sadece kutuların içi değişti:

flowchart TD
    A([Başla]) --> B["notlar ← [70, 85, 90, 60, 100]"]
    B --> C["i ← 1"]
    C --> D{"i ≤ uzunluk(notlar) mi?"}
    D -- Evet --> E["YAZ notlar[i]"]
    E --> F["i ← i + 1"]
    F --> D
    D -- Hayır --> G([Bitti])

O geriye dönen ok (F’den D’ye) yine döngünün kalbi. Şimdi döngüyü kâğıtta yürütelim — değişkenler ve döngüler yazılarından tanıdığın izleme tablosu ile:

i 6 olunca koşul yanlış çıkıyor ve döngü tam listenin sonunda, kibarca duruyor. Dikkat et: sayaç i hem turları sayıyor hem de konumu gösteriyor — listeyi gezerken bu ikisi bir araya geliyor. İşte döngü ile listenin neden bu kadar iyi anlaştığının sebebi bu.

Listeyle biriktirmek: toplam ve ortalama

Listeyi gezmeyi öğrendiysen, artık onunla gerçek bir iş yapabiliriz. Döngüler yazısındaki biriktirme kalıbını hatırla: döngüden önce bir biriktirici kurar, her turda ona ekler, sonunda tek bir sonuç alırdık. Şimdi tam olarak aynı kalıbı listeye uyguluyoruz — beş notun ortalamasını bulalım:

notlar ← [70, 85, 90, 60, 100]
toplam ← 0
i ← 1
ZAMAN i ≤ uzunluk(notlar) DOĞRU İKEN
    toplam ← toplam + notlar[i]
    i ← i + 1
DÖNGÜ SONU
ortalama ← toplam / uzunluk(notlar)
YAZ ortalama

Burada iki değişken var, tıpkı döngülerdeki gibi rolleri ayrı: i konumu ilerleten sayaç, toplam ise sonucu biriken biriktirici. Her turda toplam, o sıradaki nota göre büyüyor: 0 → 70 → 155 → 245 → 305 → 405. Döngü bitince toplam 405 olur; onu eleman sayısına (5) bölünce ortalama 81 çıkar.

En yükseği ve en düşüğü bulmak

Döngüler yazısında “toplama, sayma, en büyüğü bulma… hepsi aynı biriktirme kalıbının çeşitleridir” demiştik. Şimdi bir liste elimizde olduğuna göre, o “en büyüğü bulma”yı gerçekten yapabiliriz: notların en yükseğini bulalım.

Fikir basit ve çok insani: elinde bir kâğıt tut, üstüne şimdilik ilk notu yaz. Sonra listeyi gezerken, gördüğün her not elindekinden büyükse kâğıdı güncelle. Sona geldiğinde kâğıtta en yüksek not kalır:

notlar ← [70, 85, 90, 60, 100]
enYuksek ← notlar[1]
i ← 2
ZAMAN i ≤ uzunluk(notlar) DOĞRU İKEN
    EĞER notlar[i] > enYuksek İSE
        enYuksek ← notlar[i]
    BİTİREĞER
    i ← i + 1
DÖNGÜ SONU
YAZ enYuksek

Dikkat ettin mi, bu örnekte üç yapı da bir arada çalışıyor: listeyi bir döngüyle geziyoruz, her turda bir koşulla (koşullar) karşılaştırma yapıyoruz ve sonucu bir biriktiriciye yazıyoruz. Serinin bütün parçaları — değişken, koşul, döngü, liste — burada tek bir küçük programda buluşuyor. Kâğıtta yürüt: enYuksek sırayla 70 → 85 → 90 → 90 → 100 olur; 60’a rastladığında değişmez (çünkü 60, 90’dan büyük değil), sonunda 100’de durur.

Listede aramak: bir şey var mı, nerede?

Sık ihtiyaç duyulan bir başka iş: bir değerin listede olup olmadığını bulmak. Yoklamada bir isim var mı? Sepette şu ürün var mı? Bunun için de listeyi gezip her elemanı aradığımızla karşılaştırırız. Sonucu tutmak için bir evet/hayır bayrağı kullanırız — değişkenler yazısındaki doğru/yanlış (boolean) değerlerini hatırla:

isimler ← ["Ada", "Ali", "Zeynep", "Can"]
aranan  ← "Zeynep"
bulundu ← yanlış
i ← 1
ZAMAN i ≤ uzunluk(isimler) DOĞRU İKEN
    EĞER isimler[i] = aranan İSE
        bulundu ← doğru
    BİTİREĞER
    i ← i + 1
DÖNGÜ SONU
YAZ bulundu

Mantık şu: bayrağı en baştan yanlış kabul ederiz (“daha bulamadık”). Listeyi gezerken aradığımıza rastlarsak bayrağı doğruya çeviririz. Döngü bitince bayrak, o değerin listede olup olmadığını söyler. Sadece var mı değil, kaçıncı sırada olduğunu da öğrenmek istersen, bayrağın yanına bir de konum yaz: EĞER bloğunun içine konum ← i ekle — döngü bitince konum, aradığın elemanın sırasını tutar.

Listeyi değiştirmek: ekle, düzelt, sil

Şimdiye kadar listelerimiz kurulduğu gibi kaldı. Ama gerçek listeler yaşar: alışveriş listesine yeni bir şey eklersin, bir notu düzeltirsin, sepetten bir ürünü çıkarırsın. Üç temel iş var; bunlara bir listenin “günlük hayatı” diyebiliriz.

Bir elemanı düzeltmek kolay — konumu seçip ona yeni bir değer atarsın. Bu, değişkenlerdeki atamanın aynısı, sadece hedef artık listenin bir kutusu:

notlar ← [70, 85, 90, 60, 100]
notlar[4] ← 75          (dördüncü not artık 60 değil, 75)
YAZ notlar[4]           → 75

Listenin sonuna eleman eklemek için EKLE diyeceğiz: listeye yeni bir değeri sona iliştirir, liste bir kutu uzar:

alışveriş ← ["süt", "ekmek", "yumurta"]
alışveriş'e "peynir" EKLE
YAZ uzunluk(alışveriş)   → 4   (liste artık dört elemanlı)

Bir elemanı silmek için ÇIKAR diyeceğiz: değeri listeden çıkarır, liste bir kutu kısalır:

alışveriş ← ["süt", "ekmek", "yumurta", "peynir"]
alışveriş'ten "ekmek" ÇIKAR
YAZ uzunluk(alışveriş)   → 3   ("ekmek" gitti; liste: süt, yumurta, peynir)

Listenin uzunluğunun değişebildiğine dikkat et — bu, listeyi tek bir değişkenden ayıran önemli bir özellik. Bir çalma listesine şarkı eklemek, bir yoklamadan öğrenci çıkarmak, bir notu düzeltmek… hepsi bu üç işten biridir.

Boştan başlayıp liste kurmak

Şu ana kadar listelerimiz hazır değerlerle doğdu. Ama çoğu zaman liste boş başlar ve program çalışırken tur tur dolar — tıpkı boş bir alışveriş sepetini gezerken doldurman gibi. Boş bir liste [] ile kurulur (içinde hiç kutu yok, uzunluk 0’dır), sonra döngü içinde EKLE ile büyür. Bu, gerçek yazılımlarda en sık kullanılan kalıplardan biridir: bir sürü şeyi süzüp yalnızca işine yarayanları biriktirmek.

Bir örnek yapalım: 1’den 20’ye kadar olan sayılardan yalnızca çift olanları bir listede toplayalım. Koşullar yazısındaki MOD ile çift olup olmadığını anlıyoruz (sayı MOD 2 = 0), döngüyle 1’den 20’ye sayıyoruz ve uygun olanları boş listeye ekliyoruz:

çiftler ← []
sayı ← 1
ZAMAN sayı ≤ 20 DOĞRU İKEN
    EĞER sayı MOD 2 = 0 İSE
        çiftler'e sayı EKLE
    BİTİREĞER
    sayı ← sayı + 1
DÖNGÜ SONU
YAZ çiftler        → [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Bu, sözde kod ve döngüler yazılarındaki “1–10 çift sayıları” örneğinin bir üst sürümü: orada çiftleri ekrana yazıyorduk, burada bir listeye topluyoruz — böylece sonradan onları sayabilir, toplayabilir, tekrar gezebiliriz.

İki liste yan yana: paralel listeler

Çoğu zaman tek bir bilgi değil, birbirine bağlı bilgiler tutmak isteriz: her öğrencinin hem adı hem notu var. Basit bir yol, iki ayrı liste tutup aynı konumu aynı öğrenciye denk getirmektir. Buna paralel listeler denir: isimler[i] ile notlar[i], aynı i için aynı kişiyi anlatır.

isimler ← ["Ada", "Can", "Zeynep"]
notlar  ← [90, 70, 85]
i ← 1
ZAMAN i ≤ uzunluk(isimler) DOĞRU İKEN
    YAZ isimler[i] + ": " + notlar[i]
    i ← i + 1
DÖNGÜ SONU

Burada + iki metni birbirine ekliyor (değişkenler yazısındaki metin birleştirme). Çıktı sırayla Ada: 90, Can: 70, Zeynep: 85 olur. Tek bir i ile iki listeyi birlikte geziyoruz; çünkü onları aynı sırayla dizdik.

Liste içinde liste: ızgaralar ve tablolar

Şimdiye kadarki listelerimiz tek sıraydı — bir satır kutu. Ama dünya çoğu zaman iki boyutludur: satranç tahtası, tombala kartı, Excel tablosu, bir oyunun haritası, sinemadaki koltuk planı… Hepsi satır ve sütun. Bunu temsil etmenin yolu şaşırtıcı derecede basit: elemanları yine liste olan bir liste. Yani liste içinde liste.

izgara ← [[1, 2, 3],
          [4, 5, 6]]

izgara’nın iki elemanı var ve her biri bir satır (kendisi bir liste): izgara[1], [1, 2, 3] yani birinci satırdır. Tek bir hücreye ulaşmak için iki konum gerekir: önce satır, sonra sütun. izgara[1][2], “birinci satırın ikinci elemanı” yani 2’dir; izgara[2][3] ise 6. Bir tabloyla bakalım:

İki boyutlu bir listeyi gezmek için de iki boyutlu bir gezinti gerekir: iç içe döngü. Döngüler yazısındaki iç içe döngüyü hatırla — dış döngü her tur attığında iç döngü baştan sona döner. İşte tam da o kalıp burada işe yarıyor: dış döngü satırları, iç döngü o satırın sütunlarını dolaşır:

satır ← 1
ZAMAN satır ≤ uzunluk(izgara) DOĞRU İKEN
    sütun ← 1
    ZAMAN sütun ≤ uzunluk(izgara[satır]) DOĞRU İKEN
        YAZ izgara[satır][sütun]
        sütun ← sütun + 1
    DÖNGÜ SONU
    satır ← satır + 1
DÖNGÜ SONU

Dikkat: dıştaki uzunluk(izgara) kaç satır olduğunu (2), içteki uzunluk(izgara[satır]) ise o satırda kaç sütun olduğunu (3) verir. Kâğıtta yürütünce sırayla 1, 2, 3, 4, 5, 6 yazılır — önce birinci satır baştan sona, sonra ikinci satır. Döngüler yazısındaki çarpım tablosu örneğini hatırladın mı? İşte o iç içe döngü, aslında iki boyutlu bir liste üzerinde yürümeye hazırlanmaktı.

Metin de bir listedir: karakterler

Söz verdiğimiz o hoş bağlantıya geldik. Değişkenler yazısında metni (isim ← "Ada") bir değer türü olarak tanımıştık. Aslında bir metin, perde arkasında harflerin (karakterlerin) bir listesidir. Yani liste hakkında öğrendiğin her şey — konum, uzunluk, gezmek — doğrudan metne de uygulanır:

kelime ← "merhaba"
YAZ kelime[1]            → "m"   (birinci harf)
YAZ kelime[4]            → "h"   (dördüncü harf)
YAZ uzunluk(kelime)      → 7     (yedi harf)

Metni de bir listeyi gezdiğin gibi harf harf gezebilirsin. Örneğin bir kelimede belli bir harfin kaç kez geçtiğini sayalım — koşul ve biriktirme bir arada:

kelime ← "kalabalık"
sayaç ← 0
i ← 1
ZAMAN i ≤ uzunluk(kelime) DOĞRU İKEN
    EĞER kelime[i] = "a" İSE
        sayaç ← sayaç + 1
    BİTİREĞER
    i ← i + 1
DÖNGÜ SONU
YAZ sayaç                → 3

Sık yapılan hatalar

Kendin dene

Kalem ve kâğıt yeter. Her egzersizde önce sözde kodu yaz (listeyi gezmeyi unutma: sayaç, uzunluk koşulu, liste[i]), sonra bir izleme tablosu çizip birkaç turu elle çalıştır.

Egzersiz 1 — Listeyi tersten yazdır (kolay)

Elinde sayılar ← [3, 8, 1, 9, 4] listesi var. Elemanları sondan başa doğru ekrana yaz: 4, 9, 1, 8, 3.

Egzersiz 2 — Geçenleri say (orta)

Bir sınıfın notları: notlar ← [45, 70, 30, 88, 55, 90, 40]. 50 ve üzeri alanlar geçti sayılıyor. Kaç kişinin geçtiğini bul ve yazdır.

Egzersiz 3 — Sadece çiftleri topla (orta)

sayılar ← [7, 4, 11, 2, 9, 8, 5] listesindeki yalnızca çift sayıları, sırasını koruyarak yeni bir listeye topla ve o yeni listeyi yazdır.

Egzersiz 4 — En yüksek notu kim aldı? (paralel liste)

İki paralel liste var: isimler ← ["Ada", "Can", "Zeynep", "Ali"] ve notlar ← [72, 95, 88, 95]. En yüksek notu ve o notu alan öğrencinin adını bul.

Egzersiz 5 — Izgaranın toplamı (mini proje)

İki boyutlu bir liste: izgara ← [[5, 3, 8], [1, 9, 2], [7, 4, 6]]. Izgaradaki bütün sayıların toplamını bul ve yazdır.

Özet