lists stl
Impara tutto sugli elenchi in STL insieme alla sua implementazione.
Gli elenchi sono contenitori sequenziali. Gli elenchi contengono elementi in posizioni non contigue. Abbiamo discusso di array e vettori nei nostri tutorial precedenti.
Nel caso dei contenitori array e vector, poiché questi contenitori immagazzinano dati in una memoria contigua, l'operazione di inserimento nel mezzo di questi contenitori si rivela molto costosa in quanto dobbiamo spostare di conseguenza gli elementi esistenti per fare spazio al nuovo elemento.
=> Vedi qui per esplorare l'elenco completo dei tutorial C ++.
cosa sono i metadati nel data warehousing
Cosa imparerai:
Panoramica
L'elenco è un contenitore che supera questo inconveniente dei contenitori di array e vettoriali. Ci consente di inserire elementi ovunque nell'elenco senza causare un sovraccarico. Ma le liste sono più lente dei vettori per quanto riguarda l'attraversamento.
In questo tutorial vedremo l'implementazione delle liste in STL insieme alle varie operazioni di attraversamento, manipolazioni e accesso alla lista con esempi.
Si noti che la maggior parte delle operazioni sulle liste sono simili a quelle dei vettori e quindi i lettori che hanno già letto il nostro tutorial sui vettori non avranno problemi ad interpretare i concetti delle liste.
Dichiarazione e inizializzazione
Per implementare il contenitore di elenchi e utilizzare tutti i suoi vantaggi, dobbiamo includere un file di intestazione nel nostro programma.
#include La dichiarazione generale per il contenitore di elenchi è
std::list listName; Per esempio,possiamo dichiarare una lista chiamata 'mylist' di tipo int come segue:
std::list mylist; Possiamo anche inizializzare la lista al momento della dichiarazione o aggiungervi elementi usando una delle operazioni che supporta.
Vediamo come possiamo inizializzare l'elenco che abbiamo creato sopra.
std::list mylist = {1, 1, 2, 3, 5}; L'inizializzazione di cui sopra sarà disposta in memoria come mostrato di seguito:
Una volta inizializzato l'elenco, possiamo accedere agli elementi di un elenco utilizzando un iteratore. Le funzioni Iterator 'inizio' e 'fine' ci aiutano a spostarci tra gli elementi della lista.
Nota: L'iteratore per l'elenco supporta anche altri iteratori come gli iteratori inversi (rbegin, rend), gli iteratori costanti (cbegin, cend) e gli iteratori inversi costanti (crbegin, crend) e possono essere usati in modo simile ai vettori.
L'esempio seguente mostra questo.
#include #include #include #include using namespace std; int main() { list mylist = {1, 1, 2, 3, 5}; cout<<”List elements are: “; list::iterator it; for(it=mylist.begin();it!=mylist.end();++it) cout<<*it<<” “; }Produzione:
Gli elementi dell'elenco sono: 1 1 2 3 5
Pertanto, nell'esempio precedente, abbiamo dichiarato un elenco della sequenza di Fibonacci. Successivamente, dichiariamo un iteratore dello stesso tipo di list e quindi, utilizzando il ciclo for, stampiamo il contenuto della lista dall'inizio alla fine.
Passiamo ora alle operazioni o alle funzioni fornite dal contenitore di elenchi in STL.
Operazioni su elenco
- Inserire: Utilizzato per inserire un elemento nella posizione data. Restituisce un iteratore che punta al primo elemento inserito.
inserire (pos, num_elem, elem)
Dove,
pos => Posizione in cui devono essere inseriti nuovi elementi.
num_elem => Numero di elementi da inserire; il valore predefinito è 1.
articolo => Valore effettivo da inserire.
Cerchiamo di capire la funzione di inserimento prendendo un esempio.
#include #include // for list operations using namespace std; int main() { list mylist = {1,1,2}; list::iterator it = mylist.begin(); // iterator to point to 4th position advance(it,` 3); // inserts 3 at 4th position mylist.insert(it, 3); cout << 'The list after inserting' << ' 1 element using insert() is : '; for (list::iterator i = mylist.begin();i != mylist.end();i++) cout << *i << ' '; cout << endl; }Produzione:
L'elenco dopo aver inserito 1 elemento utilizzando insert () è: 1 1 2 3
Questo è un esempio per inserire un solo elemento in 4thposizione nell'elenco che alla fine è l'ultima posizione. Quindi, in primo luogo, abbiamo una lista per la quale abbiamo definito l'iteratore che punta all'inizio della lista. Quindi spostiamo questo iteratore su 4thposition e quindi chiamare insert per inserire 1 elemento.
Possiamo anche inserire più di un elemento, specificando il secondo parametro nella funzione di inserimento. Ogni volta che non è specificato, il valore predefinito è 1.
- respingere :Aggiunge un nuovo elemento alla fine dell'elenco.
- push_front :Aggiunge un nuovo elemento all'inizio dell'elenco.
Vediamo un esempio che dimostra l'utilizzo delle funzioni push_back e push_front.
#include #include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3}; cout<<'List elements are: '; printlist(mylist); mylist.push_front(0); mylist.push_back(5); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produzione:
Gli elementi dell'elenco sono: 1 1 2 3
Elenca i contenuti dopo push_front e push_back: 0 1 1 2 3 5
In questo esempio, creiamo ed elenchiamo prima tutti i due elementi, uno in primo piano e uno in fondo utilizzando rispettivamente le funzioni push_front e push_back. L'output mostra l'elenco modificato dopo che entrambe le funzioni sono state eseguite.
- pop_back :Rimuove l'ultimo elemento nell'elenco riducendo così la dimensione dell'elenco di 1.
- pop_front :Rimuove il primo elemento nell'elenco riducendo così la dimensione dell'elenco di 1.
L'esempio seguente mostra l'utilizzo delle operazioni pop_back e pop_front dell'elenco.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); mylist.pop_front(); mylist.pop_back(); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produzione:
Gli elementi dell'elenco sono: 1 1 2 3 5
Elenca i contenuti dopo push_front e push_back: 1 2 3
Come descritto nella definizione delle operazioni, ciascuna delle operazioni pop_front e pop_back rimuove l'elemento dalla parte anteriore e posteriore dell'elenco, ovvero rispettivamente il primo e l'ultimo elemento dell'elenco e quindi ogni volta che riduce la dimensione dell'elenco di 1.
- taglia :Restituisce la dimensione dell'elenco, ovvero il numero di elementi nell'elenco.
- vuoto :Controlla se l'elenco è vuoto.
- cancellare :Rimuove un elemento o un intervallo di elementi dall'elenco.
- chiaro :Rimuove tutti gli elementi dall'elenco portandolo alla dimensione 0.
Di seguito è riportato un esempio per dimostrare l'utilizzo di tutte le funzioni di cui sopra, ovvero dimensione, vuoto, cancellazione e cancellazione.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'size of the list: '< Produzione:
Gli elementi dell'elenco sono: 1 1 2 3 5
dimensione della lista: 5
Elenco dopo la cancellazione del primo elemento: 1 2 3 5
Nuova dimensione dell'elenco: 4
dimensione della lista dopo la cancellazione: 0
Il programma di cui sopra mostra tutte e quattro le funzioni relative alla capacità della lista. Vediamo che la dimensione della lista diminuisce di 1 quando cancelliamo 1 elemento della lista. Mentre quando chiamiamo un'operazione chiara sulla lista, la dimensione è 0, il che significa che tutti gli elementi nell'elenco vengono rimossi.
- davanti :Restituisce il valore del primo elemento della lista.
- indietro :Restituisce il valore dell'ultimo elemento della lista.
- scambiare :Scambia il contenuto di un elenco con il contenuto di un altro elenco della stessa dimensione e tipo.
- inversione :Un algoritmo che inverte la lista.
- ordinare :Ordina l'elenco fornito.
L'esempio seguente mostra l'utilizzo delle funzioni front, back, reverse, sort e swap.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'
Front of the list: '< Produzione:
Gli elementi dell'elenco sono: 1 1 2 3 5
Prima della lista: 1
In fondo alla lista: 5
Elenco inverso: 5 3 2 1 1
qa domande e risposte dell'intervista del capo del test
Contenuto della lista dispari: 1 3 5 7 9
Dopo lo scambio
mia lista: 1 3 5 7 9
Lista strana: 5 3 2 1 1
In questo codice, per prima cosa stampiamo i valori anteriore e posteriore della lista mylist. Quindi questo elenco viene invertito e viene stampato l'elenco invertito. Successivamente, definiamo un altro elenco di numeri dispari che non è in alcun ordine e chiamiamo l'algoritmo 'Ordina' per ordinare questo elenco. Quindi scambiamo le due liste usando la funzione di scambio e stampiamo le liste scambiate.
- giunzione :Questa funzione viene utilizzata per trasferire il contenuto di un elenco in un altro elenco in una posizione specificata.
Entrambi gli elenchi devono essere dello stesso tipo.
giunzione (posizione, lista);
dove,
position => Posizione in cui trasferire il contenuto della lista.
list => Elenco i cui elementi devono essere trasferiti.
L'esempio riportato di seguito mostra l'utilizzo della funzione di giunzione.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 8,13}; cout<<'List elements are: '; printlist(mylist); list seclist = {2,3,5}; cout<<'list to be spliced: '; printlist(seclist); list:: iterator it = mylist.begin(); it ++; it++; mylist.splice(it,seclist); cout<<'
List contents after splicing at position 2: '; printlist(mylist); } Produzione:
Gli elementi dell'elenco sono: 1 1 8 13
lista da unire: 2 3 5
Elenco dei contenuti dopo la giunzione in posizione 2: 1 1 2 3 5 8 13
Il esempio mostra che usiamo due elenchi. Innanzitutto, l'iteratore per mylist viene spostato in due posizioni e quindi viene chiamata la funzione di giunzione per trasferire il contenuto della seconda lista alla terza posizione della prima lista.
- partire :A differenza della funzione di giunzione che può essere utilizzata per trasferire il contenuto di un elenco in un altro in una posizione specifica, l'operazione di unione unisce direttamente due elenchi per formare un unico elenco. Per l'operazione di unione, entrambi gli elenchi devono essere ordinati.
Di seguito è riportato un esempio per dimostrare la funzione di unione.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1,2,3,5,8}; list seclist = {4,6,7}; cout<<'First List: '; printlist(mylist); cout< Produzione:
Primo elenco: 11 2 3 5 8
Secondo elenco: 4 6 7
Contenuto dell'elenco dopo aver unito due elenchi:
1 1 2 3 4 5 6 7 8
Pertanto, nel programma precedente, abbiamo due elenchi ordinati. Chiamiamo operazione di unione su questi due elenchi. L'elenco risultante è un elenco ordinato contenente gli elementi di entrambi gli elenchi.
Conclusione
Siamo giunti alla fine di questo tutorial sugli elenchi in STL. Speriamo che questo tutorial ti abbia fornito un'immensa conoscenza delle liste in STL.
=> Controlla qui per vedere i tutorial di formazione dalla A alla Z di C ++ qui.
Lettura consigliata