data structure

Angol

Főnév

data structure (tsz. data structures)

1. (informatika) adatszerkezet, adatstruktúra

---

Az adatszerkezetek alapvető építőelemei a hatékony programozásnak. Lehetővé teszik az adatok tárolását, kezelését és manipulálását optimális módon. C++ nyelven számos beépített és felhasználó által definiált adatszerkezet létezik, amelyek segítenek különböző problémák megoldásában.

---

1. Alapvető adatszerkezetek

A leggyakrabban használt adatszerkezetek C++-ban a következők:

1. Tömbök (array)
2. Mutatók és dinamikus memória (pointer)
3. Vektor (std::vector)
4. Lista (std::list)
5. Verem (std::stack)
6. Sor (std::queue)
7. Kettős végű sor (std::deque)
8. Halmaz (std::set)
9. Asszociatív tömb (térkép) (std::map)
10. Grafok és fák (BST, AVL, Graph)

C++ a Standard Template Library (STL) segítségével számos adatszerkezetet biztosít, amelyek hatékonyan kezelhetők és újrafelhasználhatók.

---

2. Tömbök (array)

A tömbök rögzített méretű, homogén adattárolók, ahol az elemek indexelhetők.

Statikus tömb

#include <iostream>
using namespace std;

int main() {
    int tomb[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        cout << tomb[i] << " ";
    }

    return 0;
}

Dinamikus tömb (new és delete)

#include <iostream>
using namespace std;

int main() {
    int* dinTomb = new int[5];  // Dinamikus tömb

    for (int i = 0; i < 5; i++) {
        dinTomb[i] = i * 10;
        cout << dinTomb[i] << " ";
    }

    delete[] dinTomb; // Memória felszabadítása

    return 0;
}

---

3. Mutatók és dinamikus memória

A mutatók dinamikusan foglalnak memóriát a heap-en.

#include <iostream>
using namespace std;

int main() {
    int* p = new int(10);
    cout << "A dinamikusan foglalt ertek: " << *p << endl;
    delete p;

    return 0;
}

---

4. Vektor (std::vector)

A std::vector egy dinamikus méretű tömb, amely automatikusan méreteződik.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};

    v.push_back(40); // Elem hozzáadása
    v.pop_back();    // Utolsó elem eltávolítása

    for (int i : v) {
        cout << i << " ";
    }

    return 0;
}

✅ Előnyök: Dinamikusan változtatható méret
❌ Hátrányok: Túlméretezés esetén teljes átmásolás történik

---

5. Kétirányú láncolt lista (std::list)

A std::list egy kétirányú láncolt lista, amely könnyen módosítható.

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> l = {10, 20, 30};
    l.push_back(40);
    l.push_front(5);

    for (int i : l) {
        cout << i << " ";
    }

    return 0;
}

✅ Előnyök: Gyors beszúrás és törlés
❌ Hátrányok: Lassabb hozzáférés index alapján

---

6. Verem (std::stack)

A verem egy LIFO (Last In, First Out) adatszerkezet.

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);

    while (!s.empty()) {
        cout << s.top() << " ";  // Legfelső elem kiíratása
        s.pop();  // Legfelső elem eltávolítása
    }

    return 0;
}

✅ Előnyök: Gyors beszúrás és törlés
❌ Hátrányok: Csak a legfelső elem érhető el közvetlenül

---

7. Sor (std::queue)

A sor egy FIFO (First In, First Out) adatszerkezet.

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;
    q.push(10);
    q.push(20);
    q.push(30);

    while (!q.empty()) {
        cout << q.front() << " ";  // Első elem kiíratása
        q.pop();  // Első elem törlése
    }

    return 0;
}

---

8. Halmaz (std::set)

Egyedi értékeket tárol, automatikusan rendezve.

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s = {30, 10, 20, 10};
    
    for (int i : s) {
        cout << i << " ";  // Rendezett kiíratás: 10 20 30
    }

    return 0;
}

---

9. Térkép (std::map)

A std::map kulcs-érték párok tárolására szolgál.

#include <iostream>
#include <map>
using namespace std;

int main() {
    map<int, string> m;
    m[1] = "Egy";
    m[2] = "Kettő";
    
    for (auto i : m) {
        cout << i.first << ": " << i.second << endl;
    }

    return 0;
}

---

10. Fák és Grafok

A bináris keresőfa és a grafok összetett adatszerkezetek, amelyeket keresési és útkeresési algoritmusokhoz használnak.

Bináris keresőfa (BST)

struct Node {
    int value;
    Node* left;
    Node* right;
    
    Node(int val) {
        value = val;
        left = right = nullptr;
    }
};

Graf (Szomszédsági lista)

#include <iostream>
#include <vector>
using namespace std;

class Graph {
public:
    vector<vector<int>> adjList;

    Graph(int n) {
        adjList.resize(n);
    }

    void addEdge(int u, int v) {
        adjList[u].push_back(v);
        adjList[v].push_back(u);  // Ha irányított, ezt hagyd ki
    }
};

---

Összegzés

Az adatszerkezetek segítenek hatékonyan kezelni és feldolgozni az adatokat. Az alábbiakat érdemes megjegyezni:

• Tömbök és vektorok – Gyors hozzáférés index alapján
• Listák – Gyors beszúrás és törlés
• Verem és sor – Speciális adatszerkezetek LIFO/FIFO műveletekkel
• Halmaz és térkép – Egyedi elemek és kulcs-érték tárolás
• Fák és grafok – Keresési és kapcsolati adatokhoz

A megfelelő adatszerkezet kiválasztása kulcsfontosságú a program hatékonysága szempontjából! 🚀

További információk

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

---