Forward_list Kontti tarjoaa toteutuksen yksin linkitetty luettelo tietorakenne. Se tallentaa tietoja ei-kohtauksellisessa muistissa, jossa kukin elementti osoittaa seuraavaan sekvenssin elementtiin. Tämä tekee insertoinnista ja poistoista nopeamman, kun elementin sijainti on tiedossa.

Syntaksi

Eteenpäin luettelo on määritelty std :: eteenpäin luokkamalli < Forward_list > otsikkotiedosto.

Forward_list fl;

jossa

• T: Tietotyyppi elementtejä eteenpäin.
• F: Etuluetteloon määritetty nimi.

Julistus ja alustaminen

Forward_list voidaan julistaa ja alustaa monin tavoin alla olevan esimerkin osoittamalla tavalla:

   #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  

Esimerkki: Yllä olevassa ohjelmassa olemme yksinkertaisia ​​alustettuna eteenpäin suuntautuva luettelo kolmella tavalla:

• Lausunto Forward_list FL1 luo tyhjän eteenpäin luettelon kokonaislukuista.
• Lausunto Forward_list FL2 (34) luo eteenpäin luettelon koosta 3 ja jokaisen elementin ollessa 4.
• Lausunto Forward_list fl3 = {1 5 3 4} luo eteenpäin -luettelon ja alustaa elementtien kanssa, jotka muodostavat alustusluettelon.

Perustoiminta

Tässä ovat perustoiminnot, jotka voimme suorittaa eteenpäin suuntautuvassa luettelossa:

Kello 1.

Eteenpäin suuntautuvan luettelon elementtejä ei voida käyttää indekseillä, kuten taulukoilla tai vektoreilla. Meidän on suoritettava luettelo peräkkäin alusta alkaen haluttuun asentoon käyttääksemme sitä. Tämä voidaan tehdä lisäämällä alkaa() iteraattori, mutta on parempi käyttää Seuraava () tai etukäteen () toiminto.

Kuitenkin luettelon ensimmäiseen elementtiin pääsee helposti edessä () menetelmä.

Esimerkki:

   #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 

Esimerkki: Yllä olevassa ohjelmassa ensimmäinen elementti tulostetaan käyttämällä edessä () menetelmä. Kolmannen elementin pääsy Seuraava () käytetään iteraattorin kahden asennon siirtämiseen alusta ja *se käytetään iteraattorin käytöstä.

2. Elementtien lisääminen

Elementit voidaan lisätä eteenpäin suuntautuvaan luetteloon käyttämällä insert_after () toiminto. Se vaatii iteraattorin, jonka jälkeen elementti asetetaan. Nopeaa asetusta edestä tukee kuitenkin push_front () menetelmä.

Esimerkki:

   #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  

Selitys: Tässä ohjelmassa eturintamassa asetetaan etuosaan ensimmäinen elementti push_front () toiminto. Sitten iteraattori luodaan ja siirretään yksi sijainti eteenpäin etukäteen () toiminto. Sen jälkeen elementti 5 asetetaan toisen elementin jälkeen käyttämällä insert_after () toiminto.

3. Elementtien päivittäminen

Nykyisten elementtien arvoa voidaan muuttaa yksinkertaisesti käyttämällä niitä ja käyttämällä toimeksiantaja uuden arvon määrittäminen.

Esimerkki:

   #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. Löydä elementti

Eteenpäin suuntautuva luettelo ei tarjoa mitään jäsentoimintoa elementin etsimiseksi, mutta voimme käyttää löytää() Algoritmi minkä tahansa arvon löytämiseksi.

Esimerkki -

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

Eteenpäin suuntautuva luettelo voidaan kulkea käyttämällä alkaa() ja loppu () iteraattorit, joilla on silmukka, mutta voimme vain siirtyä eteenpäin eikä taaksepäin.

Esimerkki:

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

Eteenpäin luettelossa voimme poistaa elementin tietyssä paikassa ERASE_AFTER () menetelmä. Tämä menetelmä vie iteraattorin yhteen sijaintiin ennen kohdeelementtiä. Nopea deleetio edestä on mahdollista käyttämällä pop_front () menetelmä.

Esimerkki:

   #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. eteenpäin suuntautuvan luettelon koko

Eteenpäin_listalla ei ole sisäänrakennettua kokoa (). Sen koon löytämiseksi meidän on laskettava elementit manuaalisesti kuljettamalla sitä silmukka tai käyttämällä STD :: Etäisyyttä.

   #include          #include         #include          using     namespace     std  ;   int     main  ()     {      forward_list   <  int  >     flist  =  {  10    20    30    40  };      //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. tyhjä ()

Sitä käytetään tarkistamaan, onko Forward_List on tyhjä.
Se palauttaa tosi, jos luettelo on tyhjä ja väärä muuten sallii nopeasti tarkistaa, jos säilöllä ei ole tietoja.

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

Ajan monimutkaisuus

Alla olevassa taulukossa luetellaan yllä olevien operaatioiden ajan monimutkaisuus eteenpäin suuntautuvassa luettelossa:

Eteenpäin luettelo vs. luettelo