sequence container

sequence container (tsz. sequence containers)

1. (informatika) A sequence konténerek (sorozatkonténerek) a C++ Standard Template Library (STL) egyik fő osztályát képezik. Ezek olyan adatszerkezetek, amelyekben az elemek meghatározott sorrendben helyezkednek el, és a sorrend megtartása mellett lehet hozzáadni, törölni és módosítani az elemeket.

A C++ STL három fő sequence konténert biztosít:

A std::vector a leggyakrabban használt sequence konténer, amely egy dinamikusan méretezhető tömbként működik.

• Az elemek egy folyamatos memóriaterületen helyezkednek el.
• A mérete automatikusan nő és csökken (push_back() és pop_back()).
• Gyors indexelés (O(1)), mert az elemek tömbként vannak tárolva.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {10, 20, 30};
    v.push_back(40);  // Új elem hozzáadása
    std::cout << v << std::endl;  // Gyors elérés

    v.erase(v.begin()); // Első elem törlése
    for (int x : v) std::cout << x << " "; // 20 30 40

    return 0;
}

Mikor használjuk? ✅ Ha gyors, véletlenszerű hozzáférésre van szükség
✅ Ha a legtöbb módosítás a végén történik

A dupla végű sor (deque) egy olyan tömbszerű adatszerkezet, amely gyors beszúrást és törlést biztosít mind az elején, mind a végén.

• Dinamikusan változtatható méret.
• Az elején és végén történő beszúrás és törlés O(1) időben történik.
• Kevésbé memóriahatékony, mert az elemek nem feltétlenül folyamatos memóriában helyezkednek el.

#include <iostream>
#include <deque>

int main() {
    std::deque<int> d = {10, 20, 30};
    d.push_front(5);  // Hozzáadás az elejére
    d.push_back(40);  // Hozzáadás a végére

    d.pop_front(); // Első elem törlése
    d.pop_back();  // Utolsó elem törlése

    for (int x : d) std::cout << x << " "; // 20 30
    return 0;
}

Mikor használjuk? ✅ Ha az elején és végén is gyorsan kell hozzáadni és törölni
✅ Ha nem szükséges, hogy az elemek egybefüggő memóriában legyenek

Az std::list egy láncolt lista, amely bármely helyen gyors beszúrást és törlést biztosít.

• Kétirányú láncolt szerkezet (minden elem az előzőre és a következőre is mutat).
• Az elemek nem folyamatos memóriában helyezkednek el.
• Beszúrás és törlés bármely helyen O(1) időben történik.
• Lassú indexelés (O(n)), mert az elemeket sorban kell végigjárni.

#include <iostream>
#include <list>

int main() {
    std::list<int> l = {10, 20, 30};
    l.push_front(5);  // Elejére beszúrás
    l.push_back(40);  // Végére beszúrás

    l.erase(l.begin()); // Első elem törlése

    for (int x : l) std::cout << x << " "; // 20 30 40
    return 0;
}

Mikor használjuk? ✅ Ha gyakran kell az elemek közepére beszúrni vagy törölni
✅ Ha a véletlenszerű elérés nem fontos

A sequence konténerek kompatibilisek az STL algoritmusokkal.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> v = {5, 1, 4, 2, 3};
    std::sort(v.begin(), v.end()); // Rendezés növekvő sorrendbe

    for (int x : v) std::cout << x << " "; // 1 2 3 4 5
    return 0;
}

Az std::list és std::deque is használható az STL algoritmusaival, de mivel az std::list nem rendelkezik indexeléssel, sok esetben saját beépített függvényeit kell használni, például:

std::list<int> l = {5, 1, 4, 2, 3};
l.sort(); // Láncolt listák esetén beépített rendezés

A sequence konténerek mindegyike más-más esetekben hasznos: - std::vector → Ha gyors indexelés kell és főleg a végéhez adunk hozzá. - std::deque → Ha az elejére és végére is gyorsan kell beszúrni. - std::list → Ha gyakran kell középre beszúrni és törölni.

Ha a cél egy gyors, hatékony és könnyen használható konténer, a std::vector az elsődleges választás a legtöbb esetben. 🚀

• sequence container - Szótár.net (en-hu)
• sequence container - Sztaki (en-hu)
• sequence container - Merriam–Webster
• sequence container - Cambridge
• sequence container - WordNet
• sequence container - Яндекс (en-ru)
• sequence container - Google (en-hu)
• sequence container - Wikidata
• sequence container - Wikipédia (angol)