Cara Implementasi Stack Tanpa Menggunakan Library: Pengalaman Belajar C++ dari Nol

Kalau kamu seorang programmer pemula yang sedang belajar struktur data, pasti cepat atau lambat akan ketemu dengan yang namanya stack. Waktu pertama kali saya belajar stack, jujur saya agak bingung. Di buku teori dijelaskan kalau stack itu seperti tumpukan piring—yang terakhir ditaruh di atas adalah yang pertama diambil (Last In, First Out / LIFO). Konsepnya sih gampang, tapi waktu disuruh implementasi stack tanpa library di C++, saya lumayan pusing.

Dalam artikel ini saya ingin berbagi pengalaman pribadi ketika mencoba mengimplementasikan stack dari nol, tanpa bantuan library bawaan seperti std::stack. Buat kamu yang masih belajar, semoga bisa jadi panduan santai, dan buat yang sudah lebih advance, mungkin bisa jadi bahan nostalgia atau inspirasi.

Pertemuan Pertama dengan Stack

Jadi ceritanya begini. Waktu kuliah, ada tugas di mata kuliah Struktur Data:

"Implementasikan stack menggunakan array, tanpa menggunakan library bawaan C++."

Saya pikir, “Ah, gampang! Tinggal bikin array, masukin data, selesai.” Tapi ternyata tidak sesederhana itu. Kita harus benar-benar paham konsep stack:

• Ada operasi push (menambahkan elemen ke atas stack).

• Ada operasi pop (mengambil elemen dari atas stack).

• Ada juga peek (melihat elemen teratas tanpa menghapusnya).

Selain itu, kita juga harus mempertimbangkan kasus error, misalnya stack penuh (overflow) atau stack kosong (underflow). Dari sini saya belajar, implementasi stack itu bukan cuma soal coding, tapi juga memahami cara berpikir data disusun dan dikelola.

Implementasi Pertama: Stack Menggunakan Array

Saya mulai dengan pendekatan paling sederhana: pakai array statis.

Kodenya waktu itu kira-kira seperti ini (versi yang sudah saya rapikan):

#include <iostream>
using namespace std;

#define MAX 5 // kapasitas stack

class Stack {
private:
    int arr[MAX];
    int top;

public:
    Stack() {
        top = -1; // menandakan stack kosong
    }

    bool isEmpty() {
        return top == -1;
    }

    bool isFull() {
        return top == MAX - 1;
    }

    void push(int value) {
        if (isFull()) {
            cout << "Stack Overflow! Tidak bisa menambahkan " << value << endl;
            return;
        }
        arr[++top] = value;
        cout << value << " berhasil ditambahkan ke stack." << endl;
    }

    void pop() {
        if (isEmpty()) {
            cout << "Stack Underflow! Tidak ada elemen untuk dihapus." << endl;
            return;
        }
        cout << arr[top--] << " berhasil dihapus dari stack." << endl;
    }

    void peek() {
        if (isEmpty()) {
            cout << "Stack kosong." << endl;
            return;
        }
        cout << "Elemen teratas: " << arr[top] << endl;
    }
};

int main() {
    Stack s;

    s.push(10);
    s.push(20);
    s.push(30);
    s.peek();

    s.pop();
    s.peek();

    s.pop();
    s.pop();
    s.pop(); // mencoba pop saat stack kosong

    return 0;
}

Ketika saya jalankan, hasilnya cukup memuaskan. Ada pesan kalau stack penuh, pesan kalau stack kosong, dan elemen-elemen masuk serta keluar sesuai aturan LIFO.

Tantangan yang Saya Hadapi

Waktu pertama kali mengerjakan ini, saya sempat ketemu beberapa masalah:

1. Indexing Array
   Saya sempat lupa increment top sebelum menyimpan data, akibatnya data selalu menimpa index 0. Belajar dari kesalahan ini, saya jadi paham pentingnya urutan operasi.

2. Overflow & Underflow
   Awalnya saya nggak masukkan pengecekan. Jadi pas stack penuh dan saya push, program malah error. Setelah ditambah pengecekan, jadi lebih aman.

3. Keterbatasan Array
   Karena saya pakai array statis, kapasitas stack terbatas (misalnya MAX = 5). Kalau mau stack yang lebih fleksibel, harus pakai linked list atau dynamic array dengan new.

Implementasi Kedua: Stack dengan Linked List

Karena penasaran, saya coba implementasi stack pakai linked list. Bedanya dengan array, stack berbasis linked list tidak punya batasan ukuran (selama memori masih ada).

Contoh implementasi sederhana:

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
};

class Stack {
private:
    Node* top;

public:
    Stack() {
        top = nullptr;
    }

    void push(int value) {
        Node* newNode = new Node();
        newNode->data = value;
        newNode->next = top;
        top = newNode;
        cout << value << " berhasil ditambahkan ke stack." << endl;
    }

    void pop() {
        if (top == nullptr) {
            cout << "Stack Underflow! Tidak ada elemen untuk dihapus." << endl;
            return;
        }
        cout << top->data << " berhasil dihapus dari stack." << endl;
        Node* temp = top;
        top = top->next;
        delete temp;
    }

    void peek() {
        if (top == nullptr) {
            cout << "Stack kosong." << endl;
            return;
        }
        cout << "Elemen teratas: " << top->data << endl;
    }

    bool isEmpty() {
        return top == nullptr;
    }
};

int main() {
    Stack s;

    s.push(100);
    s.push(200);
    s.push(300);
    s.peek();

    s.pop();
    s.peek();

    return 0;
}

Dengan cara ini, saya bisa push elemen sebanyak-banyaknya tanpa perlu khawatir stack penuh, karena elemen baru akan selalu dialokasikan di heap.

Pelajaran Berharga dari Pengalaman Ini

Dari pengalaman mencoba implementasi stack tanpa library, saya mendapatkan beberapa pelajaran penting:

1. Jangan terlalu bergantung pada library
   Library memang memudahkan, tapi dengan bikin dari nol, saya jadi lebih paham cara kerja stack sebenarnya.

2. Kesalahan adalah bagian dari proses
   Error seperti overflow dan underflow awalnya bikin frustasi, tapi justru itu yang bikin saya mengerti logika stack lebih dalam.

3. Fleksibilitas struktur data
   Ternyata tidak ada satu cara yang mutlak. Mau pakai array atau linked list, semuanya punya kelebihan dan kekurangan.

4. Struktur data adalah fondasi penting
   Banyak algoritma canggih yang dibangun di atas stack. Misalnya parsing ekspresi matematika, evaluasi postfix, DFS pada graph, bahkan implementasi fungsi rekursif di level mesin. Jadi, paham stack dari dasar itu sangat berharga.

Membangun stack tanpa library awalnya terasa menakutkan, tapi setelah dicoba, ternyata malah menyenangkan. Rasanya seperti membongkar mesin mobil untuk tahu bagaimana setiap komponen bekerja. Walaupun sekarang saya bisa saja langsung pakai std::stack, pengalaman mengimplementasikan stack dari nol membuat saya lebih percaya diri ketika menghadapi tantangan pemrograman lain.

Kalau kamu sedang belajar struktur data, coba deh implementasi stack sendiri. Jangan takut error—justru dari error itulah kamu belajar. Ingat, setiap programmer pasti pernah stuck, tapi setiap bug yang berhasil kita atasi adalah kemenangan kecil yang akan membentuk kemampuan besar di masa depan.

Jadi, bagaimana menurut kamu? Mau coba bikin stack sendiri tanpa library, atau lebih suka langsung pakai yang sudah jadi?