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_listfl;

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ā:

#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 

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.

vlc lejupielādēt youtube

Piemērs:

#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

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.

virkne c

Piemērs:

#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 

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:

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

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

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

mašīnrakstā foreach cilpa

Piemērs:

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

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

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

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ā:

Forward List vs List