No hay una necesidad real de inicializar al menor / mayor posible para encontrar el menor / mayor en la matriz:
double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
if (array[i] < smallest)
smallest = array[i];
if (array[i] > largest0
largest= array[i];
}
O, si lo está haciendo más de una vez:
#include <utility>
template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
std::pair<typename iter::value_type, typename iter::value_type> ret;
ret.first = ret.second = *begin;
while (++begin != end) {
if (*begin < ret.first)
ret.first = *begin;
if (*begin > ret.second)
ret.second = *begin;
}
return ret;
}
La desventaja de proporcionar un código de muestra: veo que otros ya han sugerido la misma idea.
Tenga en cuenta que si bien el estándar tiene un elemento_mínimo y un elemento_máximo, usarlos requeriría escanear los datos dos veces, lo que podría ser un problema si la matriz es grande. Los estándares recientes han abordado esto agregando a std::minmax_element
, que hace lo mismo que el find_extrema
anterior (encuentre los elementos mínimo y máximo en una colección en una sola pasada).
Editar: Abordar el problema de encontrar el valor más pequeño distinto de cero en una matriz de unsigned: observe que los valores sin signo se "envuelven" cuando llegan a un extremo. Para encontrar el valor más pequeño distinto de cero, podemos restar uno de cada uno para la comparación. Cualquier valor cero "se ajustará" al valor más grande posible para el tipo, pero se mantendrá la relación entre otros valores. Una vez que terminamos, obviamente agregamos uno al valor que encontramos.
unsigned int min_nonzero(std::vector<unsigned int> const &values) {
if (vector.size() == 0)
return 0;
unsigned int temp = values[0]-1;
for (int i=1; i<values.size(); i++)
if (values[i]-1 < temp)
temp = values[i]-1;
return temp+1;
}
Tenga en cuenta que esto todavía usa el primer elemento para el valor inicial, pero aún no necesitamos ningún código de "caso especial", ya que se ajustará al valor más grande posible, cualquier valor distinto de cero se comparará como más pequeño. El resultado será el valor más pequeño distinto de cero, o 0 si y solo si el vector no contiene valores distintos de cero.