Algoritma, Struktur Data, Abstract Data Type (ADT)

Latihan membuat instruksi pembelajaran tentang Algoritma, Struktur Data, dan Abstract Data Type (ADT).

Implementasi instruksinya menggunakan bahasa pemrograman Rust.

Abstract Data Type (ADT) dalam pemrograman Rust

Ringkasan Tujuan

Materi ini memperkenalkan tiga konsep dasar dalam informatika:

1. Algoritma – langkah-langkah sistematis untuk menyelesaikan masalah.

2. Struktur Data – cara menyimpan dan mengorganisasi data.

3. Abstract Data Type (ADT) – model tipe data yang mendefinisikan data, nilai, dan operasi yang berlaku atasnya.

Niklaus Wirth, yang menciptakan bahasa pemrograman Pascal, merumuskan hubungan penting ini dalam bukunya:

“Algoritma + Struktur Data = Program”

Tujuan Pembelajaran

Setelah mempelajari materi ini, Anda diharapkan dapat:

1. Menjelaskan perbedaan algoritma, struktur data, dan ADT.

2. Membuat algoritma sederhana dalam Rust.

3. Memanfaatkan struktur data sederhana seperti array.

4. Memahami ADT dengan contoh konkret, termasuk operasinya.

5. Menyadari pentingnya modularisasi melalui ADT.

6. Membuat dan menguji operasi ADT dengan test case.

Prasyarat

• Variabel dan assignment.

• Percabangan (if-else).

• Perulangan (for, while).

• Array sederhana.

• Fungsi sederhana.

Langkah-langkah Tugas

1. Algoritma

Definisi: prosedur terstruktur, terhingga, dan jelas untuk menyelesaikan masalah.

Contoh: mencari bilangan terbesar dalam array

fn main() {
    let data = [3, 7, 2, 9, 5];
    let mut maks = data[0];

    for i in 1..data.len() {
        if data[i] > maks {
            maks = data[i];
        }
    }

    println!("Bilangan terbesar adalah {}", maks);
}

2. Struktur Data

Definisi: cara data disimpan dan diorganisasi.

Contoh: array nilai ujian

fn main() {
    let nilai = [80, 75, 90, 60];

    let mut total = 0;
    for i in 0..nilai.len() {
        total += nilai[i];
    }

    let rata = total as f32 / nilai.len() as f32;
    println!("Rata-rata nilai = {}", rata);
}

3. Abstract Data Type (ADT)

Definisi
ADT adalah pemodelan tipe data berdasarkan:

• data yang terkandung,

• himpunan nilai yang mungkin, dan

• operasi yang dapat dilakukan.

Contoh: ADT Waktu

struct Waktu {
    jam: i32,
    menit: i32,
    detik: i32,
}

fn buat_waktu(j: i32, m: i32, d: i32) -> Waktu {
    Waktu { jam: j, menit: m, detik: d }
}

fn tampilkan(w: &Waktu) {
    println!("{:02}:{:02}:{:02}", w.jam, w.menit, w.detik);
}

Operasi Selisih Waktu: Cara 1 (langsung per komponen)

fn selisih_komponen(w1: &Waktu, w2: &Waktu) -> Waktu {
    // Versi disederhanakan, tidak mempertimbangkan jam negatif
    let mut jam = w2.jam - w1.jam;
    let mut menit = w2.menit - w1.menit;
    let mut detik = w2.detik - w1.detik;

    // Normalisasi jika hasil negatif
    if detik < 0 {
        detik += 60;
        menit -= 1;
    }
    if menit < 0 {
        menit += 60;
        jam -= 1;
    }

    Waktu { jam, menit, detik }
}

Operasi Selisih Waktu: Cara 2 (konversi ke detik)

fn ke_detik(w: &Waktu) -> i32 {
    w.jam * 3600 + w.menit * 60 + w.detik
}

fn dari_detik(total: i32) -> Waktu {
    let jam = total / 3600;
    let sisa = total % 3600;
    let menit = sisa / 60;
    let detik = sisa % 60;
    Waktu { jam, menit, detik }
}

fn selisih_detik(w1: &Waktu, w2: &Waktu) -> Waktu {
    let d = ke_detik(w2) - ke_detik(w1);
    dari_detik(d)
}

Contoh Pemakaian

fn main() {
    let w1 = buat_waktu(13, 45, 0);
    let w2 = buat_waktu(14, 30, 0);

    let hasil1 = selisih_komponen(&w1, &w2);
    let hasil2 = selisih_detik(&w1, &w2);

    tampilkan(&hasil1); // 00:45:00
    tampilkan(&hasil2); // 00:45:00
}

Modularisasi

Dengan ADT, detail implementasi tersembunyi. Program utama cukup memanggil operasi selisih_komponen atau selisih_detik tanpa perlu tahu bagaimana cara internalnya bekerja.
Hal ini mendukung modularisasi, yaitu pemisahan kode menjadi bagian-bagian yang jelas, mudah dipelihara, dan dapat digunakan kembali.

Test Case pada ADT

ADT harus diuji sesuai spesifikasinya. Untuk ADT Waktu:

1. Kasus normal

   • Input: 13:45:00 dan 14:30:00

   • Hasil: 00:45:00.

2. Kasus sama

   • Input: 10:00:00 dan 10:00:00

   • Hasil: 00:00:00.

3. Kasus dengan carry-over

   • Input: 13:59:50 dan 14:00:10

   • Hasil: 00:00:20.

Dengan test case, kita memastikan operasi pada ADT sesuai dengan definisi yang diharapkan.

Pertanyaan Refleksi

1. Apa perbedaan pendekatan menghitung selisih waktu dengan cara komponen dan dengan cara konversi ke detik?

2. Menurut Anda, cara mana yang lebih mudah dipahami? Cara mana yang lebih fleksibel jika durasi waktunya panjang?

3. Bagaimana test case membantu memastikan operasi ADT berfungsi dengan benar?