std::max element

std::max element (tsz. std::max elements)

1. (informatika) A std::max_element függvény a C++ Standard Library (STL) egyik algoritmusa, amely egy tartomány legnagyobb elemének iterátorát adja vissza. Ez a függvény különösen hasznos, ha egy tömbből, vektorból vagy más iterálható adatszerkezetből szeretnénk megtalálni a legnagyobb elemet.

A std::max_element függvény a <algorithm> fejlécben található, és az alábbi módokon használható:

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 3, 7, 2, 5};

    auto max_it = std::max_element(v.begin(), v.end());

    if (max_it != v.end()) {
        std::cout << "A legnagyobb elem: " << *max_it << std::endl;
    }

    return 0;
}

Ebben a példában a std::max_element megkeresi a v vektor legnagyobb elemét, majd kiírja az értékét.

A std::max_element kétféle módon hívható meg:

1. Alapverzió:

   template< class ForwardIt >
   ForwardIt max_element( ForwardIt first, ForwardIt last );
   

   • first: a tartomány kezdő iterátora.
   • last: a tartomány végének iterátora.
   • Visszatérési érték: a legnagyobb elem iterátora.

2. Összehasonlító függvénnyel:

   template< class ForwardIt, class Compare >
   ForwardIt max_element( ForwardIt first, ForwardIt last, Compare comp );
   

   Itt comp egy olyan függvény vagy lambda kifejezés, amely meghatározza az összehasonlítás módját.

A std::max_element végigiterál a tartományon, és egy belső összehasonlítás segítségével megjegyzi a legnagyobb elemet. Ha több azonosan nagy érték van, akkor az első előfordulás iterátorát adja vissza.

Ha például egy struktúrában szeretnénk egy adott mező alapján megkeresni a legnagyobb elemet:

#include <iostream>
#include <vector>
#include <algorithm>

struct Ember {
    std::string nev;
    int kor;
};

int main() {
    std::vector<Ember> emberek = { {"Anna", 25}, {"Béla", 30}, {"Cecil", 28} };

    auto max_kor = std::max_element(emberek.begin(), emberek.end(),
        (const Ember& a, const Ember& b) {
            return a.kor < b.kor;
        });

    if (max_kor != emberek.end()) {
        std::cout << "A legidősebb ember: " << max_kor->nev << ", " << max_kor->kor << " éves\n";
    }

    return 0;
}

Ebben az esetben egy lambda függvényt használunk, amely az Ember struktúra kor tagját hasonlítja össze.

Ha egy hagyományos tömbben szeretnénk megtalálni a legnagyobb elemet:

#include <iostream>
#include <algorithm>

int main() {
    int tomb = {5, 2, 9, 1, 7};

    auto max_it = std::max_element(std::begin(tomb), std::end(tomb));

    std::cout << "A legnagyobb elem: " << *max_it << std::endl;

    return 0;
}

Vektorok és egyéb STL konténerek esetén az iterátorokkal dolgozunk:

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
    std::vector<double> szamok = {3.1, 2.7, 8.2, 4.4};

    auto max_it = std::max_element(szamok.begin(), szamok.end());

    std::cout << "A legnagyobb szám: " << *max_it << std::endl;

    return 0;
}

Ha saját osztályunk van, és szeretnénk az egyik attribútum alapján megtalálni a legnagyobb értéket:

#include <iostream>
#include <vector>
#include <algorithm>

class Termek {
public:
    std::string nev;
    double ar;

    Termek(std::string n, double a) : nev(n), ar(a) {}
};

int main() {
    std::vector<Termek> termekek = { {"Laptop", 300000}, {"Telefon", 150000}, {"Monitor", 90000} };

    auto max_termek = std::max_element(termekek.begin(), termekek.end(),
        (const Termek& a, const Termek& b) {
            return a.ar < b.ar;
        });

    if (max_termek != termekek.end()) {
        std::cout << "A legdrágább termék: " << max_termek->nev << " - " << max_termek->ar << " Ft\n";
    }

    return 0;
}

• Időbeli komplexitás: O(n), mivel a std::max_element végigmegy az összes elemen.
• Ha az iterátort end()-re kapjuk vissza, akkor üres a tartomány.
• Ne használjuk std::max_element-et üres tartományon! Ha mégis, akkor ellenőrizzük az eredményt az end()-del.
• Egyenlő elemek esetén az első előfordulás iterátorát adja vissza.
• Összehasonlító függvény nélkül az alapértelmezett operator< operátort használja.

Ha csak a legnagyobb értéket szeretnénk (és nem az iterátort), akkor kombinálhatjuk a std::max_element és a dereferálást:

int max_ertek = *std::max_element(szamok.begin(), szamok.end());

Ha egyszerre a legnagyobb és legkisebb elemet akarjuk megtalálni:

auto minmax = std::minmax_element(szamok.begin(), szamok.end());
std::cout << "Min: " << *minmax.first << ", Max: " << *minmax.second << std::endl;

A std::max_element egy erőteljes algoritmus a legnagyobb elem keresésére tartományokban. Különösen hasznos STL konténerekkel, és testreszabható egyéni összehasonlító függvényekkel. Ha saját típusokkal dolgozunk, érdemes lambda kifejezést vagy függvényobjektumot használni az egyedi kritériumok megadásához.

Főbb előnyei: - Könnyen használható STL konténerekkel. - Hatékony O(n) időbeli komplexitás. - Rugalmas, egyedi összehasonlító függvénnyel bővíthető.

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