data structure (tsz. data structures)
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.
A leggyakrabban használt adatszerkezetek C++-ban a következők:
array)pointer)std::vector)std::list)std::stack)std::queue)std::deque)std::set)std::map)C++ a Standard Template Library (STL) segítségével számos adatszerkezetet biztosít, amelyek hatékonyan kezelhetők és újrafelhasználhatók.
array)A tömbök rögzített méretű, homogén adattárolók, ahol az elemek indexelhetők.
#include <iostream>
using namespace std;
int main() {
int tomb = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
cout << tomb << " ";
}
return 0;
}
new és delete)#include <iostream>
using namespace std;
int main() {
int* dinTomb = new int; // Dinamikus tömb
for (int i = 0; i < 5; i++) {
dinTomb = i * 10;
cout << dinTomb << " ";
}
delete dinTomb; // Memória felszabadítása
return 0;
}
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;
}
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
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
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
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;
}
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;
}
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 = "Egy";
m = "Kettő";
for (auto i : m) {
cout << i.first << ": " << i.second << endl;
}
return 0;
}
A bináris keresőfa és a grafok összetett adatszerkezetek, amelyeket keresési és útkeresési algoritmusokhoz használnak.
struct Node {
int value;
Node* left;
Node* right;
Node(int val) {
value = val;
left = right = nullptr;
}
};
#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.push_back(v);
adjList.push_back(u); // Ha irányított, ezt hagyd ki
}
};
Az adatszerkezetek segítenek hatékonyan kezelni és feldolgozni az adatokat. Az alábbiakat érdemes megjegyezni:
A megfelelő adatszerkezet kiválasztása kulcsfontosságú a program hatékonysága szempontjából! 🚀