std::sort

std::sort (tsz. std::sorts)

1. (informatika) A 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.

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

#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

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

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(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! 🚀

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