FORWARD SARAKSTS C ++ STL

Forward_list konteiners nodrošina ieviešanu atsevišķi saistītais saraksts datu struktūra. Tas glabā datus bez pakārtotās atmiņas, kur katrs elements norāda uz nākamo elementu secībā. Tas padara ievietošanu un dzēšanu ātrāk, tiklīdz ir zināma elementa pozīcija.

Sintakse

Forward saraksts tiek definēts kā std :: uz priekšu_list klases veidne < Forward_list > Galvenes fails.

Forward_list fl;

kur

T: Datu tipa elementi uz priekšu sarakstā.
F: Vārds, kas piešķirts uz priekšu sarakstam.

Deklarācija un inicializācija

Forward_List var deklarēt un inicializēt vairākos veidos, kā parādīts zemāk redzamajā piemērā:

C++

    #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  ;   }

Izvade

4 4 4 1 5 3 4

Piemērs: Iepriekš minētajā programmā mēs esam vienkārši inicializēti uz priekšu sarakstā trīs veidos:

Paziņojums Forward_list fl1 Izveido tukšu uz priekšu skaitu skaitu skaitu.
Paziņojums Forward_list fl2 (34) Izveido priekšējo 3. izmēra sarakstu un ar katru elementu ir 4.
Paziņojums Forward_list fl3 = {1 5 3 4} Izveido uz priekšu sarakstu un inicializē ar elementiem, kas veido inicializatoru sarakstu.

Pamata operācijas

Šeit ir pamata operācijas, kuras mēs varam veikt uz priekšu sarakstā:

1. Piekļuve elementiem

Forward List elementiem nevar piekļūt, izmantojot tādus indeksus kā masīvi vai vektori. Lai piekļūtu tam, mums ir jāiet cauri sarakstam secīgi no sākuma līdz vēlamajai pozīcijai. To var izdarīt, palielinot sākt () iterator, bet labāk ir izmantot Nākamais () vai Advance () funkcija.

Tomēr saraksta pirmais elements var viegli piekļūt priekšā () metode.

Piemērs:

C++

    #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  ;   }

Izvade

1 3

Piemērs: Iepriekš minētajā programmā pirmais elements tiek izdrukāts, izmantojot priekšā () metode. Lai piekļūtu trešajam elementam Nākamais () tiek izmantots, lai pārvietotu iteratoru divas pozīcijas no paša sākuma un *tas tiek izmantots iteratora atcelšanai.

2. Elementu ievietošana

Elementus var ievietot priekšējā sarakstā, izmantojot INSERT_AFTER () funkcija. Tas prasa iteratoru, pēc kura elements ir jāievieto. Tomēr ātru ievietošanu priekšpusē atbalsta Push_front () metode.

Piemērs:

C++

    #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  ;   }

Izvade

1 5 3 4

Paskaidrojums: Šajā programmā priekšpusē tiek ievietots pirmais elements Forward_List, izmantojot Push_front () funkcija. Tad tiek izveidots iterators un pārvieto vienu pozīciju uz priekšu, izmantojot Advance () funkcija. Pēc tam elements 5 tiek ievietots pēc otrā elementa, izmantojot INSERT_AFTER () funkcija.

3. Elementu atjaunināšana

Esošo elementu vērtību var mainīt, vienkārši piekļūstot tiem un izmantojot norīkošanas operators piešķirt jauno vērtību.

Piemērs:

C++

    #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  ;   }

Izvade

111 333

4. Atrodot elementu

Forward saraksts nenodrošina nevienu dalībnieka funkciju, lai meklētu elementu, bet mēs varam izmantot Atrast () algoritms, lai atrastu noteiktu vērtību.

Piemērs :

C++

    #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  ;   }

Izvade

5. Pārejot

Pārvēršanas sarakstu var šķērsot, izmantojot sākt () un beigas () iteratori ar cilpu, bet mēs varam virzīties tikai uz priekšu un nevis atpakaļ.

Piemērs:

C++

    #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  ;   }

Izvade

1 5 3 4

6. Elementu dzēšana

Pārsūtīšanas sarakstā mēs varam izdzēst elementu noteiktā pozīcijā, izmantojot Erase_After () metode. Šī metode ieņem iteratoru vienā pozīcijā pirms mērķa elementa. Ātra dzēšana no priekšpuses ir iespējama, izmantojot pop_front () metode.

Piemērs:

C++

    #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  ;   }

Izvade

5 3

7. Forward List lielums

Forward_List nav iebūvētas lieluma () funkcijas. Lai atrastu tā lielumu, mums manuāli jāsaskaita elementi, to šķērsojot ar cilpu vai izmantojot std :: attālumu.

C++

    #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  ;   }

Izvade

Size of forward_list: 4

8. tukšs ()

To izmanto, lai pārbaudītu, vai Forward_List ir tukšs.
Tas atgriežas taisnība, ja saraksts ir tukšs un nepatiess, pretējā gadījumā ļauj ātri pārbaudīt, vai konteineram nav datu.

C++

    #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  ;   }

Izvade

The forward_list is empty. The forward_list is not empty.

Laika sarežģītība

Zemāk esošajā tabulā ir uzskaitīta iepriekšminēto operāciju laika sarežģītība uz priekšu sarakstā:

Darbība	Laika sarežģītība
Piekļūstiet pirmajam elementam	O (1)
Piekļuve n ^th elements	O (n)
Ievietojiet priekšā	O (1)
Ievietojiet pēc noteiktas pozīcijas	O (n)
Dzēst pirmo elementu	O (1)
Dzēst pēc noteiktas pozīcijas	O (n)
Šķērsot	O (n)

Forward List vs List

Iezīmēt	Forward_list	saraksts
Saistītā saraksta tips	Atsevišķi saistītais saraksts	Divreiz saistītais saraksts
Šķērsot	Var tikai šķērsot uz priekšu	Var šķērsot gan uz priekšu, gan atpakaļ
Atmiņas lietojums	Izmanto mazāku atmiņu (tikai viens rādītājs uz mezglu)	Izmanto vairāk atmiņas (divas norādes vienā mezglā)
Ievietošana/dzēšana	Ātra ievietošana un dzēšana, bet tikai noteiktā pozīcijā vai pēc tās	Ātra ievietošana un dzēšana jebkur (pirms vai pēc pozīcijas)
Atbalstītas funkcijas	Ierobežots salīdzinājumā ar sarakstu (nav lieluma () nav apgrieztu iteratoru)	Pilnīgāks interfeiss, ieskaitot lieluma () reverse () divvirzienu iteratorus.