Struktur data Stack menggunakan prinsip LIFO (Last-In, First-Out).
Struktur data Stack adalah salah satu konsep fundamental dalam ilmu komputer. Sesuai dengan namanya, Stack bekerja berdasarkan prinsip LIFO (Last-In, First-Out), yang berarti elemen terakhir yang dimasukkan ke dalam tumpukan adalah elemen pertama yang akan dikeluarkan. Dalam Python, kita dapat mengimplementasikan struktur Stack dengan mudah menggunakan tipe data bawaan seperti List, atau dengan menggunakan modul `collections.deque` untuk performa yang lebih optimal pada operasi penambahan dan penghapusan di kedua ujung.
Menggunakan List bawaan Python adalah cara paling cepat untuk mendemonstrasikan fungsionalitas Stack. Operasi dasar Stack adalah push (menambahkan elemen) dan pop (menghapus elemen teratas). Dalam konteks List Python, append() bertindak sebagai push, dan pop() (tanpa indeks) bertindak sebagai pop.
# Inisialisasi Stack
my_stack = []
# 1. Operasi PUSH (Menambahkan elemen)
print("Melakukan PUSH:")
my_stack.append(10)
my_stack.append(20)
my_stack.append(30) # 30 adalah elemen teratas (TOP)
print(f"Stack setelah PUSH: {my_stack}")
# 2. Operasi POP (Mengeluarkan elemen teratas)
element_popped = my_stack.pop()
print(f"Elemen yang di-POP: {element_popped}") # Output: 30
print(f"Stack setelah POP: {my_stack}") # Output: [10, 20]
# 3. Melihat elemen teratas tanpa menghapus (Peek)
if my_stack:
peek_element = my_stack[-1]
print(f"Elemen teratas (Peek): {peek_element}") # Output: 20
Meskipun List sangat fleksibel, dalam konteks pemrograman yang lebih besar, disarankan untuk membuat kelas Stack sendiri. Ini memungkinkan kita untuk mendefinisikan batasan (misalnya, kapasitas maksimum) dan memastikan bahwa hanya operasi Stack yang valid (push, pop, peek, is_empty) yang dapat dilakukan, bukan operasi List umum seperti penyisipan di tengah.
class StackKustom:
def __init__(self):
# List digunakan sebagai wadah internal
self.items = []
def is_empty(self):
# Mengecek apakah stack kosong
return not self.items
def push(self, item):
# Menambahkan item ke atas stack
self.items.append(item)
print(f"PUSH: {item} berhasil ditambahkan.")
def pop(self):
# Menghapus dan mengembalikan item teratas
if not self.is_empty():
return self.items.pop()
else:
return "Stack kosong, tidak bisa POP."
def peek(self):
# Melihat item teratas tanpa menghapusnya
if not self.is_empty():
return self.items[-1]
else:
return "Stack kosong."
def size(self):
# Mengembalikan jumlah elemen
return len(self.items)
# Penggunaan Kelas Kustom
print("\n--- Menggunakan Kelas Stack Kustom ---")
s = StackKustom()
s.push("A")
s.push("B")
print(f"Ukuran Stack: {s.size()}")
print(f"Elemen teratas: {s.peek()}")
print(f"POP: {s.pop()}")
print(f"POP lagi: {s.pop()}")
print(f"Apakah kosong? {s.is_empty()}")
print(f"POP terakhir: {s.pop()}")
Untuk aplikasi performa tinggi, List Python memiliki kelemahan inheren saat digunakan sebagai Stack. Ketika List digunakan untuk pop dari awal (yang mana bukan perilaku Stack), operasi tersebut memakan waktu O(n) karena semua elemen perlu digeser. Namun, bahkan untuk operasi Stack standar (append dan pop di akhir), collections.deque (double-ended queue) sering kali lebih disukai. `deque` dirancang untuk penambahan dan penghapusan yang efisien (O(1)) di kedua ujungnya, menjadikannya implementasi Stack yang lebih kuat dan cepat di Python dibandingkan List standar, meskipun untuk kasus penggunaan sederhana, List sudah memadai.
Memahami struktur Stack sangat penting karena ia mendasari banyak algoritma pemrograman, termasuk evaluasi ekspresi matematika, manajemen riwayat navigasi (tombol "back" pada browser), dan yang paling terkenal, implementasi pemanggilan fungsi dalam runtime program (Call Stack).