Stack, Queue ve Linked List Nedir? Farkları ve Kullanım Alanları

Stack, queue ve linked list, verileri bellekte farklı mantıklarla organize eden temel veri yapılarıdır: stack son giren ilk çıkar (LIFO) mantığıyla, queue ilk giren ilk çıkar (FIFO) mantığıyla çalışır, linked list ise verileri düğümler halinde birbirine zincirleyerek saklar. Bu üç yapı, bir yazılımcının günlük hayatta karşılaştığı geri alma işlemleri, sıra yönetimi ve dinamik veri depolama gibi problemleri çözmek için kullanılır. Bu yazıda her birinin mantığını, Python ile nasıl kurulacağını ve nerede işine yarayacağını adım adım göreceksin.

Veri Yapısı Nedir ve Neden Öğrenmelisin?

Veri yapısı, en yalın tanımıyla verinin bellekte hangi düzende tutulduğunu ve bu veriye nasıl erişileceğini belirleyen organizasyon biçimidir. Bir programda sayılar, metinler veya nesneler tek başına yeterli değildir; bu değerlerin birbirine göre konumu, erişim sırası ve değişim şekli de en az veri kadar önemlidir. İşte veri yapıları tam olarak bu ihtiyacı karşılar: verinin ne olduğu değil, nasıl saklandığı ve nasıl kullanıldığı sorusuna cevap verir.

Python'da öğrendiğin ilk veri yapısı büyük ihtimalle liste (array benzeri bir yapı) olmuştur. Liste, sırayla veri tutmak için pratik bir çözümdür ama her problem için ideal değildir. Örneğin bir metin editöründe "geri al" (undo) özelliği yapmak istediğinde, ya da bir müşteri hizmetleri sisteminde sırayla işlem yapmak gerektiğinde, düz bir listenin mantığı yetersiz kalır. Verinin ortasına sürekli eleman eklemek, belirli bir sırayı korumak veya son eklenen elemana öncelik vermek gibi ihtiyaçlar, listeden farklı davranan yapılar gerektirir.

Bu noktada devreye stack, queue ve linked list girer. Bu üç yapı, verinin ekleniş ve çıkarılış sırasını farklı kurallarla yöneterek, günlük yazılım problemlerinin çoğuna doğal bir çözüm sunar. Bu yazıda yalnızca bu üç temel yapıya odaklanacağız; recursion (özyineleme) ve Big O gibi karmaşıklık analizi konularına burada hiç girmeyeceğiz, çünkü onlar başka bir yazının konusu. Amacımız, algoritma temellerine yeni başlayan biri olarak bu üç yapının mantığını net ve sade şekilde kavramanı sağlamak. İstersen konuya geçmeden önce mevcut bilgi seviyeni algoritma bilgi testi ile hızlıca ölçebilirsin; bu sana hangi kavramlara daha çok zaman ayırman gerektiği konusunda fikir verir.

Şimdi sırasıyla stack'ten başlayarak her yapının mantığını, Python kodunu ve gerçek hayattaki karşılığını inceleyelim.

Stack (Yığın) Nedir? LIFO Mantığı Nasıl Çalışır?

Stack (yığın), verilerin LIFO (Last In First Out - Son Giren İlk Çıkar) mantığıyla saklandığı bir veri yapısıdır. Bunu üst üste dizilmiş tabaklara benzetebilirsin: en son koyduğun tabağı en önce alırsın, en alttaki tabağa ulaşmak için üsttekileri sırayla kaldırman gerekir. Stack de tam olarak böyle çalışır; en son eklenen eleman, çıkarılacak ilk elemandır.

Stack üzerinde yapılan iki temel işlem vardır: push ve pop. Push, yığının en üstüne yeni bir eleman ekler. Pop ise yığının en üstündeki elemanı çıkarır ve döndürür. Bu iki işlem dışında genellikle yığının en üstündeki elemana bakmak için "peek" gibi yardımcı bir işlem de kullanılır, ancak temel mantık push ve pop ikilisidir.

Python'da stack'i en basit haliyle bir liste kullanarak simüle edebilirsin. Listenin sonuna ekleme yapan append() metodu push işlevi görürken, listenin sonundan eleman çıkaran pop() metodu pop işlevi görür:

stack = []

# push işlemleri
stack.append("sayfa1")
stack.append("sayfa2")
stack.append("sayfa3")

print(stack)  # ['sayfa1', 'sayfa2', 'sayfa3']

# pop işlemi - en son eklenen çıkar
son_sayfa = stack.pop()
print(son_sayfa)   # sayfa3
print(stack)        # ['sayfa1', 'sayfa2']

Stack, günlük hayatta ve yazılımda oldukça sık karşına çıkar. En tanıdık örneği tarayıcının geri butonudur: her ziyaret ettiğin sayfa yığına eklenir, geri tuşuna bastığında en son ziyaret ettiğin sayfa (yığının tepesindeki) açılır. Benzer şekilde metin editörlerindeki undo (geri alma) işlemi de bir stack ile çalışır; yaptığın her işlem yığına eklenir ve geri alma isteğinde en son işlem geri alınır. Ayrıca bir kod editöründe parantez, süslü parantez veya köşeli parantezlerin doğru eşleşip eşleşmediğini kontrol eden parantez kontrolü algoritmaları da stack mantığını kullanır: açılan her parantez yığına eklenir, kapanan parantez geldiğinde yığının tepesiyle eşleştirilir.

Queue (Kuyruk) Nedir? FIFO Mantığı Nasıl Çalışır?

Queue (kuyruk), verilerin FIFO (First In First Out - İlk Giren İlk Çıkar) mantığıyla işlendiği bir veri yapısıdır. Bunu bir markette kasada sıraya girmeye benzetebilirsin: sıraya ilk giren kişi, kasada işlemini ilk yaptıran kişi olur. Yeni gelenler sıranın arkasına eklenir, işlem gören kişi ise sıranın önünden ayrılır. Queue de aynı mantıkla çalışır; en önce eklenen eleman, en önce çıkarılan elemandır.

Queue üzerindeki iki temel işlem enqueue ve dequeue'dur. Enqueue, kuyruğun sonuna yeni bir eleman ekler. Dequeue ise kuyruğun önündeki elemanı çıkarır ve döndürür. Stack'ten farklı olarak burada ekleme ve çıkarma işlemleri kuyruğun farklı uçlarında gerçekleşir; bu da FIFO mantığının temelini oluşturur.

Python'da queue işlemleri için normal listeyi kullanmak performans açısından verimli değildir, çünkü listenin başından eleman çıkarmak listenin tamamını kaydırmayı gerektirir. Bunun yerine Python'ın standart kütüphanesindeki collections.deque yapısı tercih edilir; bu yapı her iki uçtan da hızlı ekleme ve çıkarma yapabilir:

from collections import deque

kuyruk = deque()

# enqueue işlemleri
kuyruk.append("musteri1")
kuyruk.append("musteri2")
kuyruk.append("musteri3")

print(kuyruk)  # deque(['musteri1', 'musteri2', 'musteri3'])

# dequeue işlemi - en once eklenen cikar
sirdaki = kuyruk.popleft()
print(sirdaki)  # musteri1
print(kuyruk)    # deque(['musteri2', 'musteri3'])

Queue yapısı, sıralı işlem gerektiren pek çok sistemde karşımıza çıkar. Ofislerde birden fazla kişinin aynı yazıcıyı kullandığı durumlarda oluşan yazıcı kuyruğu tam olarak bu mantıkla çalışır: ilk gönderilen belge ilk yazdırılır. Bankalarda veya hizmet noktalarında oluşturulan müşteri sırası sistemleri de aynı prensibi kullanır. Yazılım tarafında ise işletim sistemlerindeki ve sunuculardaki görev zamanlama sistemleri, gelen istekleri veya işlemleri sırayla işlemek için queue yapısından faydalanır; böylece hiçbir istek atlanmaz ve sıra adaleti korunur.

Linked List (Bağlı Liste) Nedir? Düğüm Zinciri Mantığı

Linked list, verilerin dizideki gibi yan yana değil, birbirine referanslarla bağlı küçük parçalar hâlinde tutulduğu bir veri yapısıdır. Bu yapının temel taşı "node" yani düğümdür. Her düğüm iki şeyden oluşur: içinde tuttuğu veri ve zincirdeki bir sonraki düğümün adresini gösteren bir referans. Bu mantığı anladığında, linked list aslında birbirine tutunan halkalardan oluşan bir zincirden farksızdır; her halka kendinden sonrakini bilir, ama bütün zinciri tek bakışta göremezsin — baştan başlayıp adım adım ilerlemen gerekir.

En basit hâli "tekli bağlı liste" (singly linked list) olarak adlandırılır. Bu yapıda her düğüm sadece bir sonraki düğümü işaret eder, geriye dönüş yoktur. Zincirin başlangıç noktasına "head" denir ve tüm liste bu noktadan itibaren dolaşılır. Son düğümün "sonraki" referansı ise boş (None) değerini tutar, çünkü zincir orada biter.

Python ile bu mantığı çok az kodla kurabilirsin. Aşağıdaki örnek basit bir Node sınıfı ve üç düğümden oluşan küçük bir zincir oluşturur:

class Node:
    def __init__(self, veri):
        self.veri = veri
        self.sonraki = None

# Zinciri elle bağlama
dugum1 = Node("A")
dugum2 = Node("B")
dugum3 = Node("C")

dugum1.sonraki = dugum2
dugum2.sonraki = dugum3

# Zinciri baştan sona gezme
mevcut = dugum1
while mevcut is not None:
    print(mevcut.veri)
    mevcut = mevcut.sonraki

Bu kodda dikkat etmen gereken nokta şu: veriler bellekte yan yana değil, her biri kendi başına var olup birbirini referansla bulur. İşte linked list'in en büyük avantajı da tam burada ortaya çıkar. Zincire yeni bir düğüm eklemek ya da aradan bir düğüm çıkarmak istediğinde, sadece komşu referansları güncellemen yeterlidir; diğer düğümleri kaydırmana gerek kalmaz. Bu esneklik, özellikle sık ekleme-çıkarma yapılan senaryolarda linked list'i pratik bir seçenek hâline getirir. Bu mantığı kod üzerinde deneyerek pekiştirmek istersen, Python bilgi seviyeni ölçen ücretsiz test ile hem sınıf yapıları hem de referans mantığına ne kadar hâkim olduğunu görebilirsin.

Dizi (Array) ile Linked List Arasındaki Farklar

Diziler ile linked list'ler aynı amaca hizmet etse de -bir grup veriyi bir arada tutmak- birbirinden oldukça farklı çalışır. Dizide tüm elemanlar bellekte ardışık olarak, yan yana yerleşir. Bu sayede bir elemana index numarasıyla doğrudan ulaşabilirsin. Linked list'te ise durum tam tersidir: düğümler bellekte dağınık şekilde durur, birbirlerini yalnızca referanslarla bulur. Bir elemana ulaşmak istediğinde zinciri baştan itibaren adım adım takip etmen gerekir.

Bir diğer önemli fark boyut esnekliğidir. Klasik dizilerde boyut genellikle önceden belirlenir ve büyütmek ya da küçültmek yeni bir dizi oluşturmayı gerektirebilir. Linked list ise dinamik bir yapıdır; ihtiyaç oldukça yeni düğümler eklenir ya da mevcut düğümler zincirden çıkarılır, bu işlem için önceden bir boyut belirlemene gerek yoktur.

Ortadan eleman ekleme veya silme konusunda da yapılar ayrışır. Dizide ortaya bir eleman eklemek istediğinde, o noktadan sonraki tüm elemanları bir sağa kaydırman gerekir. Linked list'te ise sadece ilgili düğümün komşu referanslarını güncellemen yeterlidir, geri kalan düğümler yerinde kalır. Bu, sayısal karmaşıklık hesaplarına girmeden bile sezgisel olarak fark edilebilecek bir avantajdır.

Bu farkları toplu şekilde görmek istersen aşağıdaki tablo iki yapıyı kavramsal düzeyde karşılaştırır:

Her iki yapının da kendine göre kullanım senaryosu vardır; biri diğerinden mutlak olarak üstün değildir, sadece ihtiyaca göre uygunluk değişir.

Gerçek Hayattan Benzetmelerle Stack, Queue ve Linked List

Bu üç veri yapısını kâğıt üzerinde tanımlamak bazen soyut kalabilir; oysa günlük hayattan tanıdık örneklerle düşününce mantık çok daha hızlı oturur.

Stack için en klasik benzetme tabak yığınıdır. Bir dolaba tabakları üst üste dizdiğini düşün: en son koyduğun tabağı, ihtiyaç olduğunda ilk sen alırsın. Yığının altındaki tabaklara ulaşmak için önce üsttekileri kaldırman gerekir. Bu, tam olarak LIFO mantığının -son giren ilk çıkar- günlük hayattaki karşılığıdır.

Queue için ise en tanıdık örnek market kasasındaki sıradır. Sıraya ilk giren müşteri, kasada ilk hizmeti alan kişi olur; sıraya sonradan katılanlar ise arkaya eklenir ve sırayla beklerler. Kimse araya girip önden geçemez, herkes geldiği sırayla işlem görür. Bu davranış, FIFO mantığının -ilk giren ilk çıkar- somut bir yansımasıdır.

Linked list için ise en açıklayıcı benzetme tren vagonları zinciridir. Her vagon kendi içinde bir yolcu grubunu (veriyi) taşır ve bir sonraki vagona bir bağlantı noktasıyla tutunur. Trene yeni bir vagon eklemek istediğinde, sadece bağlantı noktalarını değiştirirsin; tüm vagonları yeniden dizmene gerek kalmaz. Aynı şekilde bir vagonu trenden çıkarmak istediğinde de komşu vagonları birbirine bağlaman yeterlidir.

Bu tür benzetmeler, özellikle veri yapılarına yeni başlayan bir öğrenci için soyut kavramları somutlaştırma açısından oldukça değerlidir. Bir kavramı ilk kez kod üzerinden değil, günlük hayattan tanıdığın bir sahneden hatırlaman, ileride kod yazarken "burada hangi yapıyı kullanmalıyım" sorusuna çok daha hızlı cevap vermeni sağlar. Nitekim iyi bir zihinsel model kurmak, ezberden çok daha kalıcı bir öğrenme biçimidir.

Hangi Problemde Hangi Veri Yapısı Kullanılır?

Buraya kadar stack, queue ve linked list yapılarını ayrı ayrı incelendi; şimdi asıl soruya gelelim: bir problemle karşılaştığında hangi yapıyı seçmelisin? Bu kararı vermek için karmaşık formüllere değil, problemin "veriyle ne yapmak istediğine" bakmaya ihtiyacın var. Aşağıdaki tablo, üç yapının çalışma mantığını ve tipik kullanım senaryolarını yan yana göstererek seçim sürecini kolaylaştırır.

Tabloyu okurken aslında basit bir soru sorman yeterli: "Verinin sırası mı önemli, geri dönüş mü önemli, yoksa sık değişen bir yapı mı yönetiyorum?" Sırayı bozmadan işlem yapman gereken senaryolarda queue devreye girer; bir işlemi geri almak veya en son yapılan adıma dönmek istediğinde stack mantığı işini görür. Elemanların ortasına sürekli ekleme veya çıkarma yapman gereken, boyutu sık değişen durumlarda ise linked list dizilere göre daha esnek bir çözüm sunar. Bu üç yapıyı gerçek kod üzerinde defalarca deneyimlemek, mantığı ezberden çıkarıp kalıcı hale getirmenin en pratik yolu. Python temelli video eğitimler bu tür veri yapılarını örnek proje üzerinden adım adım göstererek öğrenme sürecini somutlaştırır.

Bu Veri Yapılarını Pekiştirmek İçin Sonraki Adımlar

Stack, queue ve linked list gibi kavramları bir kez okuyup geçmek, onları gerçekten öğrenmek anlamına gelmez. Bu yapıların mantığı ancak kendi ellerinle kod yazdığında, hata aldığında ve o hatayı çözdüğünde yerleşir. Bu yüzden bu makaledeki örnekleri kopyala-yapıştır yapmak yerine, boş bir dosyada baştan kendin yazmayı dene; push-pop veya enqueue-dequeue fonksiyonlarını kendi mantığınla kurmaya çalış.

Kendi stack, queue ve linked list implementasyonlarını sıfırdan yazmak, hazır kütüphaneleri kullanmaktan çok daha öğreticidir; çünkü bir düğümün nasıl bağlandığını veya bir elemanın nereden çıkarılacağını satır satır kurgulamak zorunda kalırsın. Bu süreçte küçük hatalar yapman normaldir; her hata, veri yapısının iç mantığını daha iyi kavramana yardımcı olur. Örneğin bir linked list'te "sonraki" işaretçisini yanlış güncellediğinde zincirin nasıl koptuğunu görmek, konuyu teoride okumaktan çok daha kalıcı bir öğrenme sağlar.

Bu yapıları rahat kavramanın en önemli ön koşullarından biri, sağlam bir Python temelidir. Değişkenler, döngüler, fonksiyonlar ve sınıflar konusunda kendine güvenmiyorsan, stack ve queue gibi yapılar gereğinden karmaşık görünebilir. birebir Python dersleri ile bu temelleri sağlamlaştırmak, veri yapılarına geçişi çok daha akıcı hale getirir. Temeller oturduktan sonra sırada recursion (özyineleme) mantığı ve algoritmaların verimliliğini ölçen Big O kavramı gibi ileri konular var; bu başlıklar, kendi derinlikleri nedeniyle ayrı yazılarda ele alınıyor. Şimdilik odak noktan, stack, queue ve linked list yapılarını rahatça kod yazarak kurabilmek olmalı.

Sık Sorulan Sorular

Stack ve queue arasındaki temel fark nedir?

Stack, LIFO yani son giren ilk çıkar mantığıyla çalışır; en son eklenen eleman en önce çıkarılır. Queue ise FIFO yani ilk giren ilk çıkar mantığına dayanır; ilk eklenen eleman ilk çıkarılır. Bu fark, iki yapının kullanım alanlarını da doğrudan belirler.

Linked list ile dizi (array) arasındaki en büyük fark nedir?

Dizide elemanlar bellekte art arda ve sabit boyutlu bir alanda tutulurken, linked list'te her eleman kendi belleğinde durur ve bir sonraki elemana işaretçiyle bağlanır. Bu yüzden linked list'e eleman ekleme veya çıkarma, dizide olduğu gibi diğer elemanları kaydırmayı gerektirmez.

Stack gerçek hayatta hangi durumlara benzetilebilir?

Stack, üst üste dizilmiş tabak yığınına benzetilir; en son konan tabak en önce alınır. Bir metin editöründeki geri al (undo) özelliği de aynı mantıkla çalışır; en son yapılan işlem önce geri alınır.

Queue hangi tür programlarda ve sistemlerde kullanılır?

Queue, sırayla işlenmesi gereken görevlerin bulunduğu sistemlerde kullanılır; yazıcıya gönderilen belgelerin sırayla basılması veya bir sunucuya gelen isteklerin geldiği sırayla işlenmesi bu mantığa örnektir. Verinin sırasının bozulmaması gereken her senaryoda queue tercih edilir.

Linked list bazı durumlarda diziden neden daha avantajlıdır?

Bir listenin ortasına veya başına sık sık eleman eklenip çıkarılması gerektiğinde linked list, dizideki gibi tüm elemanları kaydırma zorunluluğu getirmez; yalnızca ilgili düğümlerin işaretçilerini günceller. Bu da sık değişen, dinamik boyutlu veri kümelerinde linked list'i pratik bir seçenek yapar.

Stack, queue ve linked list öğrenmeye hangi ön bilgiyle başlamalıyım?

Bu yapıları rahat kavramak için değişkenler, döngüler, fonksiyonlar ve temel sınıf (class) mantığı gibi Python temellerine hakim olmak yeterlidir. Bu temeller sağlamsa stack, queue ve linked list gibi kavramlar çok daha hızlı içselleşir.

Bu veri yapılarını öğrendikten sonra sırada hangi konular var?

Stack, queue ve linked list yapılarını kod yazarak pekiştirdikten sonra, algoritmaların verimliliğini ölçen kavramlar ve fonksiyonların kendini çağırdığı özyineleme mantığı gibi konular sırada yer alır. Bu başlıklar, kendi kapsamları geniş olduğu için ayrı yazılarda ele alınmaktadır.

Stack, queue ve linked list; yazılım dünyasında karşılaşacağın çoğu problemin temelinde yatan üç kritik veri yapısıdır ve bunları kavramak, ileride öğreneceğin daha karmaşık algoritmaların önünü açar. Bilgini pekiştirmek ve nerede eksik olduğunu görmek istersen Python bilgi testini çözerek kendini ölçebilirsin.