Implementasi Struktur Data Stack di Python

EGGI SATRIA

October 1, 2024

Pemerograman

Implementasi Struktur Data Stack di Python

Artikel ini membahas cara mengimplementasikan struktur data stack di Python dengan menerapkan praktik terbaik, seperti penanganan error, pengelolaan kapasitas stack, serta contoh penggunaan stack dalam kehidupan nyata. Salah satu contoh aplikasi stack yang akan dibahas adalah membalikkan array, yang menunjukkan sifat Last-In-First-Out (LIFO) pada stack.

Stack adalah salah satu konsep mendasar dalam struktur data yang banyak digunakan dalam algoritma, seperti depth-first search (DFS), proses rekursi, dan pengelolaan undo/redo pada aplikasi. Menguasai implementasi stack di Python akan memberi Anda fondasi kuat dalam mengelola data secara efisien.

Apa itu Stack?

Stack adalah kumpulan data yang terurut di mana penambahan dan penghapusan elemen selalu dilakukan di ujung yang sama, yang disebut top. Stack mengikuti prinsip LIFO (Last-In-First-Out), yang berarti elemen terakhir yang ditambahkan adalah elemen pertama yang dihapus.

Karakteristik Utama Stack:

Struktur LIFO: Elemen yang paling akhir ditambahkan akan dikeluarkan pertama kali.
Dua Operasi Utama:Push: Menambahkan elemen ke atas stack.Pop: Menghapus elemen dari puncak stack.
Push: Menambahkan elemen ke atas stack.
Pop: Menghapus elemen dari puncak stack. Stack banyak digunakan dalam berbagai algoritma, seperti manajemen memori dalam pemanggilan fungsi, penelusuran pohon, dan banyak lagi.

Operasi pada Stack

Berikut ini adalah cara mengimplementasikan struktur data stack di Python menggunakan pendekatan berbasis kelas yang mencakup operasi dasar stack.

Implementasi Kelas Stack

class StackFullError(Exception):
    """Exception yang dilemparkan ketika menambah elemen ke stack yang penuh."""
    pass

class StackEmptyError(Exception):
    """Exception yang dilemparkan ketika menghapus elemen dari stack yang kosong."""
    pass

class Stack:
    def __init__(self, kapasitas):
        self.items = []
        self.kapasitas = kapasitas

    def is_empty(self):
        return len(self.items) == 0

    def is_full(self):
        return len(self.items) >= self.kapasitas

    def push(self, item):
        if self.is_full():
            raise StackFullError("Stack penuh, tidak dapat menambahkan elemen lagi.")
        self.items.append(item)

    def pop(self):
        if self.is_empty():
            raise StackEmptyError("Stack kosong, tidak dapat menghapus elemen.")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise StackEmptyError("Stack kosong, tidak ada elemen untuk dilihat.")
        return self.items[-1]

    def size(self):
        return len(self.items)

Dalam kelas ini:

Kami menggunakan dua exception khusus, yaitu StackFullError dan StackEmptyError, untuk menangani operasi yang tidak valid, seperti menambah elemen ke stack penuh atau menghapus elemen dari stack yang kosong.
Stack memiliki kapasitas tetap untuk memastikan stack tidak terus bertambah tanpa batas.
Operasi seperti push(), pop(), peek(), is_empty(), dan is_full() mencakup semua operasi dasar stack. Contoh Penggunaan:

stack = Stack(4)
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)

print("Stack setelah push: ", stack.items)

print("Item yang dihapus: ", stack.pop())
print("Stack setelah pop: ", stack.items)

print("Item teratas: ", stack.peek())
print("Ukuran stack: ", stack.size())

Contoh ini menunjukkan cara:

Membuat stack dengan kapasitas 4.
Menambahkan (push) dan menghapus (pop) elemen dari stack.
Melihat elemen teratas (peek) dan memeriksa ukuran stack.

Penanganan Stack Overflow dan Stack Underflow

Ketika bekerja dengan struktur data seperti stack, penting untuk menangani kesalahan seperti overflow (menambah elemen ke stack yang penuh) dan underflow (menghapus elemen dari stack yang kosong) dengan benar.

StackFullError

Exception ini dilemparkan ketika kita mencoba menambah elemen ke stack yang sudah penuh. Hal ini mencegah stack menerima elemen tambahan yang melampaui kapasitasnya.

StackEmptyError

Exception ini dilemparkan ketika kita mencoba menghapus atau melihat elemen dari stack yang kosong. Hal ini mencegah operasi yang tidak valid yang dapat mengganggu alur program.

try:
    stack.push(5)  # Ini akan menimbulkan StackFullError
except StackFullError as e:
    print(e)

try:
    empty_stack = Stack(3)
    empty_stack.pop()  # Ini akan menimbulkan StackEmptyError
except StackEmptyError as e:
    print(e)

Membalikkan Array Menggunakan Stack

Salah satu aplikasi praktis stack adalah untuk membalikkan data. Karena stack mengikuti prinsip LIFO, jika kita memasukkan semua elemen array ke dalam stack, dan kemudian mengeluarkannya kembali, urutannya akan dibalik.

Fungsi untuk Membalikkan Array

def reverse_array(arr):
    stack = Stack(len(arr))  # Inisialisasi stack dengan ukuran array
    
    # Masukkan semua elemen ke dalam stack
    for item in arr:
        stack.push(item)

    # Keluarkan semua elemen dari stack untuk mendapatkan urutan terbalik
    reversed_arr = []
    while not stack.is_empty():
        reversed_arr.append(stack.pop())

    return reversed_arr

Contoh Penggunaan

input_arr = [1, 2, 3, 4]
print(f"Array asli: {input_arr}")
print(f"Array yang dibalik: {reverse_array(input_arr)}")

Contoh ini mengambil array [1, 2, 3, 4], memasukkan semua elemennya ke dalam stack, lalu mengeluarkannya untuk membentuk array terbalik [4, 3, 2, 1].

Penjelasan

Fase Push: Semua elemen array dimasukkan ke dalam stack sesuai urutan awal.
Fase Pop: Karena sifat LIFO stack, elemen pertama yang dikeluarkan adalah elemen terakhir yang dimasukkan, sehingga menghasilkan array yang dibalik

Kesimpulan

Pada artikel ini, kita telah membahas implementasi struktur data stack di Python dengan menerapkan praktik terbaik, seperti manajemen kapasitas dan penanganan error. Kita juga telah melihat bagaimana stack dapat digunakan untuk membalikkan array, salah satu aplikasi praktis dari stack.

Pemahaman tentang stack penting dalam banyak algoritma dan dapat menjadi alat yang berguna dalam menyelesaikan berbagai masalah. Baik itu untuk mengelola pemanggilan fungsi, operasi undo, atau membalikkan data, stack menawarkan solusi yang efisien. Dengan menerapkan teknik-teknik ini di Python, Anda dapat memperdalam pemahaman tentang struktur data dan penerapannya di dunia nyata.

SALAM DATA SALAM ADYTAMA