lists stl
Erfahren Sie alles über Listen in STL zusammen mit seiner Implementierung.
Listen sind sequentielle Container. Listen enthalten Elemente an nicht zusammenhängenden Stellen. Wir haben Arrays und Vektoren in unseren vorherigen Tutorials besprochen.
Im Fall der Array- und Vektorcontainer, da diese Container Daten in einem zusammenhängenden Speicher speichern, erweist sich die Einfügeoperation in der Mitte dieser Container als sehr kostspielig, da wir die vorhandenen Elemente entsprechend verschieben müssen, um Platz für das neue Element zu schaffen.
=> Hier finden Sie die vollständige Liste der C ++ - Tutorials.
Was ist ein Wasserfallmodell mit Beispiel?
Was du lernen wirst:
Überblick
Die Liste ist ein Container, der diesen Nachteil der Array- und Vektorcontainer überwindet. Es ermöglicht uns, Elemente an einer beliebigen Stelle in der Liste einzufügen, ohne großen Aufwand zu verursachen. Aber Listen sind langsamer als Vektoren, was das Durchlaufen betrifft.
In diesem Tutorial sehen wir die Implementierung von Listen in STL zusammen mit den verschiedenen Operationen des Durchlaufens, Manipulierens und Zugriffs auf Listen mit Beispielen.
Beachten Sie, dass die meisten Listenoperationen denen von Vektoren ähnlich sind und daher Leser, die unser Tutorial zu Vektoren bereits gelesen haben, keine Probleme bei der Interpretation von Listenkonzepten haben.
Erklärung und Initialisierung
Um den Listencontainer zu implementieren und alle seine Vorteile zu nutzen, müssen wir eine Header-Datei in unser Programm aufnehmen.
#include
Die allgemeine Deklaration für den Listencontainer lautet
std::list listName;
Zum Beispiel,Wir können eine Liste mit dem Namen 'mylist' vom Typ int wie folgt deklarieren:
std::list mylist;
Wir können die Liste auch zum Zeitpunkt der Deklaration initialisieren oder mithilfe einer der unterstützten Operationen Elemente hinzufügen.
Mal sehen, wie wir die oben erstellte Liste initialisieren können.
std::list mylist = {1, 1, 2, 3, 5};
Die obige Initialisierung wird wie unten gezeigt gespeichert:
Sobald wir die Liste initialisiert haben, können wir mit einem Iterator auf die Elemente einer Liste zugreifen. Die Iterator-Funktionen 'Anfang' und 'Ende' helfen uns, die Listenelemente zu durchlaufen.
Hinweis: Der Iterator für die Liste unterstützt auch andere Iteratoren wie umgekehrte Iteratoren (rbegin, rend), konstante Iteratoren (cbegin, cend) und konstante umgekehrte Iteratoren (crbegin, crend) und kann auf ähnliche Weise wie Vektoren verwendet werden.
Das folgende Beispiel zeigt dies.
#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<<” “; }
Ausgabe:
Listenelemente sind: 1 1 2 3 5
Daher haben wir im obigen Beispiel eine Liste der Fibonacci-Sequenz deklariert. Als nächstes deklarieren wir einen Iterator des gleichen Typs wie list und drucken dann mit der for-Schleife den Listeninhalt von Anfang bis Ende.
Lassen Sie uns nun zu den Operationen oder Funktionen springen, die uns der Listencontainer in STL bietet.
Operationen auflisten
- Einfügen: Wird verwendet, um ein Element an der angegebenen Position einzufügen. Gibt einen Iterator zurück, der auf das erste eingefügte Element zeigt.
Einfügen (pos, num_elem, elem)
Wo,
pos => Position, an der neue Elemente eingefügt werden sollen.
num_elem => Anzahl der einzufügenden Elemente; Der Standardwert ist 1.
item => Istwert, der eingefügt werden soll.
Lassen Sie uns die Einfügefunktion anhand eines Beispiels verstehen.
#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; }
Ausgabe:
Die Liste nach dem Einfügen von 1 Element mit insert () lautet: 1 1 2 3
Dies ist ein Beispiel, um nur ein Element an der 4 einzufügenthPosition in der Liste, die schließlich die letzte Position ist. Daher haben wir zuerst eine Liste, für die wir den Iterator definiert haben, der auf den Anfang der Liste zeigt. Dann verschieben wir diesen Iterator auf die 4thpositionieren und dann insert aufrufen, um 1 Element einzufügen.
Wir können auch mehr als ein Element einfügen, indem wir den zweiten Parameter in der Einfügefunktion angeben. Immer wenn es nicht angegeben wird, wird standardmäßig 1 verwendet.
- push_back ::Fügt am Ende der Liste ein neues Element hinzu.
- push_front ::Fügt am Anfang der Liste ein neues Element hinzu.
Sehen wir uns ein Beispiel an, das die Verwendung der Funktionen push_back und push_front demonstriert.
#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); }
Ausgabe:
Listenelemente sind: 1 1 2 3
Listen Sie den Inhalt nach push_front und push_back auf: 0 1 1 2 3 5
In diesem Beispiel erstellen und listen wir zunächst alle zwei Elemente auf, jeweils eines vorne und hinten, indem wir die Funktionen push_front und push_back verwenden. Die Ausgabe zeigt die geänderte Liste, nachdem beide Funktionen ausgeführt wurden.
- Pop zurück ::Entfernt das letzte Element in der Liste, wodurch die Listengröße um 1 verringert wird.
- pop_front ::Entfernt das erste Element in der Liste, wodurch die Listengröße um 1 verringert wird.
Das folgende Beispiel zeigt die Verwendung der Operationen pop_back und pop_front der Liste.
#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); }
Ausgabe:
Listenelemente sind: 1 1 2 3 5
Listen Sie den Inhalt nach push_front und push_back auf: 1 2 3
Wie in der Operationsdefinition beschrieben, entfernt jede der Operationen pop_front und pop_back das Element von der Vorder- und Rückseite der Liste, d. H. Das erste und das letzte Element der Liste, und reduziert somit jedes Mal die Größe der Liste um 1.
- Größe ::Gibt die Größe der Liste zurück, d. H. Die Anzahl der Elemente in der Liste.
- leer ::Überprüft, ob die Liste leer ist.
- löschen ::Entfernt ein Element oder einen Elementbereich aus der Liste.
- klar ::Entfernt alle Elemente aus der Liste, indem die Größe 0 festgelegt wird.
Das folgende Beispiel zeigt die Verwendung aller oben genannten Funktionen, d. H. Größe, leer, löschen und löschen.
#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: '< Ausgabe:
Listenelemente sind: 1 1 2 3 5
Größe der Liste: 5
Liste nach dem Löschen des ersten Elements: 1 2 3 5
Neue Größe der Liste: 4
Größe der Liste nach Löschen: 0
Das obige Programm demonstriert alle vier Funktionen, die sich auf die Kapazität der Liste beziehen. Wir sehen, dass die Listengröße um 1 abnimmt, wenn wir 1 Element der Liste löschen. Wenn wir eine eindeutige Operation für die Liste aufrufen, ist die Größe 0, was bedeutet, dass alle Elemente in der Liste entfernt werden.
- Vorderseite ::Gibt den Wert des ersten Elements der Liste zurück.
- zurück ::Gibt den Wert des letzten Elements der Liste zurück.
- Tauschen ::Vertauscht den Inhalt einer Liste mit dem Inhalt einer anderen Liste gleicher Größe und gleichen Typs.
- umkehren ::Ein Algorithmus, der die Liste umkehrt.
- Sortieren ::Sortiert die angegebene Liste.
Das folgende Beispiel zeigt die Verwendung der Funktionen Front, Back, Reverse, Sort und Swap.
#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: '< Ausgabe:
Listenelemente sind: 1 1 2 3 5
Vorderseite der Liste: 1
Ende der Liste: 5
Umgekehrte Liste: 5 3 2 1 1
Inhalt der ungeraden Liste: 1 3 5 7 9
Nach dem Tauschen
Mylist: 1 3 5 7 9
Oddlist: 5 3 2 1 1
In diesem Code drucken wir zuerst die vorderen und hinteren Werte der Listen-Mylist. Dann wird diese Liste umgekehrt und die umgekehrte Liste wird gedruckt. Danach definieren wir eine weitere Liste ungerader Zahlen, die nicht in beliebiger Reihenfolge angeordnet ist, und rufen den Sortieralgorithmus auf, um diese Liste zu sortieren. Dann tauschen wir die beiden Listen mit der Swap-Funktion aus und drucken die ausgetauschten Listen.
- spleißen ::Diese Funktion wird verwendet, um den Inhalt einer Liste an einer bestimmten Position in eine andere Liste zu übertragen.
Beide Listen müssen vom gleichen Typ sein.
Spleiß (Position, Liste);
wo,
position => Position, an der der Listeninhalt übertragen werden soll.
list => Liste, deren Elemente übertragen werden sollen.
Das folgende Beispiel zeigt die Verwendung der Spleißfunktion.
#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); }
Ausgabe:
Listenelemente sind: 1 1 8 13
Liste, die gespleißt werden soll: 2 3 5
Listen Sie den Inhalt nach dem Spleißen an Position 2 auf: 1 1 2 3 5 8 13
Das Beispiel zeigt, dass wir zwei Listen verwenden. Zuerst wird der Iterator für meine Liste an zwei Positionen verschoben, und dann wird die Spleißfunktion aufgerufen, um den Inhalt der zweiten Liste an die dritte Position der ersten Liste zu übertragen.
- gehen ::Im Gegensatz zur Spleißfunktion, mit der Inhalte einer Liste an einer bestimmten Position an eine andere übertragen werden können, werden bei der Zusammenführungsoperation zwei Listen direkt zu einer einzigen Liste zusammengeführt. Für den Zusammenführungsvorgang müssen beide Listen in sortierter Reihenfolge vorliegen.
Im Folgenden finden Sie ein Beispiel zur Veranschaulichung der Zusammenführungsfunktion.
Top 10 Anime Sites Englisch Dub
#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< Ausgabe:
Erste Liste: 11 2 3 5 8
Zweite Liste: 4 6 7
Listeninhalt nach dem Zusammenführen von zwei Listen:
1 1 2 3 4 5 6 7 8
Daher haben wir im obigen Programm zwei Listen, die sortiert sind. Wir nennen die Zusammenführungsoperation für diese beiden Listen. Die resultierende Liste ist eine sortierte Liste, die die Elemente beider Listen enthält.
Fazit
Wir sind am Ende dieses Tutorials zu Listen in STL angelangt. Wir hoffen, dass dieses Tutorial Ihnen immenses Wissen über Listen in STL vermittelt hat.
=> Hier finden Sie A-Z der C ++ - Schulungsanleitungen.
Literatur-Empfehlungen
- Prioritätswarteschlange In STL
- KARTEN In STL
- SET In STL
- Stapel und Warteschlangen in STL
- Python-Liste - Elemente erstellen, darauf zugreifen, in Scheiben schneiden, hinzufügen oder löschen
- Konstanten in C ++
- VBScript-Dateiobjekte: CopyFile, DeleteFile, OpenTextFile, Read and Write Text File
- Initialisierungslisten in C ++