List #

Di Rust, konsep yang sebanding dengan list di beberapa bahasa lain biasanya diwakili oleh tipe data Vec<T> (vektor) atau LinkedList<T>. Vektor (Vec<T>) adalah tipe data yang lebih umum digunakan karena menawarkan kinerja yang lebih baik untuk sebagian besar kasus penggunaan. Rust juga memiliki array untuk koleksi data dengan ukuran tetap, tetapi vektor lebih fleksibel karena ukurannya dapat berubah dinamis.

Berikut penjelasan lengkap mengenai tipe data Vec<T> dan LinkedList<T> dalam Rust.

Vektor (Vec<T>) #

Vec<T> adalah tipe data koleksi yang paling umum digunakan dalam Rust. Vektor adalah array dinamis yang dapat bertambah atau berkurang ukurannya. Vektor menyimpan elemen-elemen secara berurutan dalam memori dan memungkinkan akses ke elemen-elemen tersebut dengan indeks.

Membuat Vektor #

Ada beberapa cara untuk membuat vektor di Rust:

• Menggunakan Vec::new:

  let v: Vec<i32> = Vec::new();
  

• Menggunakan Makro vec!:

  let v = vec![1, 2, 3, 4, 5];
  

• Mengisi Vektor dengan Elemen yang Sama:

  let v = vec![0; 10]; // Vektor dengan 10 elemen, semuanya 0
  

Menambahkan dan Menghapus Elemen #

Anda dapat menambahkan elemen ke dalam vektor menggunakan metode push, dan menghapus elemen menggunakan metode pop.

Contoh:

fn main() {
    let mut v = Vec::new();
    v.push(1);
    v.push(2);
    v.push(3);

    println!("Vektor: {:?}", v);

    v.pop(); // Menghapus elemen terakhir
    println!("Setelah pop: {:?}", v);
}

Penjelasan:

• push menambahkan elemen ke akhir vektor.
• pop menghapus dan mengembalikan elemen terakhir dari vektor, atau None jika vektor kosong.

Mengakses Elemen #

Anda dapat mengakses elemen-elemen dalam vektor menggunakan indeks atau menggunakan metode get.

Contoh:

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    // Akses menggunakan indeks
    println!("Elemen pertama: {}", v[0]);

    // Akses menggunakan metode `get`
    match v.get(2) {
        Some(&value) => println!("Elemen ketiga: {}", value),
        None => println!("Tidak ada elemen ketiga"),
    }
}

Penjelasan:

• Mengakses elemen dengan v[index] akan memicu panic jika indeks di luar jangkauan.
• v.get(index) mengembalikan Option<&T>, sehingga lebih aman digunakan karena Anda bisa menangani kemungkinan None.

Iterasi #

Anda dapat melakukan iterasi terhadap elemen-elemen dalam vektor menggunakan loop atau metode iterator.

Contoh:

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    for i in &v {
        println!("Elemen: {}", i);
    }
}

Penjelasan:

• for i in &v iterasi melalui referensi elemen-elemen dalam vektor. Ini mencegah vektor dimutasi selama iterasi.

Mengubah Elemen #

Anda dapat memodifikasi elemen-elemen dalam vektor jika Anda memiliki referensi mutable (&mut).

Contoh:

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    for i in &mut v {
        *i += 10;
    }

    println!("Vektor setelah dimodifikasi: {:?}", v);
}

Penjelasan:

• &mut v memungkinkan Anda mengakses elemen-elemen dalam vektor secara mutable.
• *i += 10 menambah 10 ke setiap elemen dalam vektor.

Vektor Multidimensi #

Vektor di Rust dapat mengandung vektor lain, sehingga memungkinkan untuk membuat struktur data seperti matriks atau tabel.

Contoh Vektor 2D:

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    for row in &matrix {
        for val in row {
            print!("{} ", val);
        }
        println!();
    }
}

Penjelasan:

• matrix adalah vektor yang mengandung vektor, merepresentasikan matriks 3x3.

LinkedList<T> #

Selain vektor, Rust juga menyediakan tipe data LinkedList<T> di dalam modul std::collections. LinkedList<T> adalah implementasi dari linked list, di mana setiap elemen dalam daftar menyimpan referensi ke elemen berikutnya.

Membuat LinkedList #

Anda dapat membuat linked list dengan LinkedList::new.

Contoh:

use std::collections::LinkedList;

fn main() {
    let mut list: LinkedList<i32> = LinkedList::new();
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);

    println!("Linked list: {:?}", list);
}

Penjelasan:

• LinkedList::new membuat linked list kosong.
• push_back menambahkan elemen ke akhir linked list.

Menambahkan dan Menghapus Elemen #

Linked list memungkinkan penambahan dan penghapusan elemen dari kedua ujung daftar.

Contoh:

use std::collections::LinkedList;

fn main() {
    let mut list: LinkedList<i32> = LinkedList::new();
    list.push_front(1); // Menambahkan ke depan
    list.push_back(2);  // Menambahkan ke belakang

    println!("Linked list: {:?}", list);

    list.pop_front(); // Menghapus elemen dari depan
    println!("Setelah pop_front: {:?}", list);

    list.pop_back();  // Menghapus elemen dari belakang
    println!("Setelah pop_back: {:?}", list);
}

Penjelasan:

• push_front menambahkan elemen ke awal linked list.
• pop_front dan pop_back masing-masing menghapus elemen dari awal dan akhir linked list.

Iterasi #

Anda dapat melakukan iterasi terhadap elemen-elemen dalam LinkedList menggunakan loop atau metode iterator.

Contoh:

use std::collections::LinkedList;

fn main() {
    let mut list: LinkedList<i32> = LinkedList::new();
    list.push_back(10);
    list.push_back(20);
    list.push_back(30);

    for val in &list {
        println!("Elemen: {}", val);
    }
}

Penjelasan:

• for val in &list melakukan iterasi terhadap referensi elemen-elemen dalam linked list.

Perbandingan Vec<T> dan LinkedList<T> #

Meskipun baik Vec<T> maupun LinkedList<T> adalah tipe data untuk menyimpan koleksi elemen, mereka memiliki karakteristik yang berbeda:

• Vec<T>:

  • Kinerja Akses: Mengakses elemen dengan indeks adalah operasi O(1) karena elemen-elemen disimpan bersebelahan dalam memori.
  • Kinerja Penyisipan/Penghapusan: Penyisipan atau penghapusan di tengah vektor adalah operasi O(n) karena elemen-elemen mungkin perlu dipindahkan.
  • Penggunaan Memori: Lebih efisien dalam penggunaan memori untuk sebagian besar kasus karena elemen disimpan bersebelahan.

• LinkedList<T>:

  • Kinerja Akses: Mengakses elemen adalah operasi O(n) karena harus menelusuri dari awal hingga ke elemen yang diinginkan.
  • Kinerja Penyisipan/Penghapusan: Penyisipan atau penghapusan di awal atau akhir daftar adalah operasi O(1).
  • Penggunaan Memori: Lebih boros memori karena setiap elemen harus menyimpan referensi ke elemen berikutnya dan/atau sebelumnya.

Kesimpulan #

Rust menyediakan dua tipe data utama yang sering digunakan sebagai list: Vec<T> dan LinkedList<T>. Vec<T> adalah pilihan yang paling umum digunakan karena menawarkan kinerja dan fleksibilitas yang baik untuk sebagian besar aplikasi, sedangkan LinkedList<T> berguna dalam situasi di mana Anda sering perlu menyisipkan atau menghapus elemen dari awal atau akhir daftar tanpa banyak biaya untuk akses elemen.

Memahami karakteristik dan penggunaan masing-masing tipe data ini akan membantu Anda memilih struktur data yang tepat untuk kasus penggunaan Anda di Rust.