Il n'y a pas vraiment besoin de s'initialiser au plus petit / plus grand possible pour trouver le plus petit / le plus grand du tableau:
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];
}
Ou, si vous le faites plus d'une fois:
#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;
}
L'inconvénient de fournir un exemple de code - je vois que d'autres ont déjà suggéré la même idée.
Notez que bien que la norme ait un min_element et un max_element, leur utilisation nécessiterait de parcourir les données deux fois, ce qui pourrait poser un problème si le tableau est grand. Des normes récentes ont résolu ce problème en ajoutant un std::minmax_element
, qui fait la même chose que find_extrema
ci - dessus (trouvez à la fois les éléments minimum et maximum dans une collection en un seul passage).
Edit: Résoudre le problème de la recherche de la plus petite valeur non nulle dans un tableau de unsigned: observez que les valeurs non signées «s'enroulent» lorsqu'elles atteignent un extrême. Pour trouver la plus petite valeur non nulle, nous pouvons soustraire une de chacune pour la comparaison. Toute valeur nulle sera "enveloppée" à la plus grande valeur possible pour le type, mais la relation entre les autres valeurs sera conservée. Une fois que nous avons terminé, nous en rajoutons évidemment un à la valeur que nous avons trouvée.
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;
}
Notez que cela utilise toujours le premier élément pour la valeur initiale, mais nous n'avons toujours pas besoin de code de «cas spécial» - puisque cela se terminera par la plus grande valeur possible, toute valeur non nulle sera comparée comme étant plus petite. Le résultat sera la plus petite valeur différente de zéro, ou 0 si et seulement si le vecteur ne contient aucune valeur différente de zéro.