std::sort

Üdvözlöm, Ön a std::sort szó jelentését keresi. A DICTIOUS-ban nem csak a std::sort szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a std::sort szót egyes és többes számban mondani. Minden, amit a std::sort szóról tudni kell, itt található. A std::sort szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. Astd::sort és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.

Főnév

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.



1. std::sort Szintaxis

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)



2. Alapvető Példa std::sort-tal

Egyszerű rendezés növekvő sorrendben

#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

Csökkenő sorrend

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

3. std::sort Tömbbel

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

4. Egyedi Összehasonlító Függvény

A std::sort egyedi logika szerint is rendezhet, ha megadunk egy összehasonlító függvényt.

Példa: Páros számok előre

#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.)



5. Struktúrák Rendezése

A std::sort hasznos struktúrák vagy objektumok rendezésére is.

Példa: Emberek rendezése életkor szerint

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

6. Alternatívák a std::sort-ra

Részleges rendezés – 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.

Legkisebb vagy legnagyobb elem gyors keresése – 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.



Összegzés

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