ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚ ਨੋਡ ਸੰਸ਼ੋਧਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ: ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀ ਨੋਡ ਨੂੰ ਨਲ ਵਿੱਚ ਸੈਟ ਕਰਨ ਵਿੱਚ ਅਸਮਰੱਥਾ

JavaScript ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚ ਨੋਡ ਸੋਧ ਨੂੰ ਫਿਕਸ ਕਰਨਾ: ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਗਾਈਡ

ਇਹ ਹੱਲ ਇੱਕ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਨੋਡਾਂ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰਨ ਲਈ ਵਨੀਲਾ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਮੱਧ ਨੋਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਮਿਟਾਉਣਾ ਹੈ। ਇਸ ਵਿੱਚ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਅਤੇ ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ ਵੀ ਸ਼ਾਮਲ ਹੈ।

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);

ਵਿਕਲਪਕ ਪਹੁੰਚ: ਇਸ ਨੂੰ ਹਟਾਉਣ ਦੀ ਬਜਾਏ ਨੋਡ ਦੇ ਮੁੱਲ ਨੂੰ ਸੋਧਣਾ

ਇਹ ਪਹੁੰਚ ਇੱਕ ਆਮ ਚਾਲ ਦਾ ਲਾਭ ਉਠਾਉਂਦੀ ਹੈ ਜਿੱਥੇ ਮੱਧ ਨੋਡ ਦੇ ਮੁੱਲ ਨੂੰ ਅਗਲੇ ਨੋਡ ਦੇ ਮੁੱਲ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਅਗਲਾ ਨੋਡ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਪਿਛਲੇ ਨੋਡ ਨੂੰ ਟਰੈਕ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ।

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);

ਲਿੰਕਡ ਸੂਚੀ ਨੋਡ ਸੋਧ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. ਕੀ ਕਰਨ ਲਈ ਇੱਕ ਨੋਡ ਸੈੱਟ ਕਰਦਾ ਹੈ null ਇੱਕ ਲਿੰਕ ਕੀਤੀ ਸੂਚੀ ਵਿੱਚ ਕਰਦੇ ਹੋ?
2. ਲਈ ਇੱਕ ਨੋਡ ਸੈੱਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ null ਸਿਰਫ਼ ਉਸ ਵੇਰੀਏਬਲ ਵਿੱਚ ਹਵਾਲਾ ਬਦਲਦਾ ਹੈ, ਪਰ ਇਹ ਮੂਲ ਸੂਚੀ ਢਾਂਚੇ ਨੂੰ ਨਹੀਂ ਬਦਲਦਾ।
3. ਕਿਉਂ ਨਹੀਂ b = null ਉਦਾਹਰਨ ਵਿੱਚ ਸੂਚੀ ਨੂੰ ਸੋਧੋ?
4. ਜਦੋਂ ਤੁਸੀਂ ਕਰਦੇ ਹੋ b = null, ਇਹ ਸਿਰਫ਼ ਲਈ ਹਵਾਲਾ ਬਦਲਦਾ ਹੈ b, ਨਾ next ਪੁਆਇੰਟਰ ਜੋ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਨੋਡਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ।
5. ਤੁਸੀਂ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਮਿਡਲ ਨੋਡ ਨੂੰ ਕਿਵੇਂ ਮਿਟਾਉਂਦੇ ਹੋ?
6. ਤੁਸੀਂ ਜਾਂ ਤਾਂ ਨੋਡ ਦੇ ਮੁੱਲ ਨੂੰ ਅਗਲੇ ਨੋਡ ਦੇ ਮੁੱਲ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ slow.val = slow.next.val ਅਤੇ ਅੱਪਡੇਟ ਕਰਕੇ ਅਗਲੇ ਨੋਡ ਨੂੰ ਛੱਡੋ next ਪੁਆਇੰਟਰ
7. ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਦੋ-ਪੁਆਇੰਟਰ ਤਕਨੀਕ ਕੀ ਹੈ?
8. ਇਹ ਇੱਕ ਆਮ ਪਹੁੰਚ ਹੈ ਜਿੱਥੇ ਇੱਕ ਪੁਆਇੰਟਰ (ਤੇਜ਼) ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਦੋ ਕਦਮ ਅੱਗੇ ਵਧਦਾ ਹੈ ਅਤੇ ਦੂਜਾ (ਹੌਲੀ) ਮੱਧ ਨੋਡ ਨੂੰ ਲੱਭਣ ਲਈ ਇੱਕ ਕਦਮ ਵਧਾਉਂਦਾ ਹੈ।
9. ਕਿਉਂ ਹੈ prev.next = slow.next ਨੋਡ ਮਿਟਾਉਣ ਵਿੱਚ ਕਮਾਂਡ ਜ਼ਰੂਰੀ ਹੈ?
10. ਇਹ ਕਮਾਂਡ ਪਿਛਲੇ ਨੋਡ ਦੇ ਪੁਆਇੰਟਰ ਨੂੰ ਮੱਧ ਨੋਡ 'ਤੇ ਛੱਡਣ ਲਈ ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ, ਇਸ ਨੂੰ ਸੂਚੀ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਮਿਟਾਉਂਦੀ ਹੈ।

ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚ ਨੋਡ ਮਿਟਾਉਣ ਬਾਰੇ ਅੰਤਿਮ ਵਿਚਾਰ

JavaScript ਵਿੱਚ ਲਿੰਕ ਕੀਤੀਆਂ ਸੂਚੀਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਅਕਸਰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਆਬਜੈਕਟ ਹਵਾਲੇ ਅਤੇ ਪੁਆਇੰਟਰ ਕਿਵੇਂ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੇ ਹਨ। ਬਸ ਇੱਕ ਨੋਡ ਨੂੰ null ਤੇ ਸੈਟ ਕਰਨ ਨਾਲ ਇਸਨੂੰ ਸੂਚੀ ਵਿੱਚੋਂ ਨਹੀਂ ਹਟਾਇਆ ਜਾਵੇਗਾ; ਤੁਹਾਨੂੰ ਨੋਡਾਂ ਨੂੰ ਮਿਟਾਉਣ ਲਈ ਪੁਆਇੰਟਰ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਅੱਪਡੇਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਮੱਧ ਨੋਡਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ.

ਹੌਲੀ ਅਤੇ ਤੇਜ਼ ਪੁਆਇੰਟਰ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਧਿਆਨ ਨਾਲ ਪੁਆਇੰਟਰ ਹੇਰਾਫੇਰੀ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਨੋਡ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਮਿਟਾ ਸਕਦੇ ਹੋ। ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਅਣਕਿਆਸੇ ਨਤੀਜਿਆਂ ਤੋਂ ਬਿਨਾਂ ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚ ਨੋਡ ਮਿਟਾਉਣ ਨੂੰ ਸੰਭਾਲ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਐਲਗੋਰਿਦਮਿਕ ਸਮੱਸਿਆ-ਹੱਲ ਕਰਨ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹੁਨਰ ਹੈ।