Trouver la plus petite valeur dans un tableau le plus efficacement possible
Il y a N valeurs dans le tableau et l'une d'entre elles est la plus petite valeur. Comment puis-je trouver la plus petite valeur le plus efficacement possible?
S'ils ne sont pas triés, vous ne pouvez rien faire d'autre que regarder chacun d'eux, qui est O (N), et lorsque vous aurez terminé, vous connaîtrez le minimum.
Pseudo-code:
small = <biggest value> // such as std::numerical_limits<int>::max
for each element in array:
if (element < small)
small = element
Une meilleure façon rappelée par Ben pour moi était d’initialiser petit avec le premier élément:
small = element[0]
for each element in array, starting from 1 (not 0):
if (element < small)
small = element
Ce qui précède est encapsulé dans le algorithm header comme std :: min_element .
Si vous pouvez garder votre tableau trié au fur et à mesure que les éléments sont ajoutés, alors le trouver sera O (1), puisque vous pouvez garder le plus petit au premier plan.
C'est aussi bon que cela avec les tableaux.
Le stl contient un tas de méthodes qui devraient être utilisées dépendant du problème.
std::find
std::find_if
std::count
std::find
std::binary_search
std::equal_range
std::lower_bound
std::upper_bound
Maintenant, il contient sur vos données quel algorithme utiliser . Ce Artikel contient un tableau parfait pour vous aider à choisir le bon algorithme.
Dans le cas particulier où min max doit être déterminé et que vous utilisez std :: vector ou ??? * array
std::min_element
std::max_element
peut être utilisé.
Si vous voulez être vraiment efficace et que vous avez suffisamment de temps, utilisez l'instruction SIMD.
Vous pouvez comparer plusieurs paires dans une instruction:
r0 := min(a0, b0)
r1 := min(a1, b1)
r2 := min(a2, b2)
r3 := min(a3, b3)
__m64 _mm_min_pu8(__m64 a , __m64 b );
Aujourd'hui, chaque ordinateur le supporte. D'autres ont déjà écrit la fonction min pour vous:
http://smartdata.usbid.com/datasheets/usbid/2001/2001-q1/i_minmax.pdf
ou utilisez déjà prêt bibliothèque .
Vous devez également parcourir le tableau en vous rappelant la plus petite valeur que vous ayez vue jusqu'à présent. Comme ça:
int smallest = INT_MAX;
for (int i = 0; i < array_length; i++) {
if (array[i] < smallest) {
smallest = array[i];
}
}
Si le tableau est trié par ordre croissant ou décroissant, vous pouvez le trouver avec la complexité O (1) . Pour un tableau d'ordre croissant, le premier élément est le plus petit élément, vous pouvez l'obtenir avec arr [0] (0 indexation basée) . Si le tableau est trié par ordre décroissant alors le dernier élément est le plus petit élément, vous pouvez l'obtenir par arr [sizeOfArray-1].
Si le tableau n'est pas trié, vous devez parcourir le tableau pour obtenir le plus petit élément. Dans ce cas, la complexité temporelle est O (n), ici n est la taille du tableau.
int arr[] = {5,7,9,0,-3,2,3,4,56,-7};
int smallest_element=arr[0] //let, first element is the smallest one
for(int i =1;i<sizeOfArray;i++)
{
if(arr[i]<smallest_element)
{
smallest_element=arr[i];
}
}
Vous pouvez le calculer dans la section d'entrée (lorsque vous devez trouver le plus petit élément d'un tableau donné)
int smallest_element;
int arr[100],n;
cin>>n;
for(int i = 0;i<n;i++)
{
cin>>arr[i];
if(i==0)
{
smallest_element=arr[i]; //smallest_element=arr[0];
}
else if(arr[i]<smallest_element)
{
smallest_element = arr[i];
}
}
Aussi, vous pouvez obtenir le plus petit élément par la fonction intégrée
#inclue<algorithm>
int smallest_element = *min_element(arr,arr+n); //here n is the size of array
Vous pouvez obtenir le plus petit élément de toute plage en utilisant cette fonction Telle que,
int arr[] = {3,2,1,-1,-2,-3};
cout<<*min_element(arr,arr+3); //this will print 1,smallest element of first three element
cout<<*min_element(arr+2,arr+5); // -2, smallest element between third and fifth element (inclusive)
J'ai utilisé l'astérisque (*), avant la fonction min_element (). Parce qu'il retourne le pointeur du plus petit élément . Tous les codes sont en c ++ . Vous pouvez trouver l'élément maximum de la manière opposée.
Si trouver le minimum est une chose unique, parcourez simplement la liste et trouvez le minimum.
Si trouver le minimum est une chose très courante et que vous n'avez besoin que d'opérer sur le minimum, utilisez une structure de données Heap.
Un tas sera plus rapide que de faire un tri sur la liste mais le compromis est que vous ne pouvez trouver que le minimum.
Une solution O(1) peut être juste à deviner: le plus petit nombre dans votre tableau sera souvent 0. 0 apparaît partout. Étant donné que vous regardez uniquement les nombres non signés. Mais même dans ce cas: 0 est suffisant. En outre, examiner tous les éléments à la recherche du plus petit nombre est une vraie douleur. Pourquoi ne pas simplement utiliser 0? Cela pourrait effectivement être le bon résultat!
Si l'intervieweur/votre enseignant n'aime pas cette réponse, essayez 1, 2 ou 3. Ils se retrouvent également dans la plupart des tableaux numériques de devoirs/interviews-scénarios ...
D'un côté plus grave: À quelle fréquence devrez-vous effectuer cette opération sur le tableau? Parce que les sollutions ci-dessus sont toutes O (n). Si vous voulez le faire plusieurs fois sur une liste, vous ajouterez constamment de nouveaux éléments, pourquoi ne pas payer un peu de temps à l’avance et créer un tas? Ensuite, trouver le plus petit élément peut vraiment être fait en O (1), sans qu'il en résulte une tricherie.
Procédure:
Nous pouvons utiliser min_element (tableau, tableau + taille) fonction. Mais ce itérateur
qui retourne l'adresse de l'élément minimum. Si nous utilisons * min_element (array, array + size) , alors la valeur minimale de array sera renvoyée.
Implémentation C++
#include<bits/stdc++.h>
using namespace std;
int main()
{
int num;
cin>>num;
int arr[10];
for(int i=0; i<num; i++)
{
cin>>arr[i];
}
cout<<*min_element(arr,arr+num)<<endl;
return 0;
}
//find the min in an array list of #s
$array = array(45,545,134,6735,545,23,434);
$smallest = $array[0];
for($i=1; $i<count($array); $i++){
if($array[$i] < $smallest){
echo $array[$i];
}
}
//smalest number in the array//
double small = x[0];
for(t=0;t<x[t];t++)
{
if(x[t]<small)
{
small=x[t];
}
}
printf("\nThe smallest number is %0.2lf \n",small);
Si vous développez une sorte d'abstraction de votre propre tableau, vous pouvez obtenir O(1) si vous stockez la plus petite valeur ajoutée dans un attribut supplémentaire et le comparer à chaque fois qu'un nouvel élément est placé dans un tableau.
Ça devrait ressembler a quelque chose comme ca:
class MyArray
{
public:
MyArray() : m_minValue(INT_MAX) {}
void add(int newValue)
{
if (newValue < m_minValue) m_minValue = newValue;
list.Push_back( newValue );
}
int min()
{
return m_minValue;
}
private:
int m_minValue;
std::list m_list;
}
La réponse de Richie est proche. Cela dépend de la langue. Voici une bonne solution pour Java:
int smallest = Integer.MAX_VALUE;
int array[]; // Assume it is filled.
int array_length = array.length;
for (int i = array_length - 1; i >= 0; i--) {
if (array[i] < smallest) {
smallest = array[i];
}
}
Je parcoure le tableau dans l'ordre inverse, car comparer "i" à "array_length" dans la comparaison de boucle nécessite une extraction et une comparaison (deux opérations), tandis que comparer "i" à "0" correspond à une seule opération de code temporel de la JVM. Si le travail effectué dans la boucle est négligeable, la comparaison de boucle consomme une fraction considérable du temps.
Bien sûr, d'autres ont souligné qu'encapsuler la matrice et contrôler les insertions aideraient. Si obtenir le minimum était TOUT ce dont vous aviez besoin, il n'est pas nécessaire de conserver la liste dans l'ordre. Conservez simplement une variable d'instance qui contient la plus petite insérée jusqu'à présent et comparez-la à chaque valeur lorsqu'elle est ajoutée au tableau. (Bien sûr, cela échoue si vous supprimez des éléments. Dans ce cas, si vous supprimez la valeur la plus basse actuelle, vous devez analyser l'ensemble du tableau pour trouver la nouvelle valeur la plus basse.)