lists stl
Bli kjent med alt om lister i STL sammen med implementeringen.
Lister er sekvensielle beholdere. Lister inneholder elementer på ikke sammenhengende steder. Vi har diskutert matriser og vektorer i våre tidligere opplæringsprogrammer.
Når det gjelder matrise- og vektorbeholdere, da disse beholderne lagrer data i sammenhengende minne, viser innsettingsoperasjon midt i disse beholderne seg å være veldig kostbart, ettersom vi må skifte de eksisterende elementene tilsvarende for å gi plass til det nye elementet.
=> Se her for å utforske den komplette C ++ opplæringslisten.
c ++ regex-matcheksempel
Hva du vil lære:
Oversikt
Listen er en container som overvinner denne ulempen med array- og vektorcontainere. Det lar oss sette inn elementer hvor som helst i listen uten å forårsake mye overhead. Men lister er tregere enn vektorer når det gjelder traversering.
I denne opplæringen vil vi se implementeringen av lister i STL sammen med de forskjellige operasjonene av traversal, manipulering og tilgang til listen med eksempler.
Vær oppmerksom på at et flertall av listeoperasjonene ligner på vektorene, og lesere som allerede har lest veiledningen vår om vektorer, vil derfor ikke ha problemer med å tolke konsepter.
Erklæring og initialisering
For å implementere listebeholder og bruke alle fordelene, må vi inkludere en topptekstfil i programmet vårt.
#include Den generelle erklæringen for listebeholder er
std::list listName; For eksempel,Vi kan erklære en liste med navnet 'min liste' av typen int på følgende måte:
std::list mylist; Vi kan også initialisere listen på erklæringstidspunktet eller legge til elementer i den ved hjelp av en av operasjonene den støtter.
La oss se hvordan vi kan initialisere listen vi opprettet ovenfor.
std::list mylist = {1, 1, 2, 3, 5}; Ovennevnte initialisering vil bli lagt ut i minnet som vist nedenfor:
Når vi har initialisert listen, kan vi få tilgang til elementene i en liste ved hjelp av en iterator. Iteratorfunksjonene 'begynn' og 'slutt' hjelper oss å krysse gjennom listeelementene.
Merk: Iterator for listen støtter også andre iteratorer som reversere iteratorer (rbegin, rend), konstante iteratorer (cbegin, cend) og konstante revers iteratorer (crbegin, crend) og kan brukes på en lignende måte som vektorer.
Følgende eksempel viser dette.
#include #include #include #include using namespace std; int main() { list mylist = {1, 1, 2, 3, 5}; cout<<”List elements are: “; list::iterator it; for(it=mylist.begin();it!=mylist.end();++it) cout<<*it<<” “; }Produksjon:
Listeelementene er: 1 1 2 3 5
I eksemplet ovenfor har vi således deklarert en liste over Fibonacci-sekvensen. Deretter erklærer vi en iterator av samme type som listen, og deretter bruker vi for loop, og vi skriver ut listeinnholdet fra start til slutt.
La oss nå hoppe til de operasjonene eller funksjonene som beholderen i STL gir oss.
Listeoperasjoner
- Sett inn: Brukes til å sette inn et element i gitt posisjon. Returnerer en iterator som peker på det første elementet som er satt inn.
sett inn (pos, num_elem, elem)
Hvor,
pos => Posisjon der nye elementer skal settes inn.
num_elem => Antall elementer som skal settes inn er som standard 1.
element => Faktisk verdi som skal settes inn.
La oss forstå innsettingsfunksjonen ved å ta et eksempel.
#include #include // for list operations using namespace std; int main() { list mylist = {1,1,2}; list::iterator it = mylist.begin(); // iterator to point to 4th position advance(it,` 3); // inserts 3 at 4th position mylist.insert(it, 3); cout << 'The list after inserting' << ' 1 element using insert() is : '; for (list::iterator i = mylist.begin();i != mylist.end();i++) cout << *i << ' '; cout << endl; }Produksjon:
Listen etter å ha satt inn 1 element ved hjelp av insert () er: 1 1 2 3
Dette er et eksempel på å bare sette inn ett element på 4thposisjon i listen som til slutt er den siste posisjonen. Derfor har vi først en liste som vi har definert iteratoren som peker mot begynnelsen av listen. Så skifter vi denne iteratoren til 4thposisjon og ring innlegg for å sette inn 1 element.
Vi kan også sette inn mer enn ett element, ved å spesifisere den andre parameteren i innsettingsfunksjonen. Når den ikke er spesifisert, er den som standard 1.
- push_back :Legger til et nytt element på slutten av listen.
- push_front :Legger til et nytt element i begynnelsen av listen.
La oss se et eksempel som demonstrerer bruken av push_back og push_front-funksjoner.
#include #include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3}; cout<<'List elements are: '; printlist(mylist); mylist.push_front(0); mylist.push_back(5); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produksjon:
Listeelementene er: 1 1 2 3
Listeinnhold etter push_front og push_back: 0 1 1 2 3 5
I dette eksemplet oppretter og lister vi først alle to elementene til den, en hver foran og bak ved å bruke henholdsvis push_front og push_back-funksjoner. Utgangen viser den endrede listen etter at begge funksjonene er utført.
- pop_back :Fjerner det siste elementet i listen og reduserer dermed listen med 1.
- pop_front :Fjerner det første elementet i listen og reduserer dermed listen med 1.
Følgende eksempel viser bruken av pop_back og pop_front-operasjoner i listen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); mylist.pop_front(); mylist.pop_back(); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produksjon:
hva er stadiene i sdlc
Listeelementene er: 1 1 2 3 5
Listeinnhold etter push_front og push_back: 1 2 3
Som beskrevet i operasjonens definisjon, fjerner hver av operasjonene pop_front og pop_back elementet fra forsiden og baksiden av listen, dvs. det første og det siste elementet på listen, og dermed hver gang det reduserer størrelsen på listen med 1.
- størrelse :Returnerer størrelsen på listen, dvs. antall elementer i listen.
- tømme :Sjekker om listen er tom.
- viske ut :Fjerner et element eller et utvalg av elementer fra listen.
- klar :Fjerner alle elementene fra listen ved å gjøre den til størrelse 0.
Nedenfor er et eksempel for å demonstrere bruken av alle funksjonene ovenfor, dvs. størrelse, tom, slett og klar.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'size of the list: '< Produksjon:
Listeelementene er: 1 1 2 3 5
størrelse på listen: 5
Liste etter sletting av første element: 1 2 3 5
Ny størrelse på listen: 4
størrelse på listen etter klar: 0
Ovennevnte program viser alle de fire funksjonene relatert til kapasiteten til listen. Vi ser at listestørrelsen reduseres med 1 når vi sletter 1 element i listen. Mens når vi kaller en klar operasjon på listen, er størrelsen 0 som betyr at alle elementene i listen fjernes.
- front :Returnerer verdien av det første elementet i listen.
- tilbake :Returnerer verdien av det siste elementet i listen.
- bytte :Bytter innholdet på en liste med innholdet i en annen liste av samme størrelse og type.
- omvendt :En algoritme som snur listen.
- sortere :Sorterer gitt liste.
Eksemplet nedenfor viser bruken av front-, bak-, revers-, sorterings- og byttefunksjonene.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'
Front of the list: '< Produksjon:
Listeelementene er: 1 1 2 3 5
Forsiden av listen: 1
Bak på listen: 5
Omvendt liste: 5 3 2 1 1
Innholdet i oddelisten: 1 3 5 7 9
Etter bytte
min liste: 1 3 5 7 9
Oddliste: 5 3 2 1 1
I denne koden skriver vi først ut verdiene for og bak på listen min liste. Da blir denne listen omvendt og den omvendte listen skrives ut. Etter det definerer vi en annen liste over oddetall som ikke er i noen rekkefølge, og vi kaller 'Sorter' -algoritmen for å sortere denne listen. Deretter bytter vi de to listene ved hjelp av byttefunksjonen og skriver ut de utvekslede listene.
- skjøt :Denne funksjonen brukes til å overføre innholdet i en liste til en annen liste på en spesifisert posisjon.
Begge listene må være av samme type.
skjøting (posisjon, liste);
hvor,
posisjon => Posisjon der innholdet på listen skal overføres.
liste => Liste hvis elementer skal overføres.
Eksemplet nedenfor viser bruken av skjøtefunksjonen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 8,13}; cout<<'List elements are: '; printlist(mylist); list seclist = {2,3,5}; cout<<'list to be spliced: '; printlist(seclist); list:: iterator it = mylist.begin(); it ++; it++; mylist.splice(it,seclist); cout<<'
List contents after splicing at position 2: '; printlist(mylist); } Produksjon:
Listeelementene er: 1 1 8 13
liste som skal skjøtes: 2 3 5
Listeinnhold etter skjøting i posisjon 2: 1 1 2 3 5 8 13
De eksempel viser at vi bruker to lister. Først blir iteratoren for mylisten flyttet til to posisjoner, og deretter kalles skjøtingsfunksjonen for å overføre innholdet i den andre listen til den tredje posisjonen i den første listen.
- gå :I motsetning til skjøtefunksjon som kan brukes til å overføre innholdet i en liste til en annen på en bestemt posisjon, slår fletteoperasjonen direkte sammen to lister for å danne en enkelt liste. For sammenslåing må begge listene være i sortert rekkefølge.
Nedenfor er et eksempel for å demonstrere sammenslåingsfunksjonen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1,2,3,5,8}; list seclist = {4,6,7}; cout<<'First List: '; printlist(mylist); cout< Produksjon:
Første liste: 11 2 3 5 8
Andre liste: 4 6 7
Listeinnhold etter sammenslåing av to lister:
1 1 2 3 4 5 6 7 8
Dermed i programmet ovenfor har vi to lister som er sortert. Vi kaller fletteoperasjon på disse to listene. Den resulterende listen er en sortert liste som inneholder elementene i begge listene.
Konklusjon
Vi har kommet til slutten av denne veiledningen om Lister i STL. Vi håper denne opplæringen ville gitt deg enorm kunnskap om Lister i STL.
=> Sjekk her for å se AZ av C ++ opplæringsveiledninger her.
Anbefalt lesing