Memperbaiki Masalah Modifikasi Node di Daftar Tertaut: Ketidakmampuan JavaScript untuk Menyetel Node ke Null

Memperbaiki Modifikasi Node di Daftar Tertaut JavaScript: Panduan Lengkap

Solusi ini menggunakan JavaScript vanilla untuk mengubah node dalam Daftar Tertaut dan menunjukkan cara menghapus node tengah dengan benar. Ini juga mencakup penanganan kesalahan dan validasi input.

class ListNode {
  constructor(val = 0, next = null) {
    this.val = val;
    this.next = next;
  }
}

function deleteMiddle(head) {
  if (!head || !head.next) return null;  // Handle edge case when list is empty or has only one element
  let slow = head;
  let fast = head;
  let prev = null;

  // Traverse with two pointers (slow and fast)
  while (fast && fast.next) {
    prev = slow;
    slow = slow.next;
    fast = fast.next.next;
  }

  // Delete middle node by skipping over it
  prev.next = slow.next;
  return head;
}

// Helper function to print list
function printList(head) {
  let current = head;
  while (current) {
    console.log(current.val);
    current = current.next;
  }
}

// Example usage
let a = new ListNode(1);
let b = new ListNode(2);
let c = new ListNode(3);
let d = new ListNode(4);
let e = new ListNode(5);

a.next = b;
b.next = c;
c.next = d;
d.next = e;

console.log("Before Deletion:");
printList(a);

deleteMiddle(a);

console.log("After Deletion:");
printList(a);

Pendekatan Alternatif: Memodifikasi Nilai Node Daripada Menghapusnya

Pendekatan ini memanfaatkan trik umum di mana nilai node tengah diganti dengan nilai node berikutnya, dan kemudian node berikutnya dihapus. Hal ini menghindari keharusan melacak node sebelumnya.

function deleteMiddleAlternative(head) {
  if (!head || !head.next) return null;  // Handle edge case for single node list
  let slow = head;
  let fast = head;

  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
  }

  // Replace value of the slow pointer with the next node's value
  if (slow.next) {
    slow.val = slow.next.val;
    slow.next = slow.next.next;
  }
  return head;
}

// Example usage
let x = new ListNode(1);
let y = new ListNode(2);
let z = new ListNode(3);
x.next = y;
y.next = z;

console.log("Before Deletion (Alternative):");
printList(x);

deleteMiddleAlternative(x);

console.log("After Deletion (Alternative):");
printList(x);

Pertanyaan Umum Tentang Modifikasi Node Daftar Tertaut

1. Untuk apa menyetel node null dalam daftar tertaut lakukan?
2. Menyetel simpul ke null hanya mengubah referensi dalam variabel itu, tetapi tidak mengubah struktur daftar aslinya.
3. Kenapa tidak b = null ubah daftar dalam contoh?
4. Ketika Anda melakukannya b = null, itu hanya mengubah referensi untuk b, bukan next penunjuk yang menghubungkan node-node dalam daftar tertaut.
5. Bagaimana Anda menghapus simpul tengah dalam daftar tertaut?
6. Anda dapat mengganti nilai simpul dengan nilai simpul berikutnya menggunakan slow.val = slow.next.val dan lewati node berikutnya dengan memperbarui next penunjuk.
7. Apa teknik dua penunjuk dalam daftar tertaut?
8. Ini adalah pendekatan umum di mana satu penunjuk (cepat) bergerak dua langkah sekaligus dan penunjuk lainnya (lambat) bergerak satu langkah untuk menemukan simpul tengah.
9. Mengapa prev.next = slow.next perintah yang diperlukan dalam penghapusan node?
10. Perintah ini memperbarui penunjuk simpul sebelumnya untuk melewati simpul tengah, sehingga secara efektif menghapusnya dari daftar.

Pemikiran Akhir tentang Penghapusan Node dalam Daftar Tertaut

Bekerja dengan daftar tertaut di JavaScript sering kali memerlukan pemahaman bagaimana referensi objek dan pointer berinteraksi. Menyetel node ke null saja tidak akan menghapusnya dari daftar; Anda harus memperbarui pointer dengan benar untuk menghapus node. Hal ini sangat penting ketika berhadapan dengan node tengah.

Dengan menggunakan teknik penunjuk lambat dan cepat, serta manipulasi penunjuk secara hati-hati, Anda dapat menghapus sebuah simpul dari daftar secara efisien. Menguasai teknik ini memastikan Anda dapat menangani penghapusan node dalam daftar tertaut tanpa hasil yang tidak terduga, yang merupakan keterampilan penting dalam pemecahan masalah algoritmik.