std::sort (tsz. std::sorts)
std::sort
a C++ Standard Library egyik leghatékonyabb rendező algoritmusa, amely az <algorithm>
könyvtár része. Gyors és egyszerű módot biztosít egy tartomány elemeinek növekvő vagy csökkenő sorrendbe állítására.
std::sort
SzintaxisA std::sort
függvény általános alakja:
#include <algorithm>
std::sort(first, last);
std::sort(first, last, comp);
first
: A rendezendő tartomány első eleme (iterátor).last
: A rendezendő tartomány utolsó eleme (iterátor).comp
(opcionális): Egyedi összehasonlító függvény vagy funktor.Alapértelmezett viselkedés: Ha nem adunk meg egyéni összehasonlító függvényt, akkor a std::sort
növekvő sorrendbe rendezi az elemeket (<
operátor alapján).
Időkomplexitás:
- Átlagosan és legjobb esetben: ( O(n n) )
- Legrosszabb esetben: ( O(n n) ) (általában Introsort
, ami a QuickSort, HeapSort és InsertionSort kombinációja)
std::sort
-tal
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> v = {5, 2, 8, 1, 3};
std::sort(v.begin(), v.end()); // Növekvő sorrend
std::cout << "Rendezett tömb: ";
for (int x : v) std::cout << x << " ";
return 0;
}
Kimenet:
Rendezett tömb: 1 2 3 5 8
Ha csökkenő sorrendet szeretnénk, használhatjuk az std::greater<int>()
predikátumot:
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> v = {5, 2, 8, 1, 3};
std::sort(v.begin(), v.end(), std::greater<int>());
std::cout << "Csökkenő sorrend: ";
for (int x : v) std::cout << x << " ";
return 0;
}
Kimenet:
Csökkenő sorrend: 8 5 3 2 1
std::sort
TömbbelA std::sort
tömbökkel is működik, de az iterátorokat kell használni (std::begin()
és std::end()
):
#include <iostream>
#include <algorithm>
int main() {
int arr = {10, 7, 2, 5, 9};
std::sort(std::begin(arr), std::end(arr)); // Növekvő sorrend
std::cout << "Rendezett tömb: ";
for (int x : arr) std::cout << x << " ";
return 0;
}
Kimenet:
Rendezett tömb: 2 5 7 9 10
A std::sort
egyedi logika szerint is rendezhet, ha megadunk egy összehasonlító függvényt.
#include <iostream>
#include <vector>
#include <algorithm>
bool customCompare(int a, int b) {
return (a % 2 == 0) && (b % 2 != 0); // Páros számok előre
}
int main() {
std::vector<int> v = {3, 1, 4, 8, 5, 2};
std::sort(v.begin(), v.end(), customCompare);
std::cout << "Páros számok előre rendezve: ";
for (int x : v) std::cout << x << " ";
return 0;
}
Lehetséges kimenet:
Páros számok előre rendezve: 4 8 2 3 1 5
(A páros számok előre kerültek, de a sorrendjük nem garantált.)
A std::sort
hasznos struktúrák vagy objektumok rendezésére is.
#include <iostream>
#include <vector>
#include <algorithm>
struct Ember {
std::string nev;
int kor;
};
// Összehasonlító függvény: Életkor szerint növekvő
bool compareByAge(const Ember &a, const Ember &b) {
return a.kor < b.kor;
}
int main() {
std::vector<Ember> emberek = {{"Anna", 25}, {"Béla", 30}, {"Csaba", 22}};
std::sort(emberek.begin(), emberek.end(), compareByAge);
std::cout << "Rendezett emberek (életkor szerint):" << std::endl;
for (const auto &e : emberek) {
std::cout << e.nev << " (" << e.kor << " év)" << std::endl;
}
return 0;
}
Kimenet:
Rendezett emberek (életkor szerint): Csaba (22 év) Anna (25 év) Béla (30 év)
std::sort
-ra
std::partial_sort
Ha csak a legkisebb vagy legnagyobb N elemet akarjuk rendezni:
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> v = {8, 3, 7, 1, 5, 2};
std::partial_sort(v.begin(), v.begin() + 3, v.end());
std::cout << "Az első három legkisebb elem: ";
for (int i = 0; i < 3; i++) std::cout << v << " ";
return 0;
}
Eredmény: Az első 3 legkisebb szám lesz az elején.
std::nth_element
std::nth_element(v.begin(), v.begin() + k, v.end());
Ez biztosítja, hogy az k
-adik elem a helyén legyen, és az előtte lévők kisebbek, az utána lévők nagyobbak lesznek, de nem rendezi teljesen a vektort.
✅ std::sort
egy gyors rendező algoritmus (O(n n)) időkomplexitással.
✅ Alapértelmezett rendezés növekvő sorrendben történik.
✅ Összehasonlító függvénnyel testreszabható (pl. csökkenő sorrend, egyedi kritériumok).
✅ Vektorok, tömbök és struktúrák rendezésére is alkalmazható.
✅ Alternatívák: std::partial_sort
, std::nth_element
ha nem kell teljes rendezés.
Ha hatékony rendezési megoldásra van szükséged C++-ban, a std::sort
az egyik legjobb választás! 🚀