Apa itu Stack? *Stack* adalah struktur data dasar dalam pemrograman yang bekerja seperti tumpukan barang: elemen terakhir masuk akan keluar lebih dulu. Konsep [*LIFO (Last In, First Out)*](https://www.spiceworks.com/tech/devops/articles/fifo-vs-lifo/) ini sangat krusial karena mempengaruhi cara data diakses dan diolah. Banyak tugas pemrograman melibatkan penggunaan stack – misalnya manajemen memori atau proses fungsi rekursif – sehingga memahami *apa itu stack* mempermudah pengorganisasian data dalam kode.

Banyak tugas pemrograman melibatkan struktur data **stack**. Contohnya, ketika seorang programmer menulis kode seperti di atas, ia sering menggunakan stack untuk mengelola data yang bersifat LIFO. Struktur data stack mempermudah pengorganisasian data dalam berbagai situasi. Oleh karena itulah, memahami *apa itu stack* dan cara kerjanya sangat penting bagi pemula maupun mahir untuk menyelesaikan masalah algoritmik dengan efisien.

## Definisi Stack

![](https://apps.codepolitan.com/sites/learn/uploads/original/202308/stack_adalah.png)

Secara sederhana, stack adalah **struktur data linier** yang digunakan untuk menyimpan sekumpulan objek atau variabel. Setiap penambahan data (push) dan penghapusan data (pop) terjadi di *ujung atas* tumpukan. Sifat khas stack adalah **LIFO (Last In, First Out)**: data terakhir yang masuk akan menjadi data pertama yang keluar.

Dalam dunia nyata, analogi stack sering dijumpai pada tumpukan buku atau piring. Misalnya, jika kamu menumpuk buku A, B, C, buku C (yang terakhir diletakkan) harus dikeluarkan dulu untuk mengambil buku yang lebih bawah. Begitu pula dalam pemrograman, elemen yang paling baru ditambahkan harus dikeluarkan terlebih dahulu.

> **Contoh Analogi:** Bayangkan sebuah tumpukan piring bersih. Piring terakhir yang dicuci diletakkan paling atas, sehingga saat kamu butuh piring, kamu akan mengambil piring yang paling atas terlebih dahulu. Inilah cara kerja stack di pemrograman.

Stack sering digunakan dalam berbagai konteks pemrograman. Misalnya pada saat **panggilan fungsi** (call stack) dan **rekursi**, setiap pemanggilan fungsi disimpan dalam stack hingga fungsi tersebut selesai dieksekusi. Contoh lain adalah **undo/redo** di aplikasi, evaluasi ekspresi matematika, serta pengecekan kesetaraan tanda kurung. Semua kasus ini memanfaatkan sifat LIFO stack agar data terkelola dengan teratur.

**Baca Juga:** [Mengenal Apa Itu Looping: Konsep Dasar dan Contohnya dalam Pemrograman](https://www.codepolitan.com/blog/mengenal-apa-itu-looping-konsep-dasar-dan-contohnya-dalam-pemrograman/)

## Karakteristik dan Operasi Stack

Karakteristik utama stack adalah aturan LIFO. Berikut operasi dasar yang biasa diterapkan pada stack:

* **Push:** Menambahkan elemen baru ke *bagian atas* stack. Misalnya, menumpuk buku baru di atas tumpukan.
* **Pop:** Menghapus elemen di *puncak* stack dan mengembalikan nilainya. Artinya, buku yang paling atas diambil keluar.
* **Peek/Top:** Melihat (mengintip) elemen teratas tanpa menghapusnya. Seperti mengintip buku paling atas tanpa mengambilnya.
* **IsEmpty:** Memeriksa apakah stack kosong atau tidak. Cocok seperti mengecek apakah masih ada piring di tumpukan.
* **Size:** Mengembalikan jumlah elemen dalam stack. Berguna untuk mengetahui seberapa tinggi tumpukan saat ini.

Operasi-operasi di atas dijalankan dari satu sisi stack (ujung atas). Contohnya, operasi **push** tidak boleh menambah data di bagian bawah tumpukan, dan **pop** hanya bisa menghapus dari atas. Hal ini membuat stack berbeda dengan struktur lain (misalnya queue) yang dapat menghapus dari ujung depan. Misalnya pada *stack*, hanya elemen terakhir yang dapat diakses atau dikeluarkan tanpa membongkar seluruh data di bawahnya.

Karakteristik LIFO juga berarti stack tidak mendukung *akses acak*. Untuk mengambil elemen tertentu, kita harus mengeluarkan semua elemen di atasnya terlebih dahulu. Kekurangan ini merupakan batasan yang wajar karena desain stack memang fokus pada penyimpanan sementara untuk urutan tugas tertentu (misalnya dalam pemanggilan fungsi).

## Implementasi Stack

Dalam pemrograman, stack bisa diimplementasikan menggunakan berbagai cara. Dua cara umum adalah menggunakan [***array***](https://www.codepolitan.com/blog/apa-itu-array-dalam-pemrograman-pengertian-dan-contoh-coding/) atau menggunakan **linked list**. Pilihan implementasi tergantung pada kebutuhan memori, fleksibilitas, dan kemudahan penggunaan.

### Implementasi Stack dengan Array

Implementasi stack dengan array adalah salah satu yang paling sederhana. Kita menggunakan array dengan ukuran tetap untuk menampung elemen stack, serta variabel `top` untuk menunjuk indeks elemen teratas.

**Contoh (Python dengan list):**

```python
class StackArray:
    def __init__(self, capacity):
        self.array = [None] * capacity
        self.top = -1  # Stack kosong
    def push(self, x):
        if self.top < len(self.array) - 1:
            self.top += 1
            self.array[self.top] = x
        else:
            print("Stack overflow!")
    def pop(self):
        if self.top >= 0:
            val = self.array[self.top]
            self.top -= 1
            return val
        else:
            print("Stack kosong!")
            return None
    def peek(self):
        return self.array[self.top] if self.top >= 0 else None
    def isEmpty(self):
        return self.top == -1
    def size(self):
        return self.top + 1
```

Pada contoh di atas, `push` menambah elemen ke posisi `top + 1`, dan `pop` mengurangi `top`. Implementasi berbasis array ini **cepat** dan sederhana karena akses berdasarkan indeks langsung. Namun kekurangannya, ukuran stack harus ditentukan di awal dan **tidak fleksibel** setelah itu. Jika kapasitas terlampaui, terjadi *stack overflow*, karena array tidak bisa otomatis membesar.

### Implementasi Stack dengan Linked List

Sebaliknya, stack dapat juga diimplementasikan menggunakan **linked list**. Setiap elemen stack menjadi *node* pada linked list, dan **puncak** stack disimpan di `head` (simpul pertama) linked list.

**Contoh (Python):**

```python
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class StackLinkedList:
    def __init__(self):
        self.head = None  # Menyimpan elemen teratas

    def push(self, x):
        new_node = Node(x)
        new_node.next = self.head
        self.head = new_node

    def pop(self):
        if not self.head:
            print("Stack kosong!")
            return None
        value = self.head.data
        self.head = self.head.next
        return value

    def peek(self):
        return self.head.data if self.head else None

    def isEmpty(self):
        return self.head is None

    def size(self):
        count = 0
        current = self.head
        while current:
            count += 1
            current = current.next
        return count
```

Pada implementasi linked list, operasi **push** menyisipkan node di awal list, dan **pop** menghapus node awal. Kelebihan utama metode ini adalah **fleksibilitas ukuran**; stack dapat bertambah atau berkurang sesuai kebutuhan saat runtime. Tidak perlu tentukan kapasitas maksimum di awal. Kekurangannya, setiap elemen memerlukan memori tambahan untuk pointer ke simpul berikutnya, dan akses ke elemen membutuhkan manipulasi pointer.

**Baca Juga:** [Apa Itu Array dalam Pemrograman? Pengertian dan Contoh Coding](https://www.codepolitan.com/blog/apa-itu-array-dalam-pemrograman-pengertian-dan-contoh-coding/)

## Penerapan Stack dalam Dunia Pemrograman

Stack banyak diaplikasikan dalam pemrograman untuk menyelesaikan masalah yang membutuhkan pengurutan LIFO. Berikut beberapa penerapannya:

* **Rekursi dan Call Stack:** Saat fungsi memanggil dirinya sendiri, setiap panggilan fungsi baru disimpan dalam *call stack*. Parameter dan variabel lokal ditumpuk di stack, kemudian diambil kembali saat fungsi selesai. Stack memastikan fungsi kembali ke keadaan semula dengan benar setelah rekursi berakhir.
* **Undo-Redo pada Aplikasi:** Fitur *undo* dalam editor teks biasanya menggunakan dua stack (satu untuk *undo* dan satu untuk *redo*). Setiap aksi disimpan di undo-stack. Saat undo dilakukan, operasi terakhir di-pop dan dimasukkan ke redo-stack. Begitu juga sebaliknya saat redo. Penggunaan dua stack ini membuat navigasi aksi sebelumnya menjadi efisien tanpa kehilangan sejarah.
* **Evaluasi Ekspresi Matematika:** Untuk menghitung ekspresi infix (misalnya `"3 + 4 * 2"`), sering dilakukan konversi ke notasi postfix (misal `"3 4 2 * +"`) menggunakan stack. Algoritma konversi memasukkan operator ke stack berdasarkan prioritas, kemudian mengeluarkannya dalam urutan postfix. Hasil postfix selanjutnya dapat dieksekusi dengan cara menumpuk operand dan menerapkan operator, di mana operasi dilakukan dengan pop operand dari stack.
* **Parsing Ekspresi dan Backtracking:** Stack juga berguna untuk memeriksa kesetaraan tanda kurung atau struktur ter-parse. Misalnya, dalam *parsing*, setiap tanda kurung buka dipush, lalu tanda kurung tutup di-pop untuk dicocokkan. Jika kesalahan ditemukan, stack memudahkan [*backtracking*](https://www.geeksforgeeks.org/backtracking-algorithms/). Begitu pula dalam algoritma DFS atau teknik backtracking (misalnya pencarian jalur atau teka-teki N-Queens), stack menyimpan status sementara. Setiap kali dibuat percobaan baru, state disimpan di stack, dan jika percobaan gagal, stack di-pop kembali ke keadaan sebelumnya. Dengan demikian, stack mempermudah eksplorasi semua kemungkinan secara teratur.

## Kelebihan dan Kekurangan Stack

**Kelebihan Stack:** Struktur data stack sangat sederhana dan efisien untuk skenario LIFO. Akses dan manipulasi elemen di puncak stack berlangsung cepat karena langsung ke ujungnya. Memory digunakan dengan efisien, karena elemen yang tidak lagi dibutuhkan akan *otomatis* dilepas setelah di-pop. Implementasi stack juga cenderung mudah dan cepat, membuat kode lebih ringkas dan mudah dibaca. Stack ideal digunakan ketika kita hanya perlu mengelola data sesuai urutan masuk terakhir keluar pertama, seperti memproses riwayat (undo), rekursi, dan pengolahan ekspresi.

**Kekurangan Stack:** Namun, stack memiliki keterbatasan. Karena ukuran biasanya tetap (pada implementasi array), dapat terjadi *stack overflow* jika terlalu banyak elemen dimasukkan. Selain itu, stack tidak mendukung *akses acak*; untuk mencapai elemen paling bawah, harus mengeluarkan elemen-elemen di atasnya terlebih dahulu. Hal ini membuat stack kurang cocok jika dibutuhkan penelusuran atau pengambilan data secara acak. Intinya, stack sebaiknya digunakan saat benar-benar diperlukan urutan LIFO, dan bukan untuk skenario yang memerlukan operasi acak atau kapasitas yang sangat dinamis.

Sebagai perbandingan, struktur data lain seperti **queue** menerapkan FIFO (First-In, First-Out) dan cocok untuk antrian reguler. Struktur seperti **array/list** memberikan akses elemen langsung dengan indeks, namun tidak otomatis mengelola urutan akses. Pilihlah stack ketika logika aplikasi Anda memang membutuhkan pemrosesan data terurut berdasarkan LIFO.

## Studi Kasus dan Contoh Kode Nyata

Berikut beberapa contoh implementasi stack dalam proyek kecil dan masalah dunia nyata:

* **Cek Keseimbangan Tanda Kurung:** Misalkan kita ingin memeriksa apakah tanda kurung pada sebuah string seimbang. Berikut contoh kode sederhana di Python:

  ```python
  def cek_tanda_kurung(s):
      stack = []
      for char in s:
          if char in '([{':
              stack.append(char)  # push
          elif char in ')]}':
              if not stack:
                  return False
              top = stack.pop()  # pop
              if (top, char) not in [('(',')'), ('[',']'), ('{','}')]:
                  return False
      return not stack

  print(cek_tanda_kurung('({[]})'))  # Output: True
  ```

  Kode di atas menggunakan stack untuk menampung tanda kurung pembuka. Setiap kali muncul tanda kurung tutup, kita pop dari stack dan cek kecocokannya. Jika akhirnya stack kosong, tanda kurung adalah seimbang.

* **Konversi Desimal ke Biner:** Contoh lain adalah konversi bilangan desimal menjadi biner. Kita bisa memanfaatkan stack untuk menyimpan sisa pembagian hingga akhirnya membentuk urutan biner:

  ```python
  def desimal_ke_biner(n):
      stack = []
      while n > 0:
          stack.append(str(n % 2))
          n //= 2
      return ''.join(reversed(stack))  # ambil digit dari stack teratas

  print(desimal_ke_biner(13))  # Output: '1101'
  ```

  Di sini, setiap langkah kita *push* sisa pembagian (0 atau 1) ke stack. Setelah selesai, kita *pop* kembali urutan digit dari akhir ke awal untuk membentuk hasil biner.

* **Undo-Redo Sederhana:** Misalnya dalam teks editor, dua stack bisa digunakan: satu menyimpan riwayat untuk undo, dan satunya lagi untuk redo. Contoh pseudocode:

  ```python
  undo_stack = []
  redo_stack = []
  def tulis(teks):
      undo_stack.append(teks)
  def undo():
      if undo_stack:
          tindakan = undo_stack.pop()
          redo_stack.append(tindakan)
  def redo():
      if redo_stack:
          tindakan = redo_stack.pop()
          undo_stack.append(tindakan)
  ```

  Setiap aksi *push* ke `undo_stack`. Saat `undo()` dipanggil, elemen terakhir dipindahkan ke `redo_stack`. Fitur `redo()` mengambil kembali elemen terakhir dari `redo_stack` ke `undo_stack`. Dengan stack ini, kita dapat menelusuri aksi mundur-maju dengan mudah.

Contoh-contoh di atas menunjukkan bagaimana stack membantu menyelesaikan tugas tertentu dalam kode nyata. Walaupun sederhana, struktur data stack merupakan blok bangunan penting dalam banyak algoritma dan aplikasi.

## FAQ

1. **Apa itu stack?**
   Stack adalah struktur data linier yang beroperasi menurut prinsip LIFO (Last In, First Out). Artinya, elemen terakhir yang dimasukkan akan menjadi yang pertama kali dikeluarkan. Misalnya, jika kita memasukkan data dalam urutan A, B, C, maka melakukan *pop* akan mengeluarkan C terlebih dahulu.

2. **Apa perbedaan stack dengan queue?**
   Stack menggunakan metode LIFO, sementara queue menggunakan FIFO (First In, First Out). Dalam queue, elemen pertama yang masuk akan keluar pertama (seperti antrian orang), berbeda dengan stack yang mengeluarkan data terakhir masuk terlebih dahulu. Jadi, jika antrean data diutamakan, pakai queue; jika tumpukan data dengan urutan mundur yang diperlukan, gunakan stack.

3. **Kapan sebaiknya menggunakan stack?**
   Stack ideal digunakan saat algoritma atau aplikasi membutuhkan urutan LIFO. Contoh: pemrosesan rekursi, navigasi mundur (*backtracking*), undo/redo di aplikasi, atau parsing ekspresi matematika (seperti konversi infix ke postfix). Jika logika membutuhkan kemudahan akses ke elemen terbaru, stack adalah pilihan tepat.

4. **Apa risiko *stack overflow*?**
   Stack overflow terjadi saat ukuran stack melebihi kapasitas yang ditentukan (khususnya implementasi array). Ini bisa terjadi, misalnya, saat rekursi berjalan terlalu dalam tanpa berhenti. Untuk mencegahnya, kita perlu memeriksa batas stack dan menulis kode rekursif dengan kondisi berhenti yang jelas. Implementasi linked list bisa mengurangi risiko ini karena ukuran bisa bertambah sesuai kebutuhan memori.

5. **Bagaimana cara mengimplementasikan stack dalam pemrograman?**
   Ada beberapa cara. Dua yang umum adalah menggunakan array atau linked list. Dengan array, kita menggunakan indeks sebagai `top` untuk penambahan dan penghapusan. Dengan linked list, kita menambah/menghapus node di awal list. Banyak bahasa pemrograman menyediakan struktur stack bawaan (misal `Stack` di Java), atau kita bisa menggunakan array/list standar (misal `append/pop` di Python) untuk melakukan operasi stack.

## Kesimpulan

Secara keseluruhan, stack adalah struktur data fundamental yang **sangat berguna** dalam pemrograman. Dengan mekanisme LIFO-nya, stack memudahkan penanganan tugas-tugas seperti pemanggilan fungsi rekursif, fitur undo/redo, dan evaluasi ekspresi. Kita telah membahas definisi, operasi dasar (push, pop, dll), serta contoh implementasi stack menggunakan array dan linked list. Masing-masing implementasi memiliki kelebihan dan kekurangan; misalnya array cepat dan sederhana, namun ukuran tetap, sedangkan linked list lebih fleksibel dengan beban memori ekstra.

Pentingnya menguasai stack tak hanya teori saja. Dengan pemahaman yang baik, seorang programmer bisa menulis algoritma lebih efisien dan memahami proses internal aplikasi (seperti call stack pada fungsi). Jadi, mengerti **apa itu stack** dan cara kerjanya adalah bekal penting dalam pengembangan perangkat lunak modern.

[![](https://image.web.id/images/belajar-coding-gratis.png)](https://www.kelasfullstack.id/)

Tertarik belajar lebih banyak tentang pengembangan web dan struktur data seperti stack? Yuk ikuti *KelasFullstack* di CodePolitan! [KelasFullstack](https://www.kelasfullstack.id/) adalah kelas online lengkap untuk menjadi web developer dari A hingga Z. Materinya selalu diperbarui dan cocok bagi kamu yang ingin berkarier di bidang teknologi, mendapatkan gaji tinggi, dan bahkan membangun bisnis online sendiri. Segera daftarkan diri dan wujudkan karier impianmu di dunia pemrograman!

Apa Itu Stack dalam Ilmu Pemrograman

GenAI Video Fest adalah ajang kompetisi video kreatif yang diselenggarakan oleh CODEPOLITAN bekerjasama dengan Alibaba Cloud.

Kami menantang kreator, tech-enthusiast, dan siapa saja untuk mendobrak batas imajinasi menggunakan teknologi Generative AI terbaru. Di sini, kamu wajib menggunakan WAN Model Studio dari Alibaba Cloud sebagai tools utama untuk menghasilkan karya videomu (bisa dikombinasikan dengan tools editing lainnya).

Tunjukkan pada dunia bagaimana teknologi dan kreativitas bisa bersatu menciptakan karya visual yang berdampak!

Kategori Kompetisi
Pilih satu dari empat tema besar ini untuk karyamu:
* Humanity (Kemanusiaan): Cerita yang menyentuh hati, sosial, dan kepedulian antar sesama.
* Sports (Olahraga): Energi, semangat juang, dan dinamika dunia olahraga.
* Entertainment (Hiburan): Komedi, musik, video klip, atau parodi yang menghibur.
* Science (Sains): Visualisasi masa depan, teknologi, alam semesta, atau penemuan ilmiah.

Total Prize Pool senilai Rp 250.000.000 menunggu para pemenang!
* Top Winners Rewards: Uang Tunai, Alibaba Cloud Credits (hingga $500), Merchandise Eksklusif, dan SWAG CODEPOLITAN.
* Lucky Draw Event: Kesempatan menang hadiah tambahan bagi peserta yang beruntung.
* Massive Exposure: Karya terbaik akan di-highlight di media sosial CODEPOLITAN, Alibaba Cloud, dan channel industri kreatif lainnya.
* Special Access (Khusus Alumni RuangAI): Dapatkan 2 Token untuk klaim Kelas Spesialisasi di RuangAI secara gratis.

Jangan sampai ketinggalan tanggal penting ini:
* Pendaftaran & Submission: 23 Desember 2024 - 23 Januari 2025
* Penjurian (Judging Phase): 24 - 26 Januari 2025
* Pengumuman Pemenang: 27 Januari 2025

Cara Ikutan:
1. Daftar: Klik tombol "Daftar Sekarang" dan pastikan kamu punya akun RuangAI.
2. Join Discord: Masuk ke server Discord komunitas untuk info teknis dan diskusi.
3. Create: Buat video kreatifmu menggunakan WAN Model Studio (Alibaba Cloud) sesuai kategori pilihan.
4. Upload & Submit: Unggah videomu ke media sosial (IG/TikTok/YouTube) dan submit link karyamu di halaman submission RuangAI.

Ikuti kompetisi video Generative AI terbesar dari CODEPOLITAN dan Alibaba Cloud! Gunakan teknologi WAN Model Studio untuk menyulap ide liarmu menjadi visual memukau. Rebut total hadiah senilai Rp 250.000.000!

GenAI Video Fest

Beasiswa Basic Cybersecurity adalah program inisiatif dari JagoanSiber yang dirancang untuk membuka wawasan masyarakat luas tentang dunia keamanan digital. Program ini hadir untuk menjawab kebutuhan talenta keamanan siber yang tinggi, dimulai dengan membangun pemahaman fundamental yang kokoh.

Program ini berbentuk Kelas Online Belajar Mandiri (Self-Paced Learning) berbasis video. Peserta diberikan keleluasaan penuh untuk mengakses materi kapan saja dan di mana saja tanpa terikat jadwal, sehingga sangat fleksibel bagi pelajar, mahasiswa, maupun pekerja profesional.

Kelebihan utama program ini adalah aksesnya yang 100% GRATIS dan terbuka untuk siapa saja tanpa syarat latar belakang IT. Peserta akan dibimbing langsung oleh Mahrus Qusaery, seorang praktisi keamanan siber berpengalaman, yang akan mengupas tuntas materi dasar yang krusial.

Program beasiswa kelas online gratis untuk mempelajari dasar keamanan siber dari nol. Belajar mandiri berbasis video langsung dari praktisi ahli, Mahrus Qusaery.

Apa Itu Stack dalam Ilmu Pemrograman

Learning

KelasFullstack

RuangAI

JagoanSiber

Baca Artikel Lainnya

ChatGPT adalah Kawan atau Lawan Bagi Programmer?

Belajar Membangun Proyek Open Source, Emang bisa?

13+ Rahasia Dibalik Skills Frontend Developer di Buru Perusahaan

10 Tips & Trik Penggunaan Shortcut Vscode, Pelajari Yuk!

Cara Menghapus Commit Git: Panduan Praktis dan Terbaik!

Tingkatkan Teknologi AI, Indonesia Jalin Kerjasama dengan AS