|
|
|
|
Dentro de este apartado veremos una serie de algoritmos que no pueden ser agrupados de forma lógica en ninguna de las categorías anteriores:
min()max()min_element() ()max_element()lexicographical_compare()next_permutation()prev_permutation()
template <class T>
inline const T& min(const T& a, const T& b) {
return b < a ? b : a;
}min() devuelve el menor de dos elementos.
template <class T>
inline const T& max(const T& a, const T& b) {
return a < b ? b : a;
}max() devuelve el mayor de dos elementos.
template <class ForwardIterator>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last) {
if (first == last) return first;
ForwardIterator result = first;
while (++first != last)
if (*first < *result) result = first;
return result;
}
template <class ForwardIterator, class Compare>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
Compare comp) {
if (first == last) return first;
ForwardIterator result = first;
while (++first != last)
if (comp(*first, *result)) result = first;
return result;
}
min_element() devuelve un iterador que apunta al menor elemento de una secuencia. También podemos utilizar la otra version para utilizar otra relación de orden diferente.
template <class ForwardIterator>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last) {
if (first == last) return first;
ForwardIterator result = first;
while (++first != last)
if (*result < *first) result = first;
return result;
}
template <class ForwardIterator, class Compare>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
Compare comp) {
if (first == last) return first;
ForwardIterator result = first;
while (++first != last)
if (comp(*result, *first)) result = first;
return result;
}max_element() recorre una secuencia y devuelve un iterador que apunta al mayor elemento. Como en el caso anterior podemos modificar la relación de orden utilizando la segunda version de la función.
template <class InputIterator1, class InputIterator2>
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2) {
for ( ; first1 != last1 && first2 != last2; ++first1, ++first2) {
if (*first1 < *first2)
return true;
if (*first2 < *first1)
return false;
}
return first1 == last1 && first2 != last2;
}
template <class InputIterator1, class InputIterator2, class Compare>
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
Compare comp) {
for ( ; first1 != last1 && first2 != last2; ++first1, ++first2) {
if (comp(*first1, *first2))
return true;
if (comp(*first2, *first1))
return false;
}
return first1 == last1 && first2 != last2;
}lexicographical_compare() compara dos secuencias de elementos y nos dice si son iguales.
template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first,
BidirectionalIterator last)
template <class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last,
Compare comp)next_permutation() se utiliza para generar permutaciones. Mientras puede generar permutaciones diferentes devuelve true. Devuelve false cuando ya han sido generadas todas las permutaciones posibles.
template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first,
BidirectionalIterator last)
template <class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last,
Compare comp)prev_permutation() al igual que el algoritmo anterior se utiliza para crear permutaciones. La unica diferencia entre ambos es la forma de generarlas. Dada una permutación podemos utilizar estos dos lagoritmos para crear nuevas y luego volver a recuperar la anterior.