હેડ પોઇન્ટર વિના લિંક્ડ સૂચિમાંથી નોડ કા Deleteી નાખો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે જીઇ હેલ્થકેર MAQ
લિંક્ડ-સૂચિ તકનીકી સ્ક્રીપ્ટર

સમસ્યા નિવેદન

સમસ્યા "હેડ પોઇંટર વિના લિંક્ડ સૂચિમાંથી નોડ કા Deleteી નાખો" કહે છે કે તમારી પાસે કેટલાક ગાંઠો સાથે લિંક્ડ સૂચિ છે. હવે તમે નોડ કા deleteી નાખવા માંગો છો પરંતુ તમારી પાસે તેનો પેરેંટ નોડ સરનામું નથી. તેથી આ નોડ કા deleteી નાખો.

ઉદાહરણ

હેડ પોઇન્ટર વિના લિંક્ડ સૂચિમાંથી નોડ કા Deleteી નાખો

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

સમજૂતી: કારણ કે અમે નોડને value મૂલ્ય સાથે કા deleteી નાખવા માંગતા હતા, અમે તેને કડી થયેલ સૂચિમાંથી કા removedી નાખ્યું છે અને આઉટપુટમાં ઉલ્લેખિત સૂચિ સાથે બાકી છે.

હેડ પોઇન્ટર વિના નોડને કા deleteી નાખવા માટેનો અભિગમ

લિંક્ડ સૂચિ એ રેખીય ડેટા સ્ટ્રક્ચર છે જેનો એરે પર મોટો ફાયદો છે તે તે કદમાં બદલાઈ શકે છે. જો તમે કડી થયેલ સૂચિમાં તત્વ ઉમેરવા માંગતા હો, તો તમે તેને ઓ (1) સમયમાં ઉમેરી શકો છો. તમે પ્રથમ સ્થાને તત્વ શામેલ કરી રહ્યાં છો તે ધ્યાનમાં લેતા. પરંતુ જો તમારે સામાન્ય એરેમાં પણ આવું કરવું હતું. તે કરવા માટે તમારા (ઓ) સમયનો ખર્ચ થશે. આમ, વાસ્તવિક દુનિયાની એપ્લિકેશન્સમાં એરે ઉપર લિંક્ડ સૂચિનો ઉપયોગ કરવાનું અનુકૂળ છે. અને લિંક્ડ સૂચિ આ બધું પ્રાપ્ત કરે છે કારણ કે તે ડેટાને એક વિશિષ્ટ ભાગ તરીકે સંગ્રહિત કરતી નથી. તે દરેક તત્વને કેટલાક રેન્ડમ સ્થાન પર સંગ્રહિત કરે છે. પરંતુ તે પછી તે કેવી રીતે વ્યવસ્થા જાળવે છે? આ પ્રશ્નનો જવાબ છે, કડી થયેલ સૂચિ નિર્દેશકનો ઉપયોગ કરે છે. દરેક નોડ લિંક્ડ સૂચિમાં બીજા નોડ તરફ નિર્દેશ કરે છે અને આ રીતે આપણે એક જ ભાગને બદલીને ફાળવવાની જરૂર નથી, જેના બદલામાં ઘણાં કમ્પ્યુટેશન્સની જરૂર પડે.

જો હેડ પોઇન્ટર આપવામાં આવ્યું હતું

હવે સમસ્યા અમને પૂછે છે નોડ કા deleteી નાખો. સામાન્ય રીતે, અમને નોડનું સરનામું આપવામાં આવે છે અને કડી થયેલ સૂચિમાં આગળના નોડને કા deleteી નાખવા જરૂરી છે. પરંતુ અહીં અમારે એક નોડ કા deleteી નાખવાની જરૂર છે જેનું સરનામું અમને આપવામાં આવ્યું છે. આ સમસ્યાને હલ કરવાનો એક રસ્તો એ છે કે પહેલાં આખી કડી થયેલ સૂચિને આગળ કા .ો. પછી દરેક નોડના પેરેંટને સ્ટોર કરો અને જ્યારે તમે ઇનપુટ તરીકે પૂરા પાડવામાં આવતા નોડ પર હો ત્યારે લૂપને તોડી નાખો. આ રીતે અંતમાં આપણી પાસે કાodeી નાખવા માટે નોડનો પેરેંટ છે. તેથી હવે સમસ્યા જેની માતાપિતાનું સરનામું આપવામાં આવ્યું છે તે લિંક કરેલી સૂચિમાં નોડના સરળ કાtionી નાખવા માટે બદલાઈ ગઈ છે. પરંતુ આ કરવાથી અમને ઓ (એન) ની કામગીરીનો ખર્ચ થશે. પરંતુ આ રીતે ફક્ત ત્યારે જ વાપરી શકાય છે જ્યારે તમારી પાસે હેડ પોઇન્ટર હોય.

ઉકેલ

સમસ્યા માટેનો અભિગમ "હેડ પોઇંટર વિના લિંક્ડ સૂચિમાંથી નોડ કા Deleteી નાખો" એ કા deletedી નાખવા માટે નોડના ડેટા અને કડી થયેલ સૂચિમાં આગળના નોડને અદલાબદલ કરવાનો છે. કડી થયેલ સૂચિ સ્ટોરનો દરેક નોડ આગળનો નોડ છે. તેથી આ કામગીરીમાં ફક્ત ઓ (1) સમય જટિલતા છે. હવે જ્યારે ડેટા અદલાબદલ થઈ ગયો છે. ફરી એકવાર, અમે નોડને કાtionી નાખવા માટે સમસ્યા બદલી છે જેના માતાપિતાનું સરનામું આપવામાં આવ્યું છે. તેથી હવે સમસ્યા હલ કરવી અમારા માટે સરળ છે. પરંતુ ત્યાં એક કિનારીનો કેસ છે જ્યારે આપણે અંત નોડ કા deleteી નાખવાના હોય છે પરંતુ અમે તેને કા toી શકીશું નહીં. કારણ કે ત્યાં આગળનો નોડ નથી.

કોડ

હેડ પોઇન્ટર વિના નોડને કા deleteી નાખવા માટે સી ++ કોડ

#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

હેડ પોઇન્ટર વિના નોડ કા deleteવા માટે જાવા કોડ

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), કારણ કે આપણે જે ચલોનો ઉપયોગ કર્યો છે તે લિંક્ડ સૂચિમાં ગાંઠોની સંખ્યા પર આધારિત નથી. આમ જગ્યા જટિલતા પણ સતત છે.