Struktur Data JavaScript: Menguasai Map, Set, dan Implementasi Kustom untuk Pengembang Global

Di dunia pengembangan perangkat lunak yang dinamis, menguasai struktur data adalah hal yang terpenting. Struktur data membentuk dasar dari algoritma yang efisien dan kode yang terorganisir dengan baik, yang secara langsung memengaruhi kinerja dan skalabilitas aplikasi. Bagi pengembang global, memahami konsep-konsep ini sangat penting untuk membangun aplikasi tangguh yang melayani basis pengguna yang beragam dan menangani beban data yang bervariasi. Panduan komprehensif ini mendalami struktur data bawaan JavaScript yang kuat, Map dan Set, lalu mengeksplorasi alasan dan metode menarik untuk membuat struktur data kustom Anda sendiri.

Kita akan menelusuri contoh-contoh praktis, kasus penggunaan dunia nyata, dan wawasan yang dapat ditindaklanjuti, memastikan bahwa pengembang dari semua latar belakang dapat memanfaatkan alat-alat ini secara maksimal. Baik Anda bekerja di startup di Berlin, perusahaan besar di Tokyo, atau proyek freelance untuk klien di São Paulo, prinsip-prinsip yang dibahas di sini berlaku secara universal.

Pentingnya Struktur Data dalam JavaScript

Sebelum mendalami implementasi JavaScript yang spesifik, mari kita bahas secara singkat mengapa struktur data begitu fundamental. Struktur data adalah format khusus untuk mengorganisir, memproses, mengambil, dan menyimpan data. Pilihan struktur data secara signifikan memengaruhi efisiensi operasi seperti penyisipan, penghapusan, pencarian, dan pengurutan.

Dalam JavaScript, sebuah bahasa yang terkenal dengan fleksibilitas dan adopsi luasnya di seluruh pengembangan front-end, back-end (Node.js), dan seluler, penanganan data yang efisien sangatlah penting. Struktur data yang dipilih dengan buruk dapat menyebabkan:

• Hambatan Kinerja: Waktu muat yang lambat, UI yang tidak responsif, dan pemrosesan sisi server yang tidak efisien.
• Peningkatan Konsumsi Memori: Penggunaan sumber daya sistem yang tidak perlu, yang menyebabkan biaya operasional lebih tinggi dan potensi crash.
• Kompleksitas Kode: Kesulitan dalam memelihara dan melakukan debug kode karena logika manajemen data yang berbelit-belit.

JavaScript, meskipun menawarkan abstraksi yang kuat, juga menyediakan alat bagi pengembang untuk mengimplementasikan solusi yang sangat dioptimalkan. Memahami struktur bawaannya dan pola untuk struktur kustom adalah kunci untuk menjadi pengembang global yang mahir.

Kekuatan Bawaan JavaScript: Map dan Set

Untuk waktu yang lama, pengembang JavaScript sangat bergantung pada objek JavaScript biasa (mirip dengan dictionary atau hash map) dan array untuk mengelola koleksi data. Meskipun serbaguna, keduanya memiliki keterbatasan. Pengenalan Map dan Set di ECMAScript 2015 (ES6) secara signifikan meningkatkan kemampuan manajemen data JavaScript, menawarkan solusi yang lebih khusus dan seringkali lebih berkinerja.

1. Map JavaScript

Sebuah Map adalah koleksi pasangan kunci-nilai di mana kuncinya bisa berupa tipe data apa pun, termasuk objek, fungsi, dan primitif. Ini adalah perbedaan signifikan dari objek JavaScript tradisional, di mana kunci secara implisit diubah menjadi string atau Symbol.

Karakteristik Utama Map:

• Tipe Kunci Apapun: Tidak seperti objek biasa, di mana kunci biasanya berupa string atau Symbol, kunci Map dapat berupa nilai apa pun (objek, primitif, dll.). Hal ini memungkinkan hubungan data yang lebih kompleks dan bernuansa.
• Iterasi Berurutan: Elemen Map diiterasi sesuai urutan penyisipannya. Prediktabilitas ini sangat berharga untuk banyak aplikasi.
• Properti `size`: Map memiliki properti `size` yang secara langsung mengembalikan jumlah elemen, yang lebih efisien daripada mengiterasi kunci atau nilai untuk menghitungnya.
• Kinerja: Untuk penambahan dan penghapusan pasangan kunci-nilai yang sering, Map umumnya menawarkan kinerja yang lebih baik daripada objek biasa, terutama saat berurusan dengan jumlah entri yang besar.

Operasi Umum Map:

Mari kita jelajahi metode-metode penting untuk bekerja dengan Map:

• `new Map([iterable])`: Membuat Map baru. Iterable opsional dari pasangan kunci-nilai dapat disediakan untuk menginisialisasi Map.
• `map.set(key, value)`: Menambahkan atau memperbarui elemen dengan kunci dan nilai yang ditentukan. Mengembalikan objek Map.
• `map.get(key)`: Mengembalikan nilai yang terkait dengan kunci yang ditentukan, atau `undefined` jika kunci tidak ditemukan.
• `map.has(key)`: Mengembalikan boolean yang menunjukkan apakah elemen dengan kunci yang ditentukan ada di dalam Map.
• `map.delete(key)`: Menghapus elemen dengan kunci yang ditentukan dari Map. Mengembalikan `true` jika elemen berhasil dihapus, `false` jika tidak.
• `map.clear()`: Menghapus semua elemen dari Map.
• `map.size`: Mengembalikan jumlah elemen di dalam Map.

Iterasi dengan Map:

Map bersifat iterable, yang berarti Anda dapat menggunakan konstruksi seperti loop `for...of` dan sintaks spread (`...`) untuk menelusuri isinya.

• `map.keys()`: Mengembalikan iterator untuk kunci.
• `map.values()`: Mengembalikan iterator untuk nilai.
• `map.entries()`: Mengembalikan iterator untuk pasangan kunci-nilai (sebagai array `[key, value]`).
• `map.forEach((value, key, map) => {})`: Menjalankan fungsi yang disediakan sekali untuk setiap pasangan kunci-nilai.

Kasus Penggunaan Praktis Map:

Map sangat serbaguna. Berikut beberapa contohnya:

• Caching: Menyimpan data yang sering diakses (misalnya, respons API, nilai yang dihitung) dengan kunci yang sesuai.
• Mengasosiasikan Data dengan Objek: Menggunakan objek itu sendiri sebagai kunci untuk mengasosiasikan metadata atau properti tambahan dengan objek tersebut.
• Menerapkan Pencarian (Lookup): Memetakan ID ke objek pengguna, detail produk, atau pengaturan konfigurasi secara efisien.
• Penghitungan Frekuensi: Menghitung kemunculan item dalam daftar, di mana item adalah kunci dan jumlahnya adalah nilai.

Contoh: Caching Respons API (Perspektif Global)

Bayangkan membangun platform e-commerce global. Anda mungkin mengambil detail produk dari berbagai API regional. Melakukan cache pada respons ini dapat secara drastis meningkatkan kinerja. Dengan Map, ini menjadi mudah:

            const apiCache = new Map();

async function getProductDetails(productId, region) {
  const cacheKey = `${productId}-${region}`;

  if (apiCache.has(cacheKey)) {
    console.log(`Cache hit for ${cacheKey}`);
    return apiCache.get(cacheKey);
  }

  console.log(`Cache miss for ${cacheKey}. Fetching from API...`);
  // Mensimulasikan pengambilan data dari API regional
  const response = await fetch(`https://api.example.com/${region}/products/${productId}`);
  const productData = await response.json();

  // Simpan di cache untuk penggunaan di masa depan
  apiCache.set(cacheKey, productData);

  return productData;
}

// Contoh penggunaan di berbagai wilayah:
getProductDetails('XYZ789', 'us-east-1'); // Mengambil dan menyimpan di cache
getProductDetails('XYZ789', 'eu-west-2'); // Mengambil dan menyimpan di cache secara terpisah
getProductDetails('XYZ789', 'us-east-1'); // Cache hit!

            

              
                Copy
              
            
          

2. Set JavaScript

Sebuah Set adalah koleksi nilai-nilai unik. Ini memungkinkan Anda menyimpan elemen-elemen yang berbeda, secara otomatis menangani duplikat. Seperti Map, elemen Set bisa berupa tipe data apa pun.

Karakteristik Utama Set:

• Nilai Unik: Fitur paling menonjol dari Set adalah hanya menyimpan nilai-nilai unik. Jika Anda mencoba menambahkan nilai yang sudah ada, itu akan diabaikan.
• Iterasi Berurutan: Elemen Set diiterasi sesuai urutan penyisipannya.
• Properti `size`: Mirip dengan Map, Set memiliki properti `size` untuk mendapatkan jumlah elemen.
• Kinerja: Memeriksa keberadaan elemen (`has`) dan menambahkan/menghapus elemen umumnya merupakan operasi yang sangat efisien di Set, seringkali dengan kompleksitas waktu rata-rata O(1).

Operasi Umum Set:

• `new Set([iterable])`: Membuat Set baru. Iterable opsional dapat disediakan untuk menginisialisasi Set dengan elemen.
• `set.add(value)`: Menambahkan elemen baru ke Set. Mengembalikan objek Set.
• `set.has(value)`: Mengembalikan boolean yang menunjukkan apakah elemen dengan nilai yang ditentukan ada di dalam Set.
• `set.delete(value)`: Menghapus elemen dengan nilai yang ditentukan dari Set. Mengembalikan `true` jika elemen berhasil dihapus, `false` jika tidak.
• `set.clear()`: Menghapus semua elemen dari Set.
• `set.size`: Mengembalikan jumlah elemen di dalam Set.

Iterasi dengan Set:

Set juga bersifat iterable:

• `set.keys()`: Mengembalikan iterator untuk nilai (karena kunci dan nilai sama dalam Set).
• `set.values()`: Mengembalikan iterator untuk nilai.
• `set.entries()`: Mengembalikan iterator untuk nilai, dalam bentuk `[value, value]`.
• `set.forEach((value, key, set) => {})`: Menjalankan fungsi yang disediakan sekali untuk setiap elemen.

Kasus Penggunaan Praktis Set:

• Menghapus Duplikat: Cara cepat dan efisien untuk mendapatkan daftar item unik dari sebuah array.
• Pengujian Keanggotaan: Memeriksa apakah suatu item ada dalam koleksi dengan sangat cepat.
• Melacak Peristiwa Unik: Memastikan bahwa peristiwa tertentu dicatat atau diproses hanya sekali.
• Operasi Set: Melakukan operasi gabungan (union), irisan (intersection), dan selisih (difference) pada koleksi.

Contoh: Menemukan Pengguna Unik dalam Log Peristiwa Global

Pertimbangkan sebuah aplikasi web global yang melacak aktivitas pengguna. Anda mungkin memiliki log dari server atau layanan yang berbeda, berpotensi dengan entri duplikat untuk tindakan pengguna yang sama. Set sangat cocok untuk menemukan semua pengguna unik yang berpartisipasi:

            const userActivityLogs = [
  { userId: 'user123', action: 'login', timestamp: '2023-10-27T10:00:00Z', region: 'Asia' },
  { userId: 'user456', action: 'view', timestamp: '2023-10-27T10:05:00Z', region: 'Europe' },
  { userId: 'user123', action: 'click', timestamp: '2023-10-27T10:06:00Z', region: 'Asia' },
  { userId: 'user789', action: 'login', timestamp: '2023-10-27T10:08:00Z', region: 'North America' },
  { userId: 'user456', action: 'logout', timestamp: '2023-10-27T10:10:00Z', region: 'Europe' },
  { userId: 'user123', action: 'view', timestamp: '2023-10-27T10:12:00Z', region: 'Asia' } // Aksi duplikat user123
];

const uniqueUserIds = new Set();

userActivityLogs.forEach(log => {
  uniqueUserIds.add(log.userId);
});

console.log('Unique User IDs:', Array.from(uniqueUserIds)); // Menggunakan Array.from untuk mengubah Set kembali menjadi array untuk ditampilkan
// Output: ID Pengguna Unik: [ 'user123', 'user456', 'user789' ]

// Contoh lain: Menghapus duplikat dari daftar ID produk
const productIds = ['A101', 'B202', 'A101', 'C303', 'B202', 'D404'];
const uniqueProductIds = new Set(productIds);
console.log('Unique Product IDs:', [...uniqueProductIds]); // Menggunakan sintaks spread
// Output: ID Produk Unik: [ 'A101', 'B202', 'C303', 'D404' ]

            

              
                Copy
              
            
          

Kapan Struktur Bawaan Tidak Cukup: Struktur Data Kustom

Meskipun Map dan Set sangat kuat, mereka adalah alat serbaguna. Dalam skenario tertentu, terutama untuk algoritma kompleks, persyaratan data yang sangat khusus, atau aplikasi yang kritis terhadap kinerja, Anda mungkin perlu mengimplementasikan struktur data kustom Anda sendiri. Di sinilah pemahaman yang lebih dalam tentang algoritma dan kompleksitas komputasi menjadi penting.

Mengapa Membuat Struktur Data Kustom?

• Optimisasi Kinerja: Menyesuaikan struktur dengan masalah tertentu dapat menghasilkan peningkatan kinerja yang signifikan dibandingkan solusi generik. Misalnya, struktur tree khusus mungkin lebih cepat untuk kueri pencarian tertentu daripada Map.
• Efisiensi Memori: Struktur kustom dapat dirancang untuk menggunakan memori secara lebih tepat, menghindari overhead yang terkait dengan struktur serbaguna.
• Fungsionalitas Spesifik: Menerapkan perilaku atau batasan unik yang tidak didukung oleh struktur bawaan (misalnya, priority queue dengan aturan pengurutan tertentu, graph dengan edge berarah).
• Tujuan Edukasi: Memahami cara kerja struktur data fundamental (seperti stack, queue, linked list, tree) dengan mengimplementasikannya dari awal.
• Implementasi Algoritma: Banyak algoritma canggih secara intrinsik terkait dengan struktur data tertentu (misalnya, algoritma Dijkstra sering menggunakan min-priority queue).

Struktur Data Kustom Umum untuk Diimplementasikan di JavaScript:

1. Linked List

Linked list adalah struktur data linear di mana elemen tidak disimpan di lokasi memori yang berdekatan. Sebaliknya, setiap elemen (sebuah node) berisi data dan referensi (atau link) ke node berikutnya dalam urutan.

• Jenis: Singly Linked List, Doubly Linked List, Circular Linked List.
• Kasus Penggunaan: Menerapkan stack dan queue, mengelola memori dinamis, fungsionalitas undo/redo.
• Kompleksitas: Penyisipan/penghapusan di awal/akhir bisa O(1), tetapi pencarian adalah O(n).

Sketsa Implementasi: Singly Linked List

Kita akan menggunakan pendekatan berbasis kelas yang sederhana, yang umum di JavaScript.

            class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.size = 0;
  }

  // Tambah node ke akhir
  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
    this.size++;
  }

  // Hapus node berdasarkan nilai
  remove(data) {
    if (!this.head) return false;

    if (this.head.data === data) {
      this.head = this.head.next;
      this.size--;
      return true;
    }

    let current = this.head;
    while (current.next) {
      if (current.next.data === data) {
        current.next = current.next.next;
        this.size--;
        return true;
      }
      current = current.next;
    }
    return false;
  }

  // Cari node berdasarkan nilai
  find(data) {
    let current = this.head;
    while (current) {
      if (current.data === data) {
        return current;
      }
      current = current.next;
    }
    return null;
  }

  // Cetak list
  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

// Penggunaan:
const myList = new LinkedList();
myList.add('Apple');
myList.add('Banana');
myList.add('Cherry');
myList.print(); // Apple -> Banana -> Cherry -> null
myList.remove('Banana');
myList.print(); // Apple -> Cherry -> null
console.log(myList.find('Apple')); // Node { data: 'Apple', next: Node { data: 'Cherry', next: null } }
console.log('Size:', myList.size); // Size: 2

            

              
                Copy
              
            
          

2. Stack

Stack adalah struktur data linear yang mengikuti prinsip Last-In, First-Out (LIFO). Bayangkan tumpukan piring: Anda menambahkan piring baru ke atas, dan Anda mengambil piring dari atas.

• Operasi: `push` (tambah ke atas), `pop` (hapus dari atas), `peek` (lihat elemen atas), `isEmpty`.
• Kasus Penggunaan: Tumpukan panggilan fungsi, evaluasi ekspresi, algoritma backtracking.
• Kompleksitas: Semua operasi utama biasanya O(1).

Sketsa Implementasi: Stack menggunakan Array

Sebuah array JavaScript dapat dengan mudah meniru sebuah stack.

            class Stack {
  constructor() {
    this.items = [];
  }

  // Tambah elemen ke atas
  push(element) {
    this.items.push(element);
  }

  // Hapus dan kembalikan elemen teratas
  pop() {
    if (this.isEmpty()) {
      return "Underflow"; // Atau lemparkan error
    }
    return this.items.pop();
  }

  // Lihat elemen teratas tanpa menghapus
  peek() {
    if (this.isEmpty()) {
      return "No elements in Stack";
    }
    return this.items[this.items.length - 1];
  }

  // Periksa apakah stack kosong
  isEmpty() {
    return this.items.length === 0;
  }

  // Dapatkan ukuran
  size() {
    return this.items.length;
  }

  // Cetak stack (atas ke bawah)
  print() {
    let str = "";
    for (let i = this.items.length - 1; i >= 0; i--) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Penggunaan:
const myStack = new Stack();
myStack.push(10);
myStack.push(20);
myStack.push(30);
myStack.print(); // 30 20 10
console.log('Peek:', myStack.peek()); // Peek: 30
console.log('Pop:', myStack.pop());   // Pop: 30
myStack.print(); // 20 10
console.log('Is Empty:', myStack.isEmpty()); // Is Empty: false

            

              
                Copy
              
            
          

3. Queue

Queue adalah struktur data linear yang mengikuti prinsip First-In, First-Out (FIFO). Bayangkan antrean orang yang menunggu di loket tiket: orang pertama dalam antrean adalah yang pertama dilayani.

• Operasi: `enqueue` (tambah ke belakang), `dequeue` (hapus dari depan), `front` (lihat elemen depan), `isEmpty`.
• Kasus Penggunaan: Penjadwalan tugas, mengelola permintaan (misalnya, antrean cetak, antrean permintaan server web), pencarian breadth-first (BFS) dalam graph.
• Kompleksitas: Dengan array standar, `dequeue` bisa menjadi O(n) karena pengindeksan ulang. Implementasi yang lebih dioptimalkan (misalnya, menggunakan linked list atau dua stack) mencapai O(1).

Sketsa Implementasi: Queue menggunakan Array (dengan pertimbangan kinerja)

Meskipun `shift()` pada array adalah O(n), ini adalah cara paling mudah untuk contoh dasar. Untuk produksi, pertimbangkan linked list atau queue berbasis array yang lebih canggih.

            class Queue {
  constructor() {
    this.items = [];
  }

  // Tambah elemen ke belakang
  enqueue(element) {
    this.items.push(element);
  }

  // Hapus dan kembalikan elemen depan
  dequeue() {
    if (this.isEmpty()) {
      return "Underflow";
    }
    return this.items.shift(); // Operasi O(n) pada array standar
  }

  // Lihat elemen depan tanpa menghapus
  front() {
    if (this.isEmpty()) {
      return "No elements in Queue";
    }
    return this.items[0];
  }

  // Periksa apakah queue kosong
  isEmpty() {
    return this.items.length === 0;
  }

  // Dapatkan ukuran
  size() {
    return this.items.length;
  }

  // Cetak queue (depan ke belakang)
  print() {
    let str = "";
    for (let i = 0; i < this.items.length; i++) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Penggunaan:
const myQueue = new Queue();
myQueue.enqueue('A');
myQueue.enqueue('B');
myQueue.enqueue('C');
myQueue.print(); // A B C
console.log('Front:', myQueue.front()); // Front: A
console.log('Dequeue:', myQueue.dequeue()); // Dequeue: A
myQueue.print(); // B C
console.log('Is Empty:', myQueue.isEmpty()); // Is Empty: false

            

              
                Copy
              
            
          

4. Tree (Binary Search Tree - BST)

Tree adalah struktur data hierarkis. Binary Search Tree (BST) adalah jenis tree di mana setiap node memiliki paling banyak dua anak, yang disebut sebagai anak kiri dan anak kanan. Untuk setiap node tertentu, semua nilai di subtree kirinya lebih kecil dari nilai node, dan semua nilai di subtree kanannya lebih besar.

• Operasi: Penyisipan, penghapusan, pencarian, traversal (in-order, pre-order, post-order).
• Kasus Penggunaan: Pencarian dan pengurutan yang efisien (seringkali lebih baik dari O(n) untuk tree yang seimbang), implementasi tabel simbol, pengindeksan basis data.
• Kompleksitas: Untuk BST yang seimbang, pencarian, penyisipan, dan penghapusan adalah O(log n). Untuk tree yang miring, mereka bisa menurun menjadi O(n).

Sketsa Implementasi: Binary Search Tree

Implementasi ini berfokus pada penyisipan dan pencarian dasar.

            class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  // Sisipkan nilai ke dalam BST
  insert(value) {
    const newNode = new TreeNode(value);
    if (!this.root) {
      this.root = newNode;
      return this;
    }

    let current = this.root;
    while (true) {
      if (value === current.value) return undefined; // Atau tangani duplikat sesuai kebutuhan

      if (value < current.value) {
        if (!current.left) {
          current.left = newNode;
          return this;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          return this;
        }
        current = current.right;
      }
    }
  }

  // Cari nilai dalam BST
  search(value) {
    if (!this.root) return null;
    let current = this.root;
    while (current) {
      if (value === current.value) return current;
      if (value < current.value) {
        current = current.left;
      } else {
        current = current.right;
      }
    }
    return null; // Tidak ditemukan
  }

  // Traversal in-order (mengembalikan daftar yang diurutkan)
  inOrderTraversal(node = this.root, result = []) {
    if (node) {
      this.inOrderTraversal(node.left, result);
      result.push(node.value);
      this.inOrderTraversal(node.right, result);
    }
    return result;
  }
}

// Penggunaan:
const bst = new BinarySearchTree();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(2);
bst.insert(7);
bst.insert(12);
bst.insert(18);

console.log('In-order traversal:', bst.inOrderTraversal()); // [ 2, 5, 7, 10, 12, 15, 18 ]
console.log('Search for 7:', bst.search(7)); // TreeNode { value: 7, left: null, right: null }
console.log('Search for 100:', bst.search(100)); // null

            

              
                Copy
              
            
          

5. Graph

Graph adalah struktur data serbaguna yang merepresentasikan sekumpulan objek (vertex atau node) di mana setiap pasangan vertex dapat dihubungkan oleh sebuah hubungan (sebuah edge). Mereka digunakan untuk memodelkan jaringan.

• Jenis: Berarah vs. Tidak Berarah, Berbobot vs. Tidak Berbobot.
• Representasi: Adjacency List (paling umum di JS), Adjacency Matrix.
• Operasi: Menambah/menghapus vertex/edge, traversal (DFS, BFS), menemukan jalur terpendek.
• Kasus Penggunaan: Jejaring sosial, sistem pemetaan/navigasi, mesin rekomendasi, topologi jaringan.
• Kompleksitas: Sangat bervariasi tergantung pada representasi dan operasi.

Sketsa Implementasi: Graph dengan Adjacency List

Adjacency list menggunakan Map (atau objek biasa) di mana kunci adalah vertex dan nilai adalah array dari vertex yang berdekatan.

            class Graph {
  constructor() {
    this.adjacencyList = new Map(); // Menggunakan Map untuk penanganan kunci yang lebih baik
  }

  // Tambah vertex
  addVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      this.adjacencyList.set(vertex, []);
    }
  }

  // Tambah edge (untuk graph tidak berarah)
  addEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      throw new Error("Satu atau kedua vertex tidak ada.");
    }
    this.adjacencyList.get(vertex1).push(vertex2);
    this.adjacencyList.get(vertex2).push(vertex1); // Untuk graph tidak berarah
  }

  // Hapus edge
  removeEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      return false;
    }
    this.adjacencyList.set(vertex1, this.adjacencyList.get(vertex1).filter(v => v !== vertex2));
    this.adjacencyList.set(vertex2, this.adjacencyList.get(vertex2).filter(v => v !== vertex1));
    return true;
  }

  // Hapus vertex dan semua edge-nya
  removeVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      return false;
    }
    while (this.adjacencyList.get(vertex).length) {
      const adjacentVertex = this.adjacencyList.get(vertex).pop();
      this.removeEdge(vertex, adjacentVertex);
    }
    this.adjacencyList.delete(vertex);
    return true;
  }

  // Traversal Depth First Search (DFS) dasar
  dfs(startVertex, visited = new Set(), result = []) {
    if (!this.adjacencyList.has(startVertex)) return null;

    visited.add(startVertex);
    result.push(startVertex);

    this.adjacencyList.get(startVertex).forEach(neighbor => {
      if (!visited.has(neighbor)) {
        this.dfs(neighbor, visited, result);
      }
    });
    return result;
  }
}

// Penggunaan (mis., merepresentasikan rute penerbangan antar kota global):
const flightNetwork = new Graph();
flightNetwork.addVertex('New York');
flightNetwork.addVertex('London');
flightNetwork.addVertex('Tokyo');
flightNetwork.addVertex('Sydney');
flightNetwork.addVertex('Rio de Janeiro');

flightNetwork.addEdge('New York', 'London');
flightNetwork.addEdge('New York', 'Tokyo');
flightNetwork.addEdge('London', 'Tokyo');
flightNetwork.addEdge('London', 'Rio de Janeiro');
flightNetwork.addEdge('Tokyo', 'Sydney');

console.log('Flight Network DFS from New York:', flightNetwork.dfs('New York'));
// Contoh Output: [ 'New York', 'London', 'Tokyo', 'Sydney', 'Rio de Janeiro' ] (urutan dapat bervariasi tergantung pada iterasi Set)

// flightNetwork.removeEdge('New York', 'London');
// flightNetwork.removeVertex('Tokyo');

            

              
                Copy
              
            
          

Memilih Pendekatan yang Tepat

Saat memutuskan apakah akan menggunakan Map/Set bawaan atau mengimplementasikan struktur kustom, pertimbangkan hal berikut:

• Kompleksitas Masalah: Untuk koleksi dan pencarian yang sederhana, Map dan Set biasanya sudah cukup dan seringkali lebih berkinerja karena optimisasi asli.
• Kebutuhan Kinerja: Jika aplikasi Anda memerlukan kinerja ekstrem untuk operasi tertentu (misalnya, penyisipan dan penghapusan dalam waktu konstan, pencarian logaritmik), struktur kustom mungkin diperlukan.
• Kurva Belajar: Mengimplementasikan struktur kustom memerlukan pemahaman yang kuat tentang prinsip-prinsip algoritma dan struktur data. Untuk sebagian besar tugas umum, memanfaatkan fitur bawaan lebih produktif.
• Keterpeliharaan (Maintainability): Struktur kustom yang terdokumentasi dan teruji dengan baik dapat dipelihara, tetapi yang kompleks dapat menimbulkan overhead pemeliharaan yang signifikan.

Pertimbangan Pengembangan Global

Sebagai pengembang yang bekerja di panggung global, beberapa faktor yang terkait dengan struktur data perlu diperhatikan:

• Skalabilitas: Bagaimana kinerja struktur data pilihan Anda saat volume data tumbuh secara eksponensial? Ini sangat penting untuk aplikasi yang melayani jutaan pengguna di seluruh dunia. Struktur bawaan seperti Map dan Set umumnya dioptimalkan dengan baik untuk skalabilitas, tetapi struktur kustom harus dirancang dengan mempertimbangkan hal ini.
• Internasionalisasi (i18n) dan Lokalisasi (l10n): Data dapat berasal dari latar belakang linguistik dan budaya yang beragam. Pertimbangkan bagaimana struktur data Anda menangani set karakter, aturan pengurutan, dan format data yang berbeda. Misalnya, saat menyimpan nama pengguna, menggunakan Map dengan objek sebagai kunci mungkin lebih tangguh daripada kunci string sederhana.
• Zona Waktu dan Penanganan Tanggal/Waktu: Menyimpan dan menanyakan data yang sensitif terhadap waktu di berbagai zona waktu memerlukan pertimbangan yang cermat. Meskipun bukan masalah struktur data secara ketat, pengambilan dan manipulasi objek tanggal yang efisien seringkali bergantung pada bagaimana mereka disimpan (misalnya, dalam Map yang diindeks oleh timestamp atau nilai UTC).
• Kinerja Lintas Wilayah: Latensi jaringan dan lokasi server dapat memengaruhi kinerja yang dirasakan. Pengambilan dan pemrosesan data yang efisien di server (menggunakan struktur yang sesuai) dan di sisi klien dapat mengurangi masalah ini.
• Kolaborasi Tim: Saat bekerja dalam tim yang beragam dan terdistribusi, dokumentasi yang jelas dan pemahaman bersama tentang struktur data yang digunakan sangat penting. Menerapkan struktur standar seperti Map dan Set memfasilitasi orientasi dan kolaborasi yang lebih mudah.

Kesimpulan

Map dan Set JavaScript menyediakan solusi yang kuat, efisien, dan elegan untuk banyak tugas manajemen data umum. Mereka menawarkan kemampuan yang lebih baik dibandingkan metode lama dan merupakan alat penting bagi setiap pengembang JavaScript modern.

Namun, dunia struktur data jauh melampaui tipe bawaan ini. Untuk masalah kompleks, hambatan kinerja, atau persyaratan khusus, mengimplementasikan struktur data kustom seperti Linked List, Stack, Queue, Tree, dan Graph adalah upaya yang bermanfaat dan seringkali diperlukan. Hal ini memperdalam pemahaman Anda tentang efisiensi komputasi dan pemecahan masalah.

Sebagai pengembang global, merangkul alat-alat ini dan memahami implikasinya terhadap skalabilitas, kinerja, dan internasionalisasi akan memberdayakan Anda untuk membangun aplikasi yang canggih, tangguh, dan berkinerja tinggi yang dapat berkembang di panggung dunia. Teruslah menjelajah, teruslah mengimplementasikan, dan teruslah mengoptimalkan!