Detaillierte Erklärung und Anwendung der Liste in C++-Containerserien

Einführung

Die C++-Standardvorlagenbibliothek (STL) bietet einen umfangreichen Satz von Containerklassen, darunter eine Liste. Eine Liste ist ein Container, der als doppelt verknüpfte Liste implementiert ist und sich stark von Containern wie Arrays und Vektoren unterscheidet. In diesem Artikel werden die Elementanordnungsmerkmale der Liste, der Unterschied zu anderen Containern und Anwendungsszenarien ausführlich vorgestellt und Codebeispiele bereitgestellt.

Eigenschaften der Elementanordnung der Liste

Die Liste ist eine doppelt verknüpfte Liste, sodass ihre Elemente nicht kontinuierlich im Speicher gespeichert werden, sondern durch Zeiger verbunden sind. Dies führt zu einer effizienten Leistung bei Einfüge- und Löschvorgängen, ist jedoch bei Direktzugriffen relativ langsam.

Vorteile und Nachteile

Vorteile:
Effiziente Einfüge- und Löschvorgänge: Aufgrund der Struktur der verknüpften Liste erfordert das Einfügen und Löschen von Elementen nur das Anpassen der Zeiger benachbarter Knoten, ohne dass eine große Anzahl von Elementen verschoben werden muss .
Keine vorherige Zuweisung von Speicher erforderlich: Im Vergleich zu Arrays und Vektoren müssen Listen keinen kontinuierlichen Speicherplatz vorab zuzuweisen.
Nachteile:
Der wahlfreie Zugriff ist relativ langsam: Aufgrund der Struktur der verknüpften Liste erfordert der Zugriff auf Elemente ein Durchlaufen nacheinander, beginnend am Kopfknoten oder Endknoten , und die Zeitkomplexität ist O( n).

Unterschiede zu anderen Behältern

Der Unterschied zwischen und vector (vector):
Speicherzuweisungsmethode: vector verwendet ein dynamisches Array und die Elemente werden kontinuierlich im Speicher gespeichert, während list eine verknüpfte Liste verwendet. und die Elemente sind durch Zeiger verbunden. von.
Einfüge- und Löschvorgänge: In einem Vektor kann das Einfügen und Löschen von Elementen das Verschieben einer großen Anzahl von Elementen beinhalten, während Listeneinfüge- und -löschvorgänge nur das Anpassen von Zeigern erfordern und daher effizienter sind.
Der Unterschied zwischen und Warteschlange (Warteschlange):
Elementzugriff: Warteschlange ist ein First-In-First-Out ( FIFO)-Datenstruktur, die nur an beiden Enden der Warteschlange zum Einfügen und Löschen von Elementen ausgeführt werden kann, während Listen Elemente an jeder Position einfügen und löschen können.
Unterschiede zur doppelendigen Warteschlange (Deque):
Zwischeneinfügungs- und Löschvorgänge: Im Vergleich zu Deque eignet sich die Liste besser zum Einfügen und Löschen von Elementen in der Mitte weil Diese Operationen sind in Listen effizient, während sie in Deques das Verschieben von Elementen beinhalten.

Anwendungsszenarien

Die Liste eignet sich für die folgenden Szenarien:

• Häufige Einfüge- und Löschvorgänge: Wenn das Programm häufige Einfüge- und Löschvorgänge ausführen muss und sich nicht um den Direktzugriff kümmert, ist die Liste eine gute Wahl.
• Situationen, in denen kein Direktzugriff erforderlich ist: Wenn die Eigenschaften des Algorithmus oder der Datenstruktur keinen Direktzugriff erfordern, können Sie durch die Verwendung einer Liste eine bessere Leistung erzielen.
• Situationen mit vielen Einfügungen und Löschungen in der Mitte: Wenn eine große Anzahl von Einfügungen und Löschungen in der Mitte des Containers durchgeführt werden muss, ist die Liste normalerweise effizienter als andere Container.

Gemeinsame Funktionen

Im Folgenden sind einige häufige Funktionsverwendungen der Klasse std::list in C++ aufgeführt:

Aufbau und Aufgabe:

Konstrukteur:

std::list<int> myList;  // 创建一个空的list
std::list<int> myList2(5, 10);  // 创建包含5个值为10的元素的list

Zuweisungsvorgang:

std::list<int> anotherList = {
    
    1, 2, 3};
myList = anotherList;  // 赋值操作

Einfüge- und Löschvorgänge:

Elemente einfügen:

myList.push_back(4);      // 在末尾插入元素
myList.push_front(0);     // 在开头插入元素
auto it = myList.begin();  
++it;
myList.insert(it, 2);     // 在指定位置插入元素

Elemente löschen:

myList.pop_back();         // 删除末尾元素
myList.pop_front();        // 删除开头元素
auto it = myList.begin();
++it;
myList.erase(it);          // 删除指定位置的元素

Zugriffselemente:

Zugriff per Iterator:

for (auto it = myList.begin(); it != myList.end(); ++it) {
    
    
    std::cout << *it << " ";
}

Über eine bereichsbasierte for-Schleife:

for (const auto& element : myList) {
    
    
    std::cout << element << " ";
}

Kapazität:

Größe:

std::cout << "Size of the list: " << myList.size() << std::endl;

Überprüfen Sie, ob es leer ist:

if (myList.empty()) {
    
    
    std::cout << "List is empty." << std::endl;
}

Ändern Sie den Container:

Klar:

myList.clear();  // 清空所有元素

Andere Operationen:

Umkehren:

myList.reverse();  // 反转list中的元素

Sortiere nach:

myList.sort();  // 默认升序排序
// 若要降序排序，可以使用自定义比较函数
myList.sort(std::greater<int>());

Dies sind einige grundlegende Funktionsverwendungen der Klasse std::list. Im tatsächlichen Einsatz können Sie je nach Bedarf den passenden Betrieb auswählen.

Codebeispiel

Hier ist ein einfaches C++-Codebeispiel, das zeigt, wie Listen für grundlegende Vorgänge verwendet werden:

#include <iostream>
#include <list>

int main() {
    
    
    // 创建list
    std::list<int> myList;

    // 在末尾插入元素
    myList.push_back(1);
    myList.push_back(2);
    myList.push_back(3);

    // 在开头插入元素
    myList.push_front(0);

    // 遍历list
    std::cout << "Elements in the list: ";
    for (const auto& element : myList) {
    
    
        std::cout << element << " ";
    }
    std::cout << std::endl;

    // 删除第二个元素
    auto it = std::next(myList.begin(), 1);
    myList.erase(it);

    // 遍历修改后的list
    std::cout << "Elements after erasing the second element: ";
    for (const auto& element : myList) {
    
    
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

Dieses Beispiel zeigt, wie man eine Liste erstellt, Elemente einfügt und löscht und über die Liste iteriert.