Zusammenfassung häufig verwendeter Algorithmen in C++ stl

std::sort

Durch das Sortieren von Containerelementen ändert sich die Reihenfolge des Containers. Die Standardreihenfolge ist von klein nach groß.
```
void sort( RandomIt first, RandomIt last );
```

comp: gibt true zurück, wenn das erste Argument kleiner als das zweite ist.

struct {
     bool operator()(int a, int b) const { return a < b; }
 } customLess;

Algorithmuskomplexität: nlogn

std::partial_sort

Durch Sortieren der [ersten, mittleren) Elemente im Container ändert sich die Reihenfolge des Containers. Die Standardreihenfolge ist von klein nach groß.
```
void partial_sort( RandomIt first, RandomIt middle, RandomIt last );
```
comp: gibt true zurück, wenn das erste Argument kleiner als das zweite ist.
Algorithmische Komplexität: Ungefähr (last-first)log(middle-first) Anwendungen von cmp.

std::nth_element

Das Finden des n-ten Elements im Container, vorausgesetzt, es ist von klein nach groß sortiert, ändert die Reihenfolge des Containers und wird im Allgemeinen zum Ermitteln des Medians verwendet.
```
void nth_element( RandomIt first, RandomIt nth, RandomIt last );
```
comp: gibt true zurück, wenn das erste Argument kleiner als das zweite ist.
Komplexität des Algorithmus: Im Durchschnitt linear in std::distance(first, last).

std::partition

Legen Sie die Elemente, die die Bedingungen erfüllen, auf der einen Seite in den Container und die Elemente, die die Bedingungen nicht erfüllen, auf der anderen Seite. Setzen Sie den Zeiger zwischen den beiden Seiten vor dem Beginn der anderen Seite zurück, wodurch sich die Reihenfolge ändert Container.
UnaryPredicate: unäres Prädikat, das „true“ zurückgibt, wenn das Element vor anderen Elementen geordnet werden soll.
```
auto it = std::partition(v.begin(), v.end(), [](int i){return i % 2 == 0;});
```
Algorithmuskomplexität: n

std::lower_bound

Suchen Sie das erste Element im Container, das größer oder gleich einem Wert ist, ohne die Reihenfolge des Containers zu ändern, was eine Sortierung des Containers erfordert. Gibt einen Iterator zurück, der
auf das erste Element im Bereich [erstes, letztes] zeigt, das dies nicht tut erfüllen element < value(oder comp(element, value )),
(dh größer oder gleich), oder last, wenn kein solches Element gefunden wird.
```
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value );
```

comp: binäres Prädikat, das „true“ zurückgibt, wenn das erste Argument kleiner als das zweite ist.

auto prc_info = std::lower_bound(prices.begin(), prices.end(), to_find,
        [](const PriceInfo& info, double value)
        {
            return info.price < value;
        });

Algorithmuskomplexität: logn

std::upper_bound

Findet das erste Element im Container, das größer als ein Wert ist, ändert die Reihenfolge des Containers nicht und erfordert eine Reihenfolge des Containers. Gibt einen Iterator zurück, der
auf das erste Element im Bereich [erstes, letztes) zeigt, sodass value < element
( oder comp(value, element)) ist wahr (dh unbedingt größer) oder last, wenn kein solches Element gefunden wird.
```
ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value );
```

comp: binäres Prädikat, das „true“ zurückgibt, wenn das erste Argument kleiner als das zweite ist.

auto prc_info = std::upper_bound(prices.begin(), prices.end(), to_find,
          [](double value, const PriceInfo& info)
          {
              return value < info.price;
          });

Algorithmuskomplexität: logn

std::equal_range

Gibt einen Bereich zurück, der alle Elemente enthält, die dem Wert im Bereich [erster, letzter) entsprechen. Erfordert, dass der Container geordnet ist

Mögliche Umsetzung:

template<class ForwardIt, class T>
std::pair<ForwardIt, ForwardIt>
    equal_range(ForwardIt first, ForwardIt last, const T& value) {
    return std::make_pair(std::lower_bound(first, last, value),
                          std::upper_bound(first, last, value));
}

comp: binäres Prädikat, das „true“ zurückgibt, wenn das erste Argument kleiner als das zweite ist.
Algorithmuskomplexität: 2 * logn

std::binary_search

Die binäre Suche nach einem Element, das dem Wert entspricht, erfordert, dass der Container in Ordnung ist, und ändert nicht die Reihenfolge des Containers.
Mögliche Implementierung:

template<class ForwardIt, class T>
bool binary_search(ForwardIt first, ForwardIt last, const T& value)
{
  first = std::lower_bound(first, last, value);
  return (!(first == last) && !(value < *first));
}

comp: binäres Prädikat, das „true“ zurückgibt, wenn das erste Argument kleiner als das zweite ist.
Algorithmuskomplexität: logn

std::transform

Wenden Sie einen bestimmten Algorithmus auf die Elemente in einem Container an und wenden Sie ihn auf einen anderen Container an

unary_op/binary_op:

std::transform(s.cbegin(), s.cend(),
                s.begin(), // write to the same location
                [](unsigned char c) { return std::toupper(c); });

std::transform(s.cbegin(), s.cend(), std::back_inserter(ordinals),
 [](unsigned char c) { return c; });

std::transform(ordinals.cbegin(), ordinals.cend(), ordinals.cbegin(),
                ordinals.begin(), std::plus<>{});

Algorithmuskomplexität: n

std::unique

Eines der beiden benachbarten äquivalenten Elemente im Entferner. Es wird normalerweise in Verbindung mit Erase verwendet, um die tatsächliche Löschung abzuschließen, und erfordert keine Bestellung des Containers.
```
left_boundary.erase(std::unique(left_boundary.begin(), left_boundary.end()),
                  left_boundary.end());
```
BinaryPredicate: Binäres Prädikat, das „true“ zurückgibt, wenn die Elemente als gleich behandelt werden sollen.
Algorithmuskomplexität: n

std::remove/std::remove_if

Entfernen Sie Elemente aus einem Container, die bestimmte Bedingungen erfüllen. Dies wird normalerweise in Verbindung mit Löschen verwendet, um den Löschvorgang im eigentlichen Sinne abzuschließen, und erfordert nicht, dass der Container in Ordnung ist.
```
auto noSpaceEnd = std::remove(str1.begin(), str1.end(), ' ');
str1.erase(noSpaceEnd, str1.end());
```

UnaryPredicate: unäres Prädikat, das „true“ zurückgibt, wenn das Element entfernt werden soll.

str2.erase(std::remove_if(str2.begin(),
                           str2.end(),
                           [](unsigned char x){return std::isspace(x);}),
            str2.end());

Algorithmuskomplexität: n

std::for_each

Rufen Sie eine Funktion in einer Schleife für einen Container auf
```
std::for_each(nums.begin(), nums.end(), [](int &n){ n++; });
```
Da C++11 for(auto var : vars)die bereichsbasierte for-Schleifensyntax einführt, verblasst der semantische Ausdruck von for_each im Vergleich. In den meisten Fällen kann for_each unnötig sein.
Algorithmuskomplexität: n

std::min_element/std::max_element

Suchen Sie das größte/kleinste Element im Container, indem Sie standardmäßig <den Vergleich verwenden
comp: Vergleichsfunktionsobjekt (dh ein Objekt, das die Anforderungen von Compare erfüllt), das „true“ zurückgibt, wenn das erste Argument kleiner als das zweite ist.
```
result = std::max_element(v.begin(), v.end(), [](int a, int b) {
     return std::abs(a) < std::abs(b);
 });
```
Algorithmuskomplexität: n