Elenco_inoltro contenitore fornisce l'implementazione di elenco collegato singolarmente struttura dei dati. Memorizza i dati in una memoria non contigua in cui ciascun elemento punta all'elemento successivo nella sequenza. Ciò rende più veloce l'inserimento e la cancellazione una volta nota la posizione dell'elemento.

Sintassi

L'elenco di inoltro è definito come std::forward_list modello di classe all'interno del file< forward_list >file di intestazione.

forward_listfl;

Dove

• T: Tipo di dati degli elementi nell'elenco di inoltro.
• F: Nome assegnato all'elenco di inoltro.

Dichiarazione e inizializzazione

Una forward_list può essere dichiarata e inizializzata in diversi modi, come mostrato nell'esempio seguente:

#include    using namespace std; void printFL(forward_list<int>& fl) {  for (auto i : fl)  cout << i << ' ';  cout << 'n'; } int main() {    // Creating an empty forward_list  forward_list<int> fl1;  // Creating a forward_list with  // default value  forward_list<int> fl2(3 4);    // Creating a forward_list from an  // initializer list  forward_list<int> fl3 = {1 5 3 4};    printFL(fl2);  printFL(fl3);  return 0; } 

4 4 4 1 5 3 4 

Esempio: Nel programma sopra abbiamo una semplice lista di inoltro inizializzata in tre modi:

• Dichiarazione forward_list FL1 crea un elenco di inoltro vuoto di numeri interi.
• Dichiarazione forward_list fl2(34) crea un elenco in avanti di dimensione 3 e con ogni elemento pari a 4.
• Dichiarazione forward_list fl3 = {1 5 3 4} crea un elenco di inoltro e inizializza con gli elementi dell'elenco di inizializzatori.

Operazioni di base

Ecco le operazioni di base che possiamo eseguire su una lista di inoltro:

1. Accesso agli elementi

Non è possibile accedere agli elementi dell'elenco in avanti utilizzando indici come array o vettori. Dobbiamo scorrere l'elenco in sequenza dall'inizio alla posizione desiderata per accedervi. Questo può essere fatto incrementando inizio() iteratore ma è meglio usarlo Prossimo() O anticipo() funzione.

Tuttavia è possibile accedere facilmente al primo elemento dell'elenco tramite anteriore() metodo.

Esempio:

#include    using namespace std; int main() {  forward_list<int> fl = {1 5 3 4};  // Access the first element  cout << fl.front() << endl;    // Access third element  auto it = next(fl.begin() 2);  cout << *it;  return 0; } 

1 3

Esempio: Nel programma sopra riportato il primo elemento viene stampato utilizzando anteriore() metodo. Per accedere al terzo elemento Prossimo() viene utilizzato per spostare l'iteratore di due posizioni dall'inizio e *Esso viene utilizzato per dereferenziare l'iteratore.

2. Inserimento di elementi

Gli elementi possono essere inseriti nell'elenco in avanti utilizzando inserisci_dopo() funzione. Richiede l'iteratore dopo il quale inserire l'elemento. Tuttavia l'inserimento rapido nella parte anteriore è supportato da push_front() metodo.

Esempio:

#include    using namespace std; int main() {  forward_list<int> fl = {5 4};  // Inserting Element at front  fl.push_front(1);    // Insert 3 after the second element  auto it = fl.begin();  advance(it 1);  fl.insert_after(it 3);    for (auto x: fl) cout << x << ' ';  return 0; } 

1 5 3 4 

Spiegazione: In questo programma il primo elemento di forward_list viene inserito in primo piano utilizzando il push_front() funzione. Quindi viene creato un iteratore e spostato in avanti di una posizione utilizzando il comando anticipo() funzione. Dopodiché l'elemento 5 viene inserito dopo il secondo elemento utilizzando il inserisci_dopo() funzione.

3. Aggiornamento degli elementi

Il valore degli elementi esistenti può essere modificato semplicemente accedendovi e utilizzando operatore di assegnazione per assegnare il nuovo valore.

Esempio:

#include    using namespace std; int main() {  forward_list<int> fl = {1 5 3 4};  // Updating first element  fl.front() = 111;  cout << fl.front() << endl;    // Updating third element  auto it = next(fl.begin() 2);  *it = 333;  cout << *it;  return 0; } 

111 333

4. Trovare l'elemento

L'elenco di inoltro non fornisce alcuna funzione membro per cercare un elemento ma possiamo usare il file Trovare() algoritmo per trovare un dato valore.

cos'è il modulo in c++

Esempio :

#include    using namespace std; int main() {  forward_list<int> fl = {1 5 3 4};  // Finding 3  auto it = find(fl.begin() fl.end() 3);    if (it != fl.end()) cout << *it;  else cout << 'Element not Found';  return 0; } 

3

5. Attraversamento

È possibile attraversare un elenco di inoltro utilizzando inizio() E FINE() iteratori con un ciclo ma possiamo solo andare avanti e non indietro.

Esempio:

#include    using namespace std; int main() {  forward_list<int> fl = {1 5 3 4};    // Traversing using range-based for loop  for(auto i : fl)  cout << i << ' ';  cout << endl;    return 0; } 

1 5 3 4 

6. Eliminazione di elementi

Nell'elenco in avanti possiamo eliminare l'elemento nella posizione specificata utilizzando cancella_dopo() metodo. Questo metodo porta l'iteratore in una posizione prima dell'elemento di destinazione. È possibile utilizzare la cancellazione rapida dalla parte anteriore pop_front() metodo.

Esempio:

#include    using namespace std; int main() {  forward_list<int> fl = {1 5 3 4};  // Delete first element  fl.pop_front();    // Delete third element  auto it = fl.begin();  advance(it 1);  fl.erase_after(it);    for (auto x: fl) cout << x << ' ';  return 0; } 

5 3 

7. Dimensioni dell'elenco di inoltro

forward_list non ha una funzione size() incorporata. Per trovare la sua dimensione dobbiamo contare manualmente gli elementi attraversandolo con un loop o utilizzando std:: distance.

#include    #include  #include    using namespace std; int main() {  forward_list<int> flist={10203040};  //Calculate size by counting elements using std:: distance  int size=distance(flist.begin()flist.end());  cout<<'Size of forward_list: '<<size<<endl;  return 0; } 

Size of forward_list: 4 

8. vuoto()

Viene utilizzato per verificare se forward_list è vuoto.
Restituisce true se la lista è vuota e false altrimenti permette di verificare velocemente se il contenitore non ha dati.

#include    #include  using namespace std; int main() {  forward_list<int> flist;  if (flist.empty()) {  cout << 'The forward_list is empty.' << endl;  }  flist.push_front(10);  if (!flist.empty()) {  cout << 'The forward_list is not empty.' << endl;  }  return 0; } 

The forward_list is empty. The forward_list is not empty. 

Complessità temporale

La tabella seguente elenca la complessità temporale delle operazioni di cui sopra nell'elenco di inoltro:

Elenco inoltro vs Elenco