inicio GeNeura cursos

Otros algoritmos


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

Función

template <class T>
inline const T& min(const T& a, const T& b) {
  return b < a ? b : a;
}

Descripción

min() devuelve el menor de dos elementos.


max()

Función

template <class T>
inline const T& max(const T& a, const T& b) {
  return  a < b ? b : a;
}

Descripción

max() devuelve el mayor de dos elementos.


min_element()

Función

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;
}

Descripción

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.


max_element()

Función

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;
}

Descripción

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.


lexicographical_compare()

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;
}

Descripción

lexicographical_compare() compara dos secuencias de elementos y nos dice si son iguales.


next_permutation()

Función

template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first,
                      BidirectionalIterator last)

template <class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last,
                      Compare comp)

Descripción

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.


prev_permutation()

Función

template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first,
                      BidirectionalIterator last)

template <class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last,
                      Compare comp)

Descripción

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.