Stampa Elenco collegato in C ++

Quando si tratta di archiviare elementi di dati dinamicamente, gli elenchi collegati sono simili a un array. Un array è una struttura di dati lineari che memorizza tutti gli elementi di dati, che ci consente di trasferire gli elementi dell'array in un funzionamento continuo. Mentre gli elementi di dati nell'elenco collegato non sono mantenuti in posizioni di memoria continua quando vengono archiviati. C'è il punto di partenza nell'elenco collegato che si chiama testa e il punto finale è chiamato coda dell'elenco collegato nel linguaggio di programmazione C ++. In un elenco collegato, ci sono nodi che archiviano oggetti dati in esso. Il nodo ha due parti: la parte contiene l'oggetto dati in sé e la seconda parte contiene il puntatore verso il nodo dopo di esso. Il nodo finale dell'elenco collegato contiene il puntatore null.

Stiamo usando un elenco collegato quando abbiamo un array per archiviare i dati perché negli array dobbiamo dire la lunghezza dell'array durante la dichiarazione dell'array. Ma nelle elenchi collegati il ​​dimensionamento non è più un problema. La durata dell'elenco collegato si espanderà come richiesto dal programma, ma l'elenco è limitato dalla capacità di memoria disponibile. L'elenco collegato può eseguire più operazioni in linguaggio C ++ che sono: inserimento, eliminazione, attraversamento, ricerca e operazioni di ordinamento. Per comprendere queste operazioni dell'elenco dei collegamenti, implementiamo l'esempio e comprendiamo come funziona un elenco collegato nel linguaggio di programmazione C ++. Esploriamo anche come queste operazioni funzionano nell'elenco collegato.

Esempio:

Iniziamo ora a sviluppare l'esempio di elenco collegato del linguaggio di programmazione C ++. Avvia il compilatore e inizia a scrivere il codice per mettere in pratica l'esempio. Dobbiamo includere il file di intestazione dopo aver eseguito il traduttore per renderlo semplice e facile accedere ai metodi, alle classi e ad altri componenti integrati che desideriamo includere nel programma di linguaggio di programmazione C ++.

#includere
#includere
Utilizzo dello spazio dei nomi std;

Il pacchetto "iostream" è il primo pacchetto fondamentale in C ++ e viene utilizzato da tutti i programmi perché consente agli utenti di fornire input e visualizzare l'output. L'intestazione della seconda libreria standard “stdlib.H "fornisce routine affidabili ed efficaci per l'allocazione della memoria dinamicamente ai programmatori C ++. Il segno "#" indica all'interprete di recuperare i pacchetti, seguito dalla parola chiave "incluso", dicendole di incorporare la libreria. Infine, il nome della biblioteca è scritto nei token "". L'ultima frase, "Utilizzare STD dello spazio dei nomi", è necessaria per fornire il contesto per il codice.

Inizializzazione della struttura

Successivamente, creeremo la struttura del nome "nodo" in modo da formare il nodo dell'elenco collegato. Dopo aver creato il nodo, dichiareremo le parti del nodo nella struttura. La prima parte del nodo è dove archiviamo gli elementi di dati. Quindi, abbiamo dichiarato una variabile di tipo intero "informazioni" per archiviare gli elementi di dati. La parte successiva è una variabile puntatore "followowode" che sposterà il puntatore verso il followode successivo nell'elenco collegato. I dettagli sono i seguenti:

nodo struct

Info int;
nodo struct* followode;
;

Inserimento di elementi di dati nell'elenco collegato

Abbiamo creato più funzioni in modo da poter inserire gli elementi di dati nell'elenco collegato che vogliamo creare in linguaggio di programmazione C ++.

funzione beg_insert ():

Abbiamo creato una funzione definita dall'utente nel linguaggio di programmazione C ++ che è la funzione beg_insert (). Come suggerisce il nome, useremo questa funzione per inserire i dati all'inizio dell'elenco collegato. La funzione beg_insert () prende due argomenti che sono "head_info" che è il puntatore al puntatore del capo dell'elenco collegato e il secondo argomento è "new_info" che è la data del nuovo follownode che deve essere inserito. Successivamente, la funzione ha creato un "CUR_NODE" di tipo "nodo" utilizzando la funzione Malloc (). Il "Cur Node" viene quindi inizializzato con il parametro "Nuovi informazioni" e il suo puntatore è impostato sulla testa dell'elenco connesso. Utilizzando il riferimento "Head Info", la testa dell'elenco collegato è inizialmente elencata nel "CUR Node".

void beg_insert (nodo struct ** head_info, int new_info)

nodo struct* cur_node = (nodo struct*) malloc (sizeof (nodo struct));
cur_node-> info = new_info;
CUR_NODE-> FOLOWNODE = (*head_info);
(*head_info) = cur_node;

funzione mid_insert ():

Ora, abbiamo creato un'altra funzione per inserire gli elementi di dati nel mezzo dell'elenco apprezzato che è la funzione Mid_insert (). Nella funzione mid (), dobbiamo prendere due argomenti che sono "pre_node" che è il puntatore del tipo "nodo" e "new_info" che è la variabile che memorizza i nuovi dati in sé di tipo intero. Abbiamo usato l'istruzione "if" per verificare la "pre_node se è nullo o meno nel corpo della funzione, abbiamo dichiarato un" cur_node "e memorizzato il" new_info ". Quindi abbiamo creato un puntatore "successivo" del "new_info" che indica il nodo successivo del "pre_node".

void mid_insert (nodo struct* pre_node, int new_info)

if (pre_node == null)

cout << "The Previous Node Can't be NULL";
ritorno;

nodo struct* cur_node = (nodo struct*) malloc (sizeof (nodo struct));
cur_node-> info = new_info;
CUR_NODE-> FOLLOWNODE = pre_node-> folowowode;
pre_node-> follownode = cur_node;

Funzione end_insert ():

Abbiamo creato questa funzione in modo da poter inserire gli elementi di dati alla fine dell'elenco collegato. Abbiamo dichiarato gli stessi argomenti che abbiamo dichiarato nella funzione beg_insert (). Questa funzione controlla prima se l'elenco è vuoto o no. Metti le "nuove informazioni" all'inizio dell'elenco e restituila se l'elenco era anche nullo. Se non è nullo, la procedura procederà attraverso l'elenco fino a quando non colpirà il nodo "ultimo nodo". La "nuova informazione" viene quindi aggiunta come nodo "ultimo nodo" alla fine dell'elenco.

void end_insert (nodo struct ** head_info, int new_info)

nodo struct* cur_node = (nodo struct*) malloc (sizeof (nodo struct));
nodo struct * last_node = * head_info;
cur_node-> info = new_info;
CUR_NODE-> FOLOWNODE = NULL;
if (*head_info == null)

*head_info = cur_node;
ritorno;

while (last_node-> followode != Null)

last_node = last_node-> follownode;
last_node-> follownode = cur_node;
ritorno;

Eliminare un nodo da un elenco collegato

Per rimuovere i nodi attuali dall'elenco collegato, ora abbiamo creato un nuovo metodo chiamato ELETE NODE (). Determina innanzitutto se il nodo capo stesso ha il new_key che deve essere cancellato. In tal caso, il riferimento alla testa al followode viene aggiornato. Usando un ciclo, individua il nodo che contiene il new_key da distruggere. Quando viene scoperto un nodo, il nodo "pre" aggiorna il puntatore followode del nodo che verrà distrutto in modo che possa essere eliminato senza essere visto. Infine, la funzione gratuita () viene utilizzata per rilasciare l'archiviazione.

void delete_node (nodo struct ** head_info, int new_key)

Struct Node *temp_var = *head_info, *pre;
if (temp_var != Null && temp_var-> info == new_key)

*head_info = temp_var-> follownode;
libero (temp_var);
ritorno;

while (temp_var != Null && temp_var-> info != new_key)

pre = temp_var;
temp_var = temp_var-> follownode;

if (temp_var == null)

ritorno;

pre-> follownode = temp_var-> followode;
libero (temp_var);

Cerca il nodo nell'elenco collegato

La Search di funzione () prende due argomenti, che sono il puntatore al "head_info" dell'elenco collegato e del "new_key" che deve essere cercato. La funzione attraversa l'elenco collegato e controlla se i dati del nodo corrente corrispondono al "new_key". Se i dati del nodo "corrente" corrispondono al "new_key", la funzione restituisce vera. Se i dati del nodo "corrente" non corrispondono al "new_key", la funzione si sposta su Follownede. Se il nodo "corrente" diventa nullo, la funzione restituisce falso.

BOOL RICERCA (NODE Struttura ** head_info, int new_key)

nodo struct * corrente = * head_info;
mentre (corrente != Null)

if (corrente-> info == new_key)

restituire vero;

corrente = corrente-> follownode;

restituire false;

Ordinamento dei componenti del nodo nell'elenco collegato

Nella programmazione C ++, il metodo Sort () viene utilizzato per organizzare i membri nell'elenco collegato in ordine crescente. Innanzitutto, è determinato se il riferimento a "head info" è nullo. In tal caso, torniamo. Successivamente, l'elenco viene ripetuto più volte fino alla terminazione del loop. Verificare se sono presenti ulteriori informazioni sul nodo "corrente", quindi sul nodo "indice" arriva dopo. In tal caso, scambiamo i dati tra i due nodi. Il nodo "indice" viene quindi trasferito al followode. La procedura viene quindi ripetuta fino al completamento dell'elenco.

void ordin (nodo struct ** head_info)

nodo struct *corrente = *head_info, *indice = null;
int temp_var;
if (head_info == null)

ritorno;

altro

mentre (corrente != Null)

indice = corrente-> follownode;
mentre (indice != Null)

if (corrente-> info> indice-> info)

temp_var = corrente-> info;
corrente-> info = indice-> info;
indice-> info = temp_var;

indice = indice-> follownode;

corrente = corrente-> follownode;

Visualizza il nodo nell'elenco collegato

La funzione Display () prende un puntatore alla testa dell'elenco collegato come parametro. Dopodiché, passa attraverso l'elenco e mostra le informazioni di ogni nodo. Quando arriva al completamento dell'elenco, si ferma.

void display (nodo struct* nodo)

mentre (nodo != Null)
G
cout << node->informazioni << " ";
nodo = nodo-> follownode;

Chiamare le funzioni nella funzione principale ()

Abbiamo scritto la funzione principale () in modo da poter iniziare a scrivere il codice del programma del driver nel corpo principale () corpo. Innanzitutto, il puntatore "head_val" viene inizializzato su NULL del tipo "nodo". Quindi, abbiamo chiamato le funzioni di inserimento che abbiamo creato a livello globale e abbiamo definito ogni funzione di inserisci e abbiamo superato il valore in esso. Per visualizzare l'elenco collegato nella finestra della console dell'utente, abbiamo chiamato una funzione Display () definita dall'utente. Chiama l'ordinamento () in modo che possiamo mettere i dati nell'elenco collegato. Per eliminare il nodo dall'elenco collegato, abbiamo chiamato la funzione delete_node () e abbiamo superato gli elementi di dati che vogliamo eliminare. Se vogliamo trovare qualsiasi elemento del nodo, abbiamo chiamato la funzione Search () e passato l'elemento in essa.

int main ()

Struct Node* head_val = null;
beg_insert (& head_val, 34);
beg_insert (& head_val, 10);
end_insert (& head_val, 48);
mid_insert (head_val-> follownode, 72);
cout << "*---Implementation of Linked List in C++---*" << endl;
cout << "\nThe Input Linked list is: ";
display (head_val);
sort (& head_val);
cout << "\n\nAfter Sorting the Input List: ";
display (head_val);
cout << "\nAfter deleting an element: ";
delete_node (& head_val, 48);
display (head_val);
beg_insert (& head_val, 63);
beg_insert (& head_val, 84);
end_insert (& head_val, 11);
mid_insert (head_val-> follownode, 100);
cout << "\n\nThe Updated Linked list is: ";
display (head_val);
sort (& head_val);
cout << "\nAfter Sorting the Input List: ";
display (head_val);
int fint_data;
cout << "\n\nEnter the element which you want to find? ";
cin >> find_data;
if (Search (& head_val, find_data))

cout << "The element " << find_data << " is found… ";

altro

cout << "The element " << find_data << " is not found… ";

Di seguito è mostrato il risultato del linguaggio di programmazione C ++ dello scenario dalla compilazione sopra.

Conclusione

L'elenco collegato nel linguaggio di programmazione C ++ e la distinzione tra un array e un elenco collegato sono stati entrambi trattati in questo articolo. Abbiamo parlato delle varie operazioni della lista collegata. Per prima cosa abbiamo costruito uno scenario di elenco collegato, quindi abbiamo costruito ogni operazione nell'illustrazione con una descrizione completa di ogni riga di codice C ++.