Python ile Yığın (Stack) Kullanımına Yönelik Uygulama Rehberi

Yığınlar (stacks), son eklenen öğenin ilk çıktığı LIFO (Last In First Out) mantığıyla çalışan doğrusal veri yapılarıdır. Bu yapı, özellikle sıralı işlemler gerektiren algoritmalarda ve bellek yönetiminde yaygın olarak kullanılır. Python'da yığınları uygulamak için çeşitli yöntemler mevcut, ancak hangisinin en verimli olduğunu bilmek önemlidir.

Yığınların Temel İşlemleri ve LIFO Mantığı

Yığınlar üç temel işlemle yönetilir:

• Ekleme (Push): Yığına yeni bir öğe ekler. Bu işlem, yığının en üstüne yerleştirilir.
• Görüntüleme (Peek/Top): Yığının en üstündeki öğeyi görüntüler, ancak onu silmez.
• Çıkarma (Pop): Yığının en üstündeki öğeyi çıkarır ve döndürür.

Bu işlemlerin tümü, doğru veri yapısı kullanıldığında sabit süre O(1) karmaşıklığıyla gerçekleştirilebilir. Örneğin, bir listedeki son öğeye doğrudan erişim mümkündür, bu da peek ve pop işlemlerini oldukça verimli hale getirir.

Python'da Yığın Uygulamaları: Listeler vs. Deques

Python'da yığınları uygulamak için en yaygın yöntemler listeler ve collections.deque kullanmaktır. Her ikisinin de avantajları ve dezavantajları bulunmaktadır.

1. Listelerle Yığın Uygulaması

Listeler, Python'daki en basit yığın uygulamasıdır. Öğeleri listenin sonuna ekleyerek ve son öğeyi çıkararak yığın davranışını simüle edebilirsiniz.

stack = [3, 2, 5, 6]
print(stack.pop())  # 6
print(stack)        # [3, 2, 5]

Performans Analizi:

• Ekleme (Push): Ortalama O(1) karmaşıklığına sahiptir. Liste büyüdükçe, Python içsel olarak bellek ayırmasını optimize eder ve bazen yeni bir dizi oluşturur. Bu işlem O(n) karmaşıklığına sahip olsa da, nadiren gerçekleştiği için ortalama karmaşıklık O(1) olarak kabul edilir.
• Görüntüleme (Peek): O(1) karmaşıklığıyla en üst öğeye doğrudan erişim sağlar.
• Çıkarma (Pop): O(1) karmaşıklığıyla son öğeyi çıkarır.

Listelerin en büyük dezavantajı, ortadaki öğelere erişim veya müdahale edebilme yeteneğidir. Bu, yığın mantığını bozabilir, bu yüzden dikkatli kullanılmalıdır.

2. Deques ile Yığın Uygulaması

collections.deque (çift uçlu kuyruk), Python'da yığınlar için daha optimize edilmiş bir seçenektir. Linked list (bağlı liste) mantığıyla çalıştığı için, tüm temel yığın işlemleri sabit süre O(1) karmaşıklığıyla gerçekleştirilir.

from collections import deque

stack = deque()
stack.append(1)
stack.append(2)
stack.append(3)

top = stack.pop()  # 3
print(top)
peek = stack[-1]   # 2
print(peek)
print(stack)       # deque([1, 2])

Performans Analizi:

• Ekleme (Push): O(1) karmaşıklığıyla en sona öğe ekler.
• Görüntüleme (Peek): O(1) karmaşıklığıyla en üst öğeye erişir.
• Çıkarma (Pop): O(1) karmaşıklığıyla en üst öğeyi çıkarır.

Deque'ler, listedeki gibi ortadaki öğelere erişim veya müdahale yeteneğine sahip olmadıkları için, yığın mantığına daha uygundur. Özellikle algoritma problemlerinde (örneğin LeetCode soruları) deque kullanımı performans açısından önemli bir fark yaratabilir.

Özel Yığın Sınıfı Oluşturma: Gerektiğinde Kullanışlı

Bazı durumlarda, standart listeler veya deques yetersiz kalabilir. Örneğin, yığın işlemlerine ek olarak ortadaki öğelere erişim veya müdahale gerektiren senaryolarda, özel bir yığın sınıfı oluşturmak faydalı olabilir. Bu sınıf, sadece yığın mantığına uygun işlemleri destekleyecek şekilde tasarlanabilir.

Aşağıdaki örnek, özel bir yığın sınıfının nasıl oluşturulabileceğini göstermektedir:

from collections import deque

class Yigin:
    def __init__(self):
        self._yigin = deque()

    def ekle(self, ogne):
        self._yigin.append(ogne)

    def cikar(self):
        if not self._yigin:
            raise IndexError("Boş yığından çıkarma işlemi gerçekleştirilemez.")
        return self._yigin.pop()

    def goruntule(self):
        if not self._yigin:
            raise IndexError("Boş yığından görüntüleme yapılamaz.")
        return self._yigin[-1]

    def __repr__(self):
        return f"Yigin({list(self._yigin)})"

# Kullanım örneği
yigin = Yigin()
yigin.ekle(1)
yigin.ekle(2)
yigin.ekle(3)

print(yigin)         # Yigin([1, 2, 3])
print(yigin.goruntule())  # 3
print(yigin.cikar())       # 3
print(yigin.cikar())       # 2
print(yigin.cikar())       # 1
print(yigin.cikar())       # IndexError: Boş yığından çıkarma işlemi gerçekleştirilemez.

Bu sınıf, yığın mantığını sıkı bir şekilde uygular ve yalnızca tanımlı işlemleri destekler. Bu sayede, yanlış kullanımların önüne geçilir ve kodun güvenilirliği artırılır.

Yığınların Gerçek Dünya Uygulamaları

Yığınlar, bilgisayar bilimlerinde ve yazılım geliştirmede geniş bir kullanım alanına sahiptir. İşte bazı yaygın uygulamalar:

• Parantez Eşleştirme (Parentheses Matching): Bir ifadede yer alan parantezlerin doğru şekilde eşleştirilip eşleştirilmediğini kontrol eder. Örneğin, "( [ ] )" doğru, "( [ ) ]" yanlıştır.
• Ağaç Gezintileri (Tree Traversals): Derinlik Öncelikli Arama (DFS) algoritmasında kullanılır.
• Bellek Yönetimi: Fonksiyon çağrıları ve yerel değişkenlerin yönetiminde kullanılır.
• Geri Al/Yeniden Yap (Undo/Redo) İşlemleri: Metin editörlerinde ve grafik araçlarda kullanılır.

Örneğin, parantez eşleştirme problemi aşağıdaki gibi çözülebilir:

from collections import deque

def parantez_eslestir(ifade):
    eslestirme = {')': '(', '}': '{', ']': '['}
    yigin = deque()

    for karakter in ifade:
        if karakter in eslestirme:
            if not yigin or yigin.pop() != eslestirme[karakter]:
                return False
        else:
            yigin.append(karakter)
    return not yigin

print(parantez_eslestir("( [ ] ) { }"))  # True
print(parantez_eslestir("( [ ) ]"))      # False

Yığınlar, algoritma tasarımında ve veri yapılarında temel bir rol oynar. Python'da doğru yöntemi seçmek, hem performansı artırır hem de kodun okunabilirliğini ve güvenilirliğini sağlar.