ਬਿਨਾਂ ਸਿਰਲੇਖ ਦੇ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚੋਂ ਇਕ ਨੋਡ ਨੂੰ ਮਿਟਾਓ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ GE ਹੈਲਥਕੇਅਰ ਮੈਕ
ਲਿੰਕਡ-ਲਿਸਟ ਤਕਨੀਕੀ ਸਕ੍ਰਿਪਟਰ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਸਮੱਸਿਆ "ਸਿਰਲੇਖ ਦੇ ਬਗੈਰ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਨੋਡ ਮਿਟਾਓ" ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਕੁਝ ਨੋਡਾਂ ਨਾਲ ਜੁੜੀ ਸੂਚੀ ਹੈ. ਹੁਣ ਤੁਸੀਂ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਪਰ ਤੁਹਾਡੇ ਕੋਲ ਇਸਦਾ ਮੂਲ ਨੋਡ ਪਤਾ ਨਹੀਂ ਹੈ. ਇਸ ਲਈ ਇਸ ਨੋਡ ਨੂੰ ਮਿਟਾਓ.

ਉਦਾਹਰਨ

ਬਿਨਾਂ ਸਿਰਲੇਖ ਦੇ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚੋਂ ਇਕ ਨੋਡ ਨੂੰ ਮਿਟਾਓ

2->3->4->5->6->7
Node to be deleted: 4
2->3->5->6->7

ਵਿਆਖਿਆ: ਕਿਉਂਕਿ ਅਸੀਂ ਨੋਡ 4 ਨੂੰ ਵੈਲਯੂ ਨਾਲ ਮਿਟਾਉਣਾ ਚਾਹੁੰਦੇ ਸੀ. ਅਸੀਂ ਇਸਨੂੰ ਲਿੰਕਡ ਲਿਸਟ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਹੈ ਅਤੇ ਆਉਟਪੁੱਟ ਵਿਚ ਜ਼ਿਕਰ ਕੀਤੀ ਇਕ ਸੂਚੀ ਦੇ ਨਾਲ ਰਹਿ ਗਏ ਹਾਂ.

ਹੈਡ ਪੁਆਇੰਟਰ ਤੋਂ ਬਿਨਾਂ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣ ਲਈ ਪਹੁੰਚ

ਲਿੰਕਡ ਸੂਚੀ ਇਕ ਲਕੀਰ ਡਾਟਾ structureਾਂਚਾ ਹੈ ਜਿਸਦਾ ਇਕ ਐਰੇ ਉੱਤੇ ਬਹੁਤ ਵੱਡਾ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹ ਅਕਾਰ ਵਿਚ ਵੱਖੋ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚ ਇਕ ਐਲੀਮੈਂਟ ਸ਼ਾਮਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਨੂੰ ਓ (1) ਸਮੇਂ ਵਿਚ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ. ਇਹ ਵਿਚਾਰ ਕਰਦਿਆਂ ਕਿ ਤੁਸੀਂ ਤੱਤ ਪਹਿਲਾਂ ਸਥਾਨ 'ਤੇ ਪਾ ਰਹੇ ਹੋ. ਪਰ ਜੇ ਤੁਹਾਨੂੰ ਇਹ ਇਕ ਆਮ ਐਰੇ ਵਿਚ ਕਰਨਾ ਪੈਂਦਾ. ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਲਈ ਓ (ਐਨ) ਦਾ ਸਮਾਂ ਖਰਚ ਹੋਏਗਾ. ਇਸ ਤਰ੍ਹਾਂ ਅਸਲ-ਸੰਸਾਰ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਐਰੇ ਉੱਤੇ ਇੱਕ ਲਿੰਕਡ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਅਨੁਕੂਲ ਹੈ. ਅਤੇ ਲਿੰਕਡ ਸੂਚੀ ਇਸ ਸਭ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਲੈਂਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਡੇਟਾ ਨੂੰ ਇਕ ਸੰਗ੍ਰਿਹ ਸਮੂਹ ਦੇ ਤੌਰ ਤੇ ਨਹੀਂ ਸੰਭਾਲਦੀ. ਇਹ ਹਰੇਕ ਤੱਤ ਨੂੰ ਕੁਝ ਨਿਰਵਿਘਨ ਸਥਾਨ ਤੇ ਸਟੋਰ ਕਰਦਾ ਹੈ. ਪਰ ਫਿਰ ਇਹ ਵਿਵਸਥਾ ਕਿਵੇਂ ਬਣਾਈ ਰੱਖਦਾ ਹੈ? ਇਸ ਪ੍ਰਸ਼ਨ ਦਾ ਉੱਤਰ ਹੈ, ਜੁੜੀ ਹੋਈ ਸੂਚੀ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਲੈਂਦੀ ਹੈ. ਹਰ ਨੋਡ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚ ਇਕ ਹੋਰ ਨੋਡ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ wayੰਗ ਨਾਲ ਸਾਨੂੰ ਇਕੋ ਹਿੱਸਾ ਬਦਲਣ ਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਬਹੁਤ ਸਾਰੇ ਗਣਨਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ.

ਜੇ ਹੈਡ ਪੁਆਇੰਟਰ ਦਿੱਤਾ ਗਿਆ ਸੀ

ਹੁਣ ਸਮੱਸਿਆ ਸਾਨੂੰ ਪੁੱਛਦੀ ਹੈ ਇਕ ਨੋਡ ਮਿਟਾਓ. ਆਮ ਤੌਰ 'ਤੇ, ਸਾਨੂੰ ਇਕ ਨੋਡ ਦਾ ਪਤਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚ ਅਗਲੇ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ. ਪਰ ਇੱਥੇ ਸਾਨੂੰ ਇਕ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਲੋੜ ਹੈ ਜਿਸਦਾ ਪਤਾ ਸਾਨੂੰ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦਾ ਇਕ ਤਰੀਕਾ ਹੈ ਕਿ ਪਹਿਲਾਂ ਪੂਰੀ ਲਿੰਕਡ ਸੂਚੀ ਨੂੰ ਪਾਰ ਕਰਨਾ. ਫਿਰ ਹਰੇਕ ਨੋਡ ਦੇ ਮਾਪਿਆਂ ਨੂੰ ਸਟੋਰ ਕਰੋ ਅਤੇ ਲੂਪ ਨੂੰ ਤੋੜੋ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਨੋਡ ਤੇ ਹੁੰਦੇ ਹੋ ਜੋ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ ਅੰਤ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਨੋਡ ਦਾ ਮਾਪਾ ਮਿਟਾਉਣਾ ਹੈ. ਇਸ ਲਈ ਹੁਣ ਸਮੱਸਿਆ ਨੂੰ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚ ਇਕ ਨੋਡ ਦੇ ਸਧਾਰਣ ਹਟਾਉਣ ਵਿਚ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ ਜਿਸ ਦੇ ਮਾਪਿਆਂ ਦਾ ਪਤਾ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਪਰ ਅਜਿਹਾ ਕਰਨ ਨਾਲ ਸਾਡੇ ਲਈ ਓ (ਐਨ) ਓਪਰੇਸ਼ਨ ਖ਼ਰਚੇ ਪੈਣਗੇ. ਪਰ ਇਸ onlyੰਗ ਦੀ ਵਰਤੋਂ ਸਿਰਫ ਤਾਂ ਹੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਮੁੱਖ ਪੁਆਇੰਟਰ ਹੋਵੇ.

ਦਾ ਹੱਲ

ਸਮੱਸਿਆ ਲਈ ਪਹੁੰਚ "ਹੈਡ ਪੁਆਇੰਟਰ ਤੋਂ ਬਿਨਾਂ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਨੋਡ ਨੂੰ ਮਿਟਾਓ" ਇਹ ਹੈ ਕਿ ਮਿਟਾਏ ਜਾਣ ਵਾਲੇ ਨੋਡ ਦੇ ਡੇਟਾ ਅਤੇ ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਅਗਲਾ ਨੋਡ ਬਦਲਣਾ ਹੈ. ਲਿੰਕਡ ਸੂਚੀ ਵਿੱਚ ਹਰੇਕ ਨੋਡ ਸਟੋਰ ਕਰਦਾ ਹੈ ਜੋ ਨੋਡ ਅਗਲਾ ਹੁੰਦਾ ਹੈ. ਇਸ ਲਈ ਇਸ ਓਪਰੇਸ਼ਨ ਵਿਚ ਸਿਰਫ ਓ (1) ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਹੈ. ਹੁਣ ਜਦੋਂ ਡੇਟਾ ਬਦਲਿਆ ਜਾਏਗਾ. ਇਕ ਵਾਰ ਫਿਰ, ਅਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣ ਵਿਚ ਬਦਲ ਦਿੱਤਾ ਹੈ ਜਿਸ ਦੇ ਮਾਪਿਆਂ ਦਾ ਪਤਾ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਇਸ ਲਈ ਹੁਣ ਸਾਡੇ ਲਈ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਕਰਨਾ ਸੌਖਾ ਹੈ. ਪਰ ਇੱਥੇ ਇੱਕ ਕਿਨਾਰਾ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਸਾਨੂੰ ਅੰਤ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣਾ ਹੁੰਦਾ ਹੈ ਪਰ ਅਸੀਂ ਇਸਨੂੰ ਮਿਟਾਉਣ ਦੇ ਯੋਗ ਨਹੀਂ ਹੁੰਦੇ. ਕਿਉਂਕਿ ਇੱਥੇ ਕੋਈ ਅਗਲਾ ਨੋਡ ਨਹੀਂ ਹੈ.

ਕੋਡ

ਹੈਡ ਪੁਆਇੰਟਰ ਤੋਂ ਬਿਨਾਂ ਨੋਡ ਨੂੰ ਮਿਟਾਉਣ ਲਈ ਸੀ ++ ਕੋਡ

#include <bits/stdc++.h>
using namespace std;

struct node{
  int data;
  node* next;
};

node* create(int data){
  node* tmp = new node();
  tmp->data = data;
  tmp->next = NULL;
  return tmp;
}

void deletedNode(node* &head, node* toBeDeleted){
  if(toBeDeleted == NULL)
    return;
  else{
    if(toBeDeleted->next == NULL){
      cout<<"Last node can't be freed";
    }
    // store or swap but ( the data of current node will be deleted)
    toBeDeleted->data = toBeDeleted->next->data;
    toBeDeleted->next = toBeDeleted->next->next;
  }
}

int main(){
  // create a linked list
  node* head = new node();
  head = create(2);
  head->next = create(3);
  node* toBeDeleted = create(4);
  head->next->next = toBeDeleted;
  head->next->next->next = create(5);
  head->next->next->next->next = create(6);
  head->next->next->next->next->next = create(7);

  cout<<"Old Linked List: ";
  node* tmp = head;
  while(tmp!=NULL){
    cout<<tmp->data<<" ";
    tmp = tmp->next;
  }
  deletedNode(head, toBeDeleted);

  cout<<endl<<"New Linked List: ";
  tmp = head;
  while(tmp!=NULL){
    cout<<tmp->data<<" ";
    tmp = tmp->next;
  }
}
Old Linked List: 2 3 4 5 6 7
New Linked List: 2 3 5 6 7

ਹੈਡ ਪੁਆਇੰਟਰ ਤੋਂ ਬਿਨਾਂ ਨੋਡ ਮਿਟਾਉਣ ਲਈ ਜਾਵਾ ਕੋਡ

import java.util.*;
class node{
  int data;
  node next;
}
 
class Main{
  static node create(int data){
    node tmp = new node();
    tmp.data = data;
    tmp.next = null;
    return tmp;
  }
 
  static node deletedNode(node head, node toBeDeleted){
    if(toBeDeleted == null)
      return null;
    else{
      if(toBeDeleted.next == null){
        System.out.print("Last node can't be freed");
        return null;
      }
      // store or swap but ( the data of current node will be deleted)
      toBeDeleted.data = toBeDeleted.next.data;
      toBeDeleted.next = toBeDeleted.next.next;
      return head;
    }
  }
 
  public static void main(String[] args){
    // create a linked list
    node head = new node();
    head = create(2);
    head.next = create(3);
    node toBeDeleted = create(4);
    head.next.next = toBeDeleted;
    head.next.next.next = create(5);
    head.next.next.next.next = create(6);
    head.next.next.next.next.next = create(7);
 
    System.out.print("Old Linked List: ");
    node tmp = head;
    while(tmp != null){
      System.out.print(tmp.data+" ");
      tmp = tmp.next;
    }
    head = deletedNode(head, toBeDeleted);
 
    System.out.print("\n"+"New Linked List: ");
    tmp = head;
    while(tmp!=null){
      System.out.print(tmp.data+" ");
      tmp = tmp.next;
    }
  }
}
Old Linked List: 2 3 4 5 6 7 
New Linked List: 2 3 5 6 7

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (1), ਕਿਉਂਕਿ ਸਵੈਪਿੰਗ ਨਿਰੰਤਰ ਸਮੇਂ ਵਿੱਚ ਹੇਠਾਂ ਆ ਸਕਦੀ ਹੈ. ਅਤੇ ਫਿਰ ਅਸੀਂ ਸਿਰਫ ਕੁਝ ਪੁਆਇੰਟਰ ਬਦਲਦੇ ਹਾਂ ਜੋ ਦੁਬਾਰਾ ਨਿਰੰਤਰ ਸਮੇਂ ਦੀ ਕਿਰਿਆ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (1), ਕਿਉਂਕਿ ਵੇਰੀਏਬਲ ਜੋ ਅਸੀਂ ਵਰਤੇ ਹਨ ਲਿੰਕਡ ਸੂਚੀ ਵਿਚ ਨੋਡਾਂ ਦੀ ਗਿਣਤੀ ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦੇ. ਇਸ ਤਰ੍ਹਾਂ ਪੁਲਾੜ ਦੀ ਜਟਿਲਤਾ ਵੀ ਨਿਰੰਤਰ ਹੈ.