Come eliminare un nodo in un elenco collegato C ++

Un elenco collegato è fondamentalmente una combinazione di due cose: la parte delle informazioni e la parte dell'indirizzo. La parte dell'indirizzo, chiamata anche puntatore o collegamento nodo successivo, memorizza l'indirizzo del nodo successivo. L'elenco collegato è fondamentalmente una struttura di dati lineari che memorizza i dati in modo dinamico attraverso puntatori a cui è possibile accedere facilmente dal puntatore del nodo precedente.

Il nodo dell'elenco collegato sembra questo:

Rispetto all'array, l'elenco collegato non è una struttura di dati sequenziali perché è una struttura dati memorizzata dinamicamente. Memorizza tutti i dati in diverse posizioni di memoria e possiamo accedere a questi dati tramite il puntatore del nodo che memorizza l'indirizzo dei dati.

Questo modo di archiviare i dati ha questi vantaggi:

1. Non abbiamo una dimensione della memoria predefinita come un array, che porta a molti rifiuti di memoria.

2. In un array, se definiamo una memoria di tempo, non possiamo diminuirla o aumentarla in base alle nostre esigenze. Ma in un elenco collegato, possiamo aumentare o ridurre i nodi in base ai nostri requisiti.

L'elenco collegato è simile a questo:

Ogni elenco collegato ha un nodo di intestazione che è il primo nodo dell'elenco collegato; e un nodo di coda che è presente alla fine dell'elenco collegato. Dal nodo di coda, l'elenco collegato che punta al nodo successivo è finito perché memorizza l'indirizzo null, il che non significa nulla. Se un elenco collegato ha un solo nodo, significa che il nodo di intestazione e il nodo di coda sono gli stessi.

Eliminazione di un elenco collegato:

Come indicato di seguito, possiamo eliminare un nodo da un elenco collegato in tre modi:

1. Elimina il primo nodo dell'elenco collegato

2. Elimina l'ultimo nodo dell'elenco collegato

3. Elimina un nodo di posizione specifico

Spiegazione di tutti questi concetti:

Elimina il primo nodo dell'elenco collegato (il nodo di intestazione):-

Per eliminare il primo nodo dall'elenco collegato significa eliminare il nodo di intestazione (primo nodo) dell'elenco collegato. Per fare ciò, dobbiamo seguire la seguente procedura:

UN. Dobbiamo creare un puntatore (temporaneo).

B. L'indirizzo del nodo di intestazione viene copiato sul puntatore (temporaneo).

C. Ora abbiamo memorizzato l'indirizzo del nodo di intestazione. Quindi, possiamo dichiarare il nodo successivo dell'intestazione come primo nodo elenco collegato.

Eliminare il primo nodo significa che il nodo di intestazione è semplice:

Codice C ++ per eliminare il primo nodo dall'elenco collegato:

void deleteLinkEdListFirstNode ()

nodo *temporarynode = nuovo nodo;
temporarynode = headnode;
headNode = headNode-> Next;
Elimina temporarynode;

Eliminazione dell'ultimo nodo (nodo di coda):

L'eliminazione del nodo di intestazione dell'elenco collegato era semplice. Ma quando volevamo eliminare l'ultimo nodo o il nodo di coda dell'elenco collegato, dobbiamo trasferire il puntatore nullo dal nodo di coda al nodo precedente della coda, che ha l'indirizzo del nodo di coda.

Per implementare questo, dobbiamo usare due nodi temporanei ed eseguire attraverso l'elenco collegato. Quando l'elenco collegato di attraversamento è finito, il nodo temporaneo punterà al nodo corrente e un altro nodo temporaneo punterà al nodo precedente. Ora entrambi i nodi richiesti affrontano i dettagli che abbiamo e possiamo eliminare il nodo di coda mentre si sposta il puntatore null sul nodo precedente.

Codice C ++ per eliminare l'ultimo nodo dall'elenco collegato:

void deleteLinkEdListLastNode ()

nodo *currentNode = nuovo nodo;
nodo *precedenteNode = nuovo nodo;
currentNode = headnode;
while (currentNode-> Next!= Null)

PrecedenteNode = CurrentNode;
Current = CurrentNode-> Next;

Tail = precedente Node;
PrecedenteNode-> Next = null;
Elimina CurrentNode;

Eliminazione del nodo in posizione specifica:

Per eliminare un nodo da qualsiasi parte dell'elenco collegato, dobbiamo inserire la posizione particolare del nodo che vogliamo eliminare. Per definire il nodo di posizione specifico, utilizziamo due nodi temporanei, come abbiamo fatto durante l'eliminazione del nodo di coda. Attraggiamo l'intero elenco collegato fino a quando non otteniamo il nodo di posizione specifico che vogliamo eliminare e dopo aver ottenuto quel nodo, l'altro nodo temporaneo terrà l'indirizzo del nodo precedente del nodo corrente. Ora, poiché abbiamo entrambi i dettagli del nodo, possiamo facilmente spostare l'indirizzo dal nodo di eliminazione al nodo dell'indirizzo precedente, che ora punterà al nodo successivo, proprio come nel precedente metodo eliminato dell'ultimo nodo.

Codice C ++ per eliminare il nodo nth dall'elenco collegato:

void delethenthpositionNode (int positionNumber)
nodo *currentNode = nuovo nodo;
nodo *precedenteNode = nuovo nodo;
currentNode = headnode;
per (int count = 1; iPrecedenteNode = CurrentNode;
CurrentNode = CurrentNode-> Next;

PrecedenteNode-> Next = CurrentNode-> Next;

Programma C ++ per eliminare un nth nodo dall'elenco collegato

#includere
Utilizzo dello spazio dei nomi std;
Classe LinkedListNode
pubblico:
Info int;
puntatore LinkedListNode *;
;
int longCalCulate (nodo LinkedListNode*)
int count = 0;
mentre (nodo!= Null)
nodo = nodo-> puntatore;
conta ++;

Conteggio di ritorno;

void insert (LinkedListNode ** HeadNode, int info)
LinkedListNode* newNode = new LinkedListNode ();
newnode-> info = info;
newnode-> puntatore = *headnode;
*headnode = newnode;

void deleteNodeMethod (int count, LinkedListNode ** HeadNode)
LinkedListNode * temporaryNode = * headNode;
LinkedListNode* PrecedentiNode;
int lunghezza = lunghezzaCalculate (*headnode);
Se (conta < 1 || count > lunghezza)
cout << "Deletion of linked list node is not valid" << endl;
ritorno;

// Questo fucnzione eliminerà il primo nodo dell'elenco collegato
if (count == 1)
*headnode = (*headnode)-> puntatore;
cout << temporaryNode->informazioni << " deleted the linked first node" << endl;
delete (temporarynode);
ritorno;

// Questo Loop while si fermerà quando viene raggiunto al
// Fine dell'elenco collegato
while (--count)
PrecedenteNode = temporaryNode;
temporarynode = temporarynode-> puntatore;

// Questa riga aggiornerà il puntatore di Norme precedente
// con il puntatore del nodo nth Linked Elenco
PrecedenteNode-> puntatore = temporarynode-> puntatore;
// Questo codice eliminerà il nodo nth dall'elenco collegato
cout << temporaryNode->informazioni << " deleted" << endl;;
delete (temporarynode);

void DisplayLinkEdList (LinkedListNode* Item)
cout << "\nDisplaying LinkedList => : ";
// Questa condizione si fermerà quando Linkedlist raggiunto alla fine
mentre (articolo!= Null)
cout << item->informazioni << " ";
Item = Item-> puntatore;

cout << endl;

int main ()
LinkedListNode* headNode = null;
Insert (& HeadNode, 29);
Insert (& HeadNode, 34);
Insert (& HeadNode, 23);
Insert (& Headnode, 27);
Insert (& HeadNode, 31);
Insert (& HeadNode, 50);
DisplayLinkEdList (headnode);
cout << "\n Deleting node number 3 = ";
deleteNodeMethod (3, & headnode);
cout << "\n After delete node number 3, linked list will be =";
DisplayLinkEdList (headnode);
cout << "\n Deleting node number 5 = ";
deleteNodeMethod (5, & headnode);
cout << "\n After delete node number 5, linked list will be =";
DisplayLinkEdList (headnode);
restituzione 0;

Produzione:

Visualizzazione di LinkedList =>: 50 31 27 23 34 29
Eliminazione del nodo numero 3 = 27 eliminato
Dopo la cancellazione del nodo numero 3, l'elenco collegato sarà =
Visualizzazione di LinkedList =>: 50 31 23 34 29
Eliminazione del nodo numero 5 = 29 Eliminata
Dopo la cancellazione del nodo numero 5, l'elenco collegato sarà =
Visualizzazione di LinkedList =>: 50 31 23 34

Conclusione:

In questo blog, abbiamo studiato diversi modi per eliminare i concetti dell'elenco collegato e come possiamo codificare anche in un programma C ++. Infine, abbiamo studiato i principali concetti di eliminazione del nodo da una particolare posizione. I concetti di elenco collegati sono sempre importanti perché questo è il modo di giocare con la memoria del sistema operativo e ha molti vantaggi rispetto all'array.