Yığın Veri Yapısı Açıklaması

Yığın (Stack), Son Giren İlk Çıkar (LIFO) prensibini izleyen doğrusal bir veri yapısıdır. Bu, yığına eklenen son elemanın ilk çıkarılan eleman olduğu anlamına gelir.

Yığınlar basittir ancak bilgisayar bilimlerinde çok önemlidirler. Fonksiyon çağrılarında, geri alma sistemlerinde, tarayıcı geçmişinde, ifade değerlendirmede, sözdizimi çözümlemesinde, geri izlemede ve birçok gerçek yazılım sisteminde kullanılırlar.

Giriş

Veri yapıları, geliştiricilerin verileri verimli bir şekilde organize etmelerine ve yönetmelerine yardımcı olur. Diziler, bağlı listeler, kuyruklar, yığınlar, ağaçlar, grafikler ve karma tabloları farklı türdeki sorunları çözer.

Yığın, en temel ve kullanışlı veri yapılarından biridir. Gerçek bir tabak yığını gibi davrandığı için anlaşılması kolaydır. Yeni bir tabak eklediğinizde, üstüne koyarsınız. Bir tabak çıkardığınızda, önce üstteki tabağı çıkarırsınız.

Bu davranış birçok programlama durumunda ortaya çıkar. En son eklenen öğenin önce işlenmesi gerektiği her durumda, bir yığın genellikle temiz ve doğal bir çözüm sunar.

Yığın Nedir?

Yığın, ekleme ve çıkarma işlemlerinin aynı uçtan yapıldığı bir öğe koleksiyonudur. Bu uç genellikle yığının tepesi olarak adlandırılır.

Yığın LIFO kuralını izler:

Last In, First Out

Bu, en son eklenen öğenin ilk çıkarılan öğe olduğu anlamına gelir.

Temel fikir basittir:

• Yığının tepesine yeni öğeler ekleyin.

• Yığının tepesinden öğeleri çıkarın.

• Gerektiğinde yığının tepesindeki öğeyi çıkarmadan inceleyin.

• Üstteki öğeyi çıkarmadan veya okumadan önce yığının boş olup olmadığını kontrol edin.

Yığın, rastgele erişime odaklanmaz. Temel amacı erişimi tepeden kontrol etmektir.

Yığının Gerçek Hayat Analojisi

Yığının yaygın bir gerçek hayat örneği tabak yığınıdır.

Üst üste konulmuş tabakları hayal edin:

Top → Plate C
      Plate B
      Plate A

Tabak A ilk konuldu. Tabak B ondan sonra konuldu. Tabak C en son konuldu.

Bir tabak çıkarmamız gerekirse, önce Tabak C'yi çıkarırız çünkü en üsttedir. Bu, LIFO prensibine uyar.

Last added: Plate C
First removed: Plate C

Bu basit fikir, programlamada bir Yığının tam olarak nasıl çalıştığıdır.

LIFO Prensibi

LIFO, Son Giren İlk Çıkar (Last In, First Out) anlamına gelir. Yığına eklenen en son öğenin yığından ilk çıkarılan öğe olduğu anlamına gelir.

Örneğin, değerleri şu sırada eklersek:

10, 20, 30

Yığın şöyle görünecektir:

Top → 30
      20
      10

Bir öğeyi çıkarırsak (pop), 30 değeri önce kaldırılır çünkü en üsttedir.

Bu davranış, İlk Giren İlk Çıkar (FIFO) prensibini izleyen bir Kuyruktan (Queue) farklıdır.

Temel Yığın İşlemleri

Bir Yığın genellikle küçük bir dizi önemli işlem destekler.

• push (ekle): Yığının tepesine bir öğe ekler.

• pop (çıkar): En üstteki öğeyi kaldırır ve döndürür.

• peek (göz at): En üstteki öğeyi kaldırmadan döndürür.

• isEmpty (boş mu): Yığının hiç öğe içerip içermediğini kontrol eder.

• size (boyut): Yığındaki öğe sayısını döndürür.

Bu işlemler, en son verilerin önce işlenmesi gereken birçok sorunu çözmek için yeterlidir.

Push İşlemi

Push işlemi, yığına yeni bir öğe ekler.

Yığın boşsa ve 10 eklersek, yığın şunlar olur:

Top → 10

20 eklersek, yığın şunlar olur:

Top → 20
      10

30 eklersek, yığın şunlar olur:

Top → 30
      20
      10

Her yeni öğe, önceki üst öğenin üzerine yerleştirilir.

Pop İşlemi

Pop işlemi, yığının tepesindeki öğeyi kaldırır ve döndürür.

Bu yığını ele alalım:

Top → 30
      20
      10

Pop çağırırsak, 30 değeri kaldırılır.

Removed: 30

Yığın şunlar olur:

Top → 20
      10

Tekrar pop çağırırsak, 20 değeri kaldırılır.

Removed: 20

Yığın şunlar olur:

Top → 10

Yığın boşken pop işlemi dikkatli kullanılmalıdır. Boş bir yığından çıkarma işlemine genellikle yığın taşması (stack underflow) denir.

Peek İşlemi

Peek işlemi, yığının tepesindeki öğeyi kaldırmadan döndürür.

Bu yığını ele alalım:

Top → 30
      20
      10

Peek çağırırsak, sonuç şudur:

30

Ancak yığın değişmeden kalır:

Top → 30
      20
      10

Peek, kaldırılacak bir sonraki öğeyi incelemek istediğimizde, ancak yığını değiştirmek istemediğimizde kullanışlıdır.

isEmpty İşlemi

isEmpty işlemi, yığının herhangi bir öğe içerip içermediğini kontrol eder.

Eğer yığında hiç öğe yoksa:

[]

isEmpty doğru (true) döndürür.

Eğer yığın öğeler içeriyorsa:

[10, 20, 30]

isEmpty yanlış (false) döndürür.

Bu işlem, pop veya peek çağırmadan önce önemlidir çünkü bu işlemlerin bir üst öğeye erişmesi gerekir.

Manuel Çalıştırma Örneği

Bir dizi Yığın işlemini manuel olarak çalıştıralım.

push(10)
push(20)
push(30)
peek()
pop()
push(40)
pop()
pop()

Boş bir yığınla başlıyoruz:

Stack: []

Adım 1: push(10)

10'u yığının tepesine ekliyoruz.

Stack:
Top → 10

Adım 2: push(20)

20'yi 10'un üzerine ekliyoruz.

Stack:
Top → 20
      10

Adım 3: push(30)

30'u 20'nin üzerine ekliyoruz.

Stack:
Top → 30
      20
      10

Adım 4: peek()

En üstteki öğe 30'dur.

peek() returns 30

Yığın değişmez:

Stack:
Top → 30
      20
      10

Adım 5: pop()

En üstteki öğe olan 30 kaldırılır.

pop() returns 30

Yığın şunlar olur:

Stack:
Top → 20
      10

Adım 6: push(40)

40'ı tepeye ekliyoruz.

Stack:
Top → 40
      20
      10

Adım 7: pop()

En üstteki öğe olan 40 kaldırılır.

pop() returns 40

Yığın şunlar olur:

Stack:
Top → 20
      10

Adım 8: pop()

En üstteki öğe olan 20 kaldırılır.

pop() returns 20

Yığın şunlar olur:

Stack:
Top → 10

Bu manuel çalıştırma, LIFO davranışını açıkça gösterir. En son eklenen değer her zaman ilk çıkarılan değerdir.

Dizi Kullanarak Yığın Uygulaması

Bir Yığın yaygın olarak bir dizi (array) kullanılarak uygulanır. Bu uygulamada, dizinin sonu yığının tepesini temsil eder.

Örneğin:

[10, 20, 30]

30 değeri en üstteki öğedir çünkü dizinin sonundadır.

Dizinin sonunu kullanmak verimlidir çünkü birçok programlama dili dizinin sonundan öğeleri hızlı bir şekilde ekleyip çıkarabilir.

Yığın Pseudokodu

class Stack:
    items = empty array

    push(value):
        add value to end of items

    pop():
        if items is empty:
            return error
        remove and return last item

    peek():
        if items is empty:
            return error
        return last item

    isEmpty():
        return length of items == 0

    size():
        return length of items

Bu pseudokod, belirli bir programlama diline bağlı kalmadan bir Yığının ana davranışını gösterir.

PHP'de Yığın Örneği

İşte dizi kullanarak temiz bir PHP Yığın uygulaması:

<?php

class Stack
{
    private array $items = [];

    public function push(mixed $value): void
    {
        $this->items[] = $value;
    }

    public function pop(): mixed
    {
        if ($this->isEmpty()) {
            throw new RuntimeException('Cannot pop from an empty stack.');
        }

        return array_pop($this->items);
    }

    public function peek(): mixed
    {
        if ($this->isEmpty()) {
            throw new RuntimeException('Cannot peek an empty stack.');
        }

        return $this->items[count($this->items) - 1];
    }

    public function isEmpty(): bool
    {
        return count($this->items) === 0;
    }

    public function size(): int
    {
        return count($this->items);
    }

    public function toArray(): array
    {
        return $this->items;
    }
}

$stack = new Stack();

$stack->push(10);
$stack->push(20);
$stack->push(30);

echo $stack->peek(); // 30
echo PHP_EOL;

echo $stack->pop(); // 30
echo PHP_EOL;

echo $stack->pop(); // 20

Bu uygulama, boş bir yığından pop veya peek çağrıldığında bir istisna (exception) atarak yığını geçersiz işlemlere karşı korur.

JavaScript'te Yığın Örneği

İşte JavaScript'te bir Yığın uygulaması:

class Stack {
    constructor() {
        this.items = [];
    }

    push(value) {
        this.items.push(value);
    }

    pop() {
        if (this.isEmpty()) {
            throw new Error('Cannot pop from an empty stack.');
        }

        return this.items.pop();
    }

    peek() {
        if (this.isEmpty()) {
            throw new Error('Cannot peek an empty stack.');
        }

        return this.items[this.items.length - 1];
    }

    isEmpty() {
        return this.items.length === 0;
    }

    size() {
        return this.items.length;
    }

    toArray() {
        return [...this.items];
    }
}

const stack = new Stack();

stack.push(10);
stack.push(20);
stack.push(30);

console.log(stack.peek()); // 30
console.log(stack.pop());  // 30
console.log(stack.pop());  // 20

JavaScript uygulaması, PHP sürümüyle aynı mantığı izler. Dahili dizi değerleri depolar ve yığının tepesi dizinin sonudur.

Bağlı Liste Kullanarak Yığın Uygulaması

Bir Yığın ayrıca Bağlı Liste (Linked List) kullanılarak da uygulanabilir. Bu versiyonda, bağlı listenin başı yığının tepesini temsil eder.

Bir değer eklediğimizde (push), listenin başına yeni bir düğüm ekleriz. Çıkardığımızda (pop), ilk düğümü kaldırırız.

Top → [30] → [20] → [10] → null

Bu uygulama, dinamik düğüm tabanlı bellek davranışı istediğimizde kullanışlıdır.

JavaScript'te Bağlı Liste Yığın Örneği

class StackNode {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedListStack {
    constructor() {
        this.top = null;
        this.length = 0;
    }

    push(value) {
        const newNode = new StackNode(value);
        newNode.next = this.top;
        this.top = newNode;
        this.length++;
    }

    pop() {
        if (this.isEmpty()) {
            throw new Error('Cannot pop from an empty stack.');
        }

        const removedValue = this.top.data;
        this.top = this.top.next;
        this.length--;

        return removedValue;
    }

    peek() {
        if (this.isEmpty()) {
            throw new Error('Cannot peek an empty stack.');
        }

        return this.top.data;
    }

    isEmpty() {
        return this.top === null;
    }

    size() {
        return this.length;
    }
}

Bu versiyonda, hem push hem de pop bağlı listenin başında çalıştığı için verimlidirler.

Dizi Yığını vs Bağlı Liste Yığını

Hem diziler hem de bağlı listeler bir Yığın uygulamak için kullanılabilir.

Dizi tabanlı bir yığın genellikle daha basittir ve çoğu üst düzey programlama dilinde iyi çalışır. Bağlı liste tabanlı bir yığın, düğüm tabanlı yapıları öğrenirken veya dinamik bellek davranışının önemli olduğu durumlarda kullanışlıdır.

Ana farklar şunları içerir:

• Dizi yığını uygulaması daha kolaydır.

• Bağlı liste yığını düğümler ve referanslar kullanır.

• Dizi yığını ara sıra dahili olarak yeniden boyutlandırılabilir.

• Bağlı liste yığını belleği düğüm düğüm ayırır.

• Her ikisi de O(1) sürede push ve pop destekleyebilir.

Çoğu pratik JavaScript ve PHP örneği için, dizi tabanlı bir yığın anlaşılır ve yeterlidir.

Yığın İşlemlerinin Zaman Karmaşıklığı

Zaman karmaşıklığı, bir işlemin çalışma süresinin öğe sayısı arttıkça nasıl büyüdüğünü açıklar.

Standart bir Yığın için ana işlemler genellikle şu karmaşıklıklara sahiptir:

• push: O(1)

• pop: O(1)

• peek: O(1)

• isEmpty: O(1)

• size: O(1)

• search (ara): O(n)

Push, pop ve peek sabit zamanlı işlemdir çünkü doğrudan yığının tepesiyle çalışırlar.

Push Neden O(1)?

Push işlemi, yığına yeni bir öğe ekler. Tüm öğeleri taraması gerekmez.

Örneğin:

Before:
Top → 20
      10

push(30)

After:
Top → 30
      20
      10

Sadece tepe değişir, bu nedenle işlem sabit zaman alır:

O(1)

Pop Neden O(1)?

Pop işlemi, en üstteki öğeyi kaldırır. Öğeyi aramak zorunda değildir çünkü tepe zaten bilinmektedir.

Before:
Top → 30
      20
      10

pop()

After:
Top → 20
      10

Sadece tepe kaldırılır veya güncellenir, bu nedenle işlem sabit zaman alır:

O(1)

Arama Neden O(n)?

Yığın içinde arama yapmak standart bir Yığın işlemi değildir çünkü Yığınlar yalnızca en üst öğeye erişimi kontrol etmek üzere tasarlanmıştır.

Bir değer aramak gerekirse, öğeleri tek tek incelemek gerekebilir.

Top → 30
      20
      10

10'u aramak için algoritma 30'u, sonra 20'yi, sonra 10'u kontrol etmesi gerekebilir. En kötü durumda, tüm öğeleri kontrol eder.

Bu nedenle, arama şudur:

O(n)

Yığının Alan Karmaşıklığı

Bir Yığının alan karmaşıklığı O(n)'dir, burada n yığında saklanan öğe sayısıdır.

Eklenen her öğe bellek gerektirir. Yığın 100 değer içeriyorsa, 100 değer saklar. 1.000 değer içeriyorsa, 1.000 değer saklar.

Space complexity = O(n)

İşlemlerin kendisi genellikle yalnızca az miktarda ek bellek kullanır, ancak veri yapısı n öğeyi saklar.

Yığın Taşması (Stack Overflow) ve Yığın Alt Taşı (Stack Underflow)

Yığınla ilgili iki önemli hata yığın taşması (stack overflow) ve yığın alt taşıdır (stack underflow).

Yığın taşması (Stack overflow), bir yığının izin verilen bellek sınırını aşmaya çalıştığında meydana gelir. Bu, düşük seviyeli sabit boyutlu yığınlarda veya çok fazla özyinelemeli fonksiyon çağrısı olduğunda meydana gelebilir.

Yığın alt taşı (Stack underflow), bir programın boş bir yığından pop veya peek yapmaya çalıştığında meydana gelir.

Stack: []

pop() → underflow error

İyi Yığın uygulamaları, null döndürerek, bir hata değeri döndürerek veya bir istisna atarak alt taşmayı güvenli bir şekilde ele almalıdır.

Yığınlar ve Fonksiyon Çağrıları

Bir Yığının en önemli gerçek kullanımlarından biri fonksiyon çağrılarını yönetmektir. Programlama dilleri, aktif fonksiyon çağrılarını hatırlamak için bir çağrı yığını (call stack) kullanır.

Bir fonksiyon çağrıldığında, çağrı yığınına yeni bir yığın çerçevesi (stack frame) eklenir. Fonksiyon bittiğinde, yığın çerçevesi kaldırılır.

main()
  calls login()
    calls validateInput()

Çağrı yığını şöyle görünebilir:

Top → validateInput()
      login()
      main()

validateInput() bittiğinde, önce o kaldırılır. Sonra login() devam eder. Bu LIFO'ya uyar.

Yığınlar ve Özyineleme (Recursion)

Özyineleme (Recursion), çağrı yığınına büyük ölçüde bağlıdır. Her özyinelemeli çağrı yığına yeni bir fonksiyon çerçevesi ekler.

Örneğin, özyinelemeli bir faktöriyel fonksiyonu birden çok çağrı oluşturur:

factorial(4)
factorial(3)
factorial(2)
factorial(1)

Son çağrı önce bitmeli, sonra kontol önceki çağrılara geri döner.

Bu nedenle özyineleme, özyineleme derinliği çok büyük hale gelirse yığın taşmasına neden olabilir.

Yığınlar ve Geri Alma Sistemleri

Yığınlar, geri alma (undo) davranışı uygulamak için yaygın olarak kullanılır.

Bir metin düzenleyiciyi, kullanıcının şu eylemleri gerçekleştirdiği bir durumu hayal edin:

Type A
Type B
Delete B

Her eylem bir geri alma yığınına eklenebilir (push):

Top → Delete B
      Type B
      Type A

Kullanıcı geri al (undo) düğmesine bastığında, en son eylem önce tersine çevrilir. Bu tam olarak LIFO davranışıdır.

Yığınlar ve Tarayıcı Geçmişi

Tarayıcı geçmişi de yığınlar kullanılarak anlaşılabilir.

Kullanıcı sayfaları ziyaret ettiğinde:

Home → About → Blog → Contact

Geri düğmesi en son ziyaret edilen önceki sayfaya dönmelidir.

Top → Contact
      Blog
      About
      Home

Kullanıcı geri gittiğinde, İletişim (Contact) önce kaldırılır, sonra Blog en son önceki sayfa olur.

Yığınlar ve İfade Değerlendirme

Yığınlar, matematiksel ifadeleri değerlendirmek ve sözdizimini kontrol etmek için kullanılır.

Örneğin, dengeli parantezleri kontrol ederken:

(a + b) * (c + d)

Algoritma, açılan parantezleri yığına ekler ve eşleşen kapanan parantezler göründüğünde onları kaldırır.

Her açılan parantezin doğru sırada eşleşen bir kapanan parantezi varsa, ifade dengelidir.

Dengeli Parantezler Örneği

Bu ifadeyi kontrol edelim:

{[()]}

İşlem şöyledir:

Read { → push {
Read [ → push [
Read ( → push (
Read ) → pop (, match found
Read ] → pop [, match found
Read } → pop {, match found

Sonunda, yığın boştur, bu nedenle parantezler dengelidir.

Eğer ifade şöyle olsaydı:

{[(])}

Kapanan parantez, en son açılan parantezle eşleşmezdi, bu nedenle ifade geçersiz olurdu.

JavaScript'te Dengeli Parantezler

function isBalanced(expression) {
    const stack = [];
    const pairs = {
        ')': '(',
        ']': '[',
        '}': '{'
    };

    for (const char of expression) {
        if (char === '(' || char === '[' || char === '{') {
            stack.push(char);
        }

        if (char === ')' || char === ']' || char === '}') {
            if (stack.length === 0) {
                return false;
            }

            const top = stack.pop();

            if (top !== pairs[char]) {
                return false;
            }
        }
    }

    return stack.length === 0;
}

console.log(isBalanced('{[()]}')); // true
console.log(isBalanced('{[(])}')); // false

Bu klasik bir Yığın problemidir çünkü en son açılan parantez önce kapatılmalıdır.

Pratik Örnek: JavaScript'te Geri Alma Yığını

İşte basit bir geri alma yığını örneği:

class UndoManager {
    constructor() {
        this.undoStack = [];
    }

    addAction(action) {
        this.undoStack.push(action);
    }

    undo() {
        if (this.undoStack.length === 0) {
            return null;
        }

        return this.undoStack.pop();
    }
}

const manager = new UndoManager();

manager.addAction('Type A');
manager.addAction('Type B');
manager.addAction('Delete B');

console.log(manager.undo()); // Delete B
console.log(manager.undo()); // Type B

En son eylem her zaman önce geri alınır.

Geliştiriciler Ne Zaman Yığın Kullanmalı?

Geliştiriciler, en son öğenin önce işlenmesi gerektiğinde bir Yığın kullanmalıdır.

Yığınlar şu durumlarda kullanışlıdır:

• Geri alma (undo) davranışı gerektiğinde.

• Geri izleme (backtracking) gerektiğinde.

• Fonksiyon çağrıları veya özyineleme söz konusu olduğunda.

• Sözdizimi çözümlemesi gerektiğinde.

• İfade değerlendirme gerektiğinde.

• Tarayıcı benzeri geçmiş davranışı gerektiğinde.

• Derinlik öncelikli arama (depth-first search) yinelemeli olarak uygulanması gerektiğinde.

Ana işaret LIFO davranışıdır. En yeni öğenin önce işlenmesi gerekiyorsa, bir Yığın doğru yapı olabilir.

Ne Zaman Yığın Kullanmamalı?

Öğelerin eklendikleri sırayla işlenmesi gerektiğinde Yığın doğru yapı değildir.

Geliştiriciler şunlar gerektiğinde Yığından kaçınmalıdır:

• İlk giren ilk çıkar (FIFO) davranışı gerektiğinde.

• İndeksle hızlı rastgele erişim gerektiğinde.

• Öğelerin sık sık aranması gerektiğinde.

• Öncelik tabanlı işleme gerektiğinde.

• En eski öğenin önce işlenmesi gerektiğinde.

Bu durumlarda, bir Kuyruk, Dizi, Karma Tablo veya Öncelik Kuyruğu daha uygun olabilir.

Yığın vs Kuyruk

Yığınlar ve Kuyruklar her ikisi de doğrusal veri yapılarıdır, ancak farklı kuralları izlerler.

Bir Yığın LIFO'yu izler:

Last In, First Out

Bir Kuyruk FIFO'yu izler:

First In, First Out

Örneğin, bir Yığın tabak yığını gibidir. En son eklenen tabak önce kaldırılır.

Bir Kuyruk, hizmet için bekleyen insan sırası gibidir. Sıraya ilk giren kişi önce hizmet alır.

Ana farklar şunları içerir:

• Yığın en yeni öğeyi önce kaldırır.

• Kuyruk en eski öğeyi önce kaldırır.

• Yığın push ve pop kullanır.

• Kuyruk enqueue ve dequeue kullanır.

• Yığın geri alma ve geri izleme için kullanışlıdır.

• Kuyruk zamanlama ve bekleme sıraları için kullanışlıdır.

Yığınları Öğrenirken Yaygın Hatalar

Yeni başlayanlar genellikle bir Yığının temel fikrini anlarlar, ancak yine de uygulama hataları yapabilirler.

Yaygın hatalar şunları içerir:

• Yığın ile Kuyruğu karıştırmak.

• Dizinin yanlış ucundan çıkarmak.

• Boş yığın durumlarını işlemeyi unutmak.

• Rastgele erişim gerektiğinde Yığın kullanmak.

• Aramanın O(1) olduğunu varsaymak.

• Özyinelemeli çözümlerde yığın taşmasını göz ardı etmek.

• Sadece peek gerektiğinde yığını değiştirmek.

En güvenli kural basittir: yalnızca en üst öğe doğrudan erişilmelidir.

Yığınları Anlamak İçin Pratik Kontrol Listesi

Kuyruklar, Ağaçlar, Grafikler veya gelişmiş algoritmalara geçmeden önce, geliştiriciler şu soruları yanıtlayabilmelidir:

• LIFO ne anlama gelir?

• Bir Yığının tepesi nedir?

• Push ne yapar?

• Pop ne yapar?

• Peek ne yapar?

• Push ve pop neden O(1)?

• Yığın alt taşı (stack underflow) nedir?

• Yığınlar fonksiyon çağrılarında nasıl kullanılır?

• Yığınlar neden geri alma sistemleri için kullanışlıdır?

• Bir Yığın ile bir Kuyruk arasındaki fark nedir?

Bu sorular netse, geliştirici Yığınların arkasındaki gerçek mantığı anlamış demektir.

Yığınların Avantajları

Yığınların birkaç avantajı vardır.

• Anlaşılması basittir.

• Uygulaması kolaydır.

• Push ve pop O(1)'dir.

• Doğal olarak LIFO davranışını destekler.

• Geri alma, özyineleme, çözümleme ve geri izleme için kullanışlıdır.

• Diziler veya bağlı listeler kullanılarak uygulanabilir.

Bu avantajlar, Yığınları yeni başlayanlar ve profesyoneller için en önemli veri yapılarından biri haline getirir.

Yığınların Dezavantajları

Yığınların da sınırlamaları vardır.

• Hızlı rastgele erişim sağlamazlar.

• FIFO davranışı için uygun değildirler.

• Bir Yığın içinde arama O(n)'dir.

• Bellek sınırlarına ulaşıldığında taşmaya neden olabilirler.

• Yalnızca en üst öğeye doğrudan erişilebildiği için kısıtlayıcıdırlar.

Bu sınırlamalar, bir Yığın doğru amaç için kullanıldığında sorun değildir. Sadece başka bir veri yapısının ne zaman daha iyi olabileceğini tanımlarlar.

Gerçek Yazılım Projelerinde Yığınlar

Geliştiriciler manuel olarak bir Yığın sınıfı oluşturmasa bile, Yığınlar gerçek yazılım projelerinde birçok biçimde ortaya çıkar.

Yaygın gerçek dünya kullanımları şunları içerir:

• Programlama dillerinde çağrı yığını yönetimi.

• Editörlerde geri alma ve yineleme (undo/redo) özellikleri.

• Tarayıcı geri gezinmesi.

• Derleyicilerde sözdizimi çözümlemesi.

• Hesap makinelerinde ifade değerlendirme.

• Geri izleme algoritmaları.

• Grafiklerde derinlik öncelikli arama (DFS).

• Uygulamalarda yönlendirme geçmişi.

Yığınları anlamak, geliştiricilerin bu sistemlerin dahili olarak nasıl çalıştığını anlamalarına yardımcı olur.

Sonuç

Yığın (Stack), Son Giren İlk Çıkar (LIFO) prensibini izleyen doğrusal bir veri yapısıdır. Yığına eklenen son öğe, ilk çıkarılan öğedir.

Ana Yığın işlemleri push, pop, peek, isEmpty ve size'dır. Push bir öğeyi tepeye ekler, pop en üstteki öğeyi kaldırır ve peek en üstteki öğeyi kaldırmadan okur.

Yığınlar genellikle push, pop, peek, isEmpty ve size işlemleri için O(1) zaman karmaşıklığı sağlar. Bir Yığın içinde arama O(n) sürer çünkü yapı rastgele erişim için tasarlanmamıştır.

Yığınlar diziler veya bağlı listeler kullanılarak uygulanabilir. Fonksiyon çağrılarında, özyinelemede, geri alma sistemlerinde, tarayıcı geçmişinde, ifade değerlendirmede, sözdizimi kontrolünde ve geri izlemede kullanılırlar.

Veri Yapıları ve Algoritmalarını öğrenen geliştiriciler için Yığınlar temeldir. Kontrollü erişimi, LIFO davranışını, bellek düşüncesini ve gerçek yazılım sistemlerinde kullanılan birçok algoritmik teknik için temeli öğretirler.