Forward_list Le conteneur fournit la mise en œuvre de liste chaînée unique structure des données. Il stocke les données dans une mémoire non contiguë où chaque élément pointe vers l'élément suivant de la séquence. Cela rend l'insertion et la suppression plus rapides une fois que la position de l'élément est connue.

Syntaxe

La liste de transfert est définie comme std :: forward_list modèle de classe à l'intérieur du< liste_avant > fichier d'en-tête.

liste_avantfl;

où

• T : Type de données des éléments dans la liste de transfert.
• F : Nom attribué à la liste de transfert.

Déclaration et initialisation

Une forward_list peut être déclarée et initialisée de plusieurs manières, comme le montre l'exemple ci-dessous :

#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 

Exemple: Dans le programme ci-dessus, nous sommes une simple liste de transfert initialisée de trois manières :

• Déclaration liste_avant FL1 crée une liste vide d'entiers.
• Déclaration liste_avant fl2(34) crée une liste avant de taille 3 et avec chaque élément étant 4.
• Déclaration liste_avant fl3 = {1 5 3 4} crée une liste de transfert et s'initialise avec les éléments de la liste d'initialisation.

Opérations de base

Voici les opérations de base que nous pouvons effectuer sur une liste de transfert :

1. Accéder aux éléments

Les éléments de la liste de transfert ne sont pas accessibles à l'aide d'index tels que des tableaux ou des vecteurs. Nous devons parcourir la liste séquentiellement depuis le début jusqu'à la position souhaitée pour y accéder. Cela peut être fait en incrémentant commencer() itérateur mais il vaut mieux utiliser suivant() ou avance() fonction.

Cependant, le premier élément de la liste est facilement accessible en devant() méthode.

Exemple:

#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

Exemple: Dans le programme ci-dessus, le premier élément est imprimé en utilisant devant() méthode. Pour accéder au troisième élément suivant() est utilisé pour déplacer l'itérateur de deux positions depuis le début et *il est utilisé pour déréférencer l’itérateur.

2. Insertion d'éléments

Les éléments peuvent être insérés dans la liste de transfert en utilisant insert_after() fonction. Il nécessite l'itérateur après lequel l'élément doit être inséré. Cependant, l'insertion rapide à l'avant est prise en charge par push_front() méthode.

Exemple:

#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 

Explication: Dans ce programme, le premier élément de forward_list est inséré au début à l'aide du push_front() fonction. Ensuite, un itérateur est créé et avancé d'une position à l'aide de la commande avance() fonction. Après cela, l'élément 5 est inséré après le deuxième élément à l'aide de la insert_after() fonction.

3. Mise à jour des éléments

La valeur des éléments existants peut être modifiée simplement en y accédant et en utilisant opérateur d'affectation pour attribuer la nouvelle valeur.

Exemple:

#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. Trouver un élément

La liste de transfert ne fournit aucune fonction membre pour rechercher un élément mais nous pouvons utiliser le trouver() algorithme pour trouver une valeur donnée.

Exemple :

#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. Traversée

Une liste de transfert peut être parcourue en utilisant commencer() et fin() itérateurs avec une boucle mais nous ne pouvons qu'avancer et non reculer.

Exemple:

#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. Suppression d'éléments

Dans la liste avant, nous pouvons supprimer l'élément à la position donnée en utilisant effacer_après() méthode. Cette méthode amène l’itérateur à une position avant l’élément cible. Une suppression rapide depuis le recto est possible en utilisant pop_front() méthode.

Exemple:

#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. Taille de la liste de transfert

forward_list n'a pas de fonction size() intégrée. Pour trouver sa taille, nous devons compter manuellement les éléments en les parcourant avec une boucle ou en utilisant 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. vide()

Il est utilisé pour vérifier si la forward_list est vide.
Il renvoie vrai si la liste est vide et faux sinon permettant de vérifier rapidement si le conteneur ne contient pas de données.

#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. 

Complexité temporelle

Le tableau ci-dessous répertorie la complexité temporelle des opérations ci-dessus sur la liste de transfert :

système d'exploitation réseau

Liste de transfert vs liste