sequence container

Angol

Főnév

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.

---

1. Sequence konténerek típusai

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

Konténer	Jellemzők	Előnyök	Hátrányok
std::vector	Dinamikus tömb	Gyors indexelés, folyamatos memória	Lassú beszúrás középre
std::deque	Dupla végű sor	Gyors beszúrás/törlés az elején és végén	Kevésbé memóriahatékony
std::list	Kétirányú láncolt lista	Gyors beszúrás/törlés bárhol	Lassú indexelés

---

2. std::vector – Dinamikus tömb

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

Főbb tulajdonságok:

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

Használata:

#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[1] << 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

---

3. std::deque – Dupla végű sor

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.

Főbb tulajdonságok:

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

Használata:

#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

---

4. std::list – Kétirányú láncolt lista

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

Főbb tulajdonságok:

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

Használata:

#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

---

5. Sequence konténerek összehasonlítása

Jellemző	std::vector	std::deque	std::list
Indexelés	Gyors O(1)	Gyors O(1)	Lassú O(n)
Beszúrás a végén	Gyors O(1)	Gyors O(1)	Gyors O(1)
Beszúrás az elején	Lassú O(n)	Gyors O(1)	Gyors O(1)
Beszúrás középen	Lassú O(n)	Lassú O(n)	Gyors O(1)
Memóriahasználat	Hatékony	Kevésbé hatékony	Több foglalt memória
Elemek elrendezése	Tömb	Tömbszerű blokkok	Láncolt lista

---

6. Sequence konténerek és STL algoritmusok

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

---

Összegzé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. 🚀

További információk

• 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)