Vérifier si un tableau contient un élément en C++

1. Utiliser une boucle pour vérifier si un tableau contient un élément en C++
2. Utilisez std::find pour vérifier si un tableau contient un élément en C++
3. Utilisez Std::Count pour vérifier si un tableau contient un élément en C++
4. Utilisez std::binary_search pour vérifier si un tableau contient un élément en C++
5. Utilisez la fonction any_of() pour vérifier si un tableau contient un élément en C++
6. Conclusion

Lorsque vous travaillez avec des tableaux en C++, vous devrez peut-être également vérifier si un tableau contient un élément en C++. Bien que cela puisse être fait simplement en utilisant une boucle, d’autres moyens efficaces peuvent faire la même chose.

Cet article vous guidera à travers les différentes façons de vérifier si un élément est présent dans un tableau en C++. Continuer à lire.

La bibliothèque standard de C++ fournit des algorithmes et des fonctions que nous pouvons utiliser pour vérifier si un tableau contient un élément en C++. Mais voyons d’abord comment nous pouvons utiliser une boucle pour ce faire.

Utiliser une boucle pour vérifier si un tableau contient un élément en C++

Vous pouvez utiliser une boucle for pour garder les choses très simples. Ici, dans le code ci-dessous, nous avons un tableau appelé points et un élément que nous devons rechercher nommé key.

À l’intérieur du bloc main, nous utilisons une boucle for pour parcourir tous les éléments de manière linéaire. A chaque itération, nous vérifions si l’élément courant est le même que l’élément que nous recherchons.

Si l’élément key est trouvé, la boucle se rompt et la valeur de la variable booléenne, present, est mise à jour à false. Plus tard, en fonction de la valeur de cette variable, present, nous imprimons la sortie souhaitée.

Exemple de code :

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  bool present = false;
  for (int i : points) {
    if (i == key) {
      present = true;
      break;
    }
  }
  if (present) {
    cout << "The element is present";
  } else {
    cout << "The elment is not present";
    return 0;
  }

Production:

The element is present

Bien que ce soit le moyen le plus simple de rechercher un élément dans un tableau, il existe d’autres moyens plus efficaces de faire de même. Nous en discuterons dans les sections suivantes.

Utilisez std::find pour vérifier si un tableau contient un élément en C++

La fonction std::find est principalement utilisée pour rechercher un élément dans une plage spécifique. Cette fonction recherche l’élément recherché dans la plage [first, last).

Syntaxe:

InputIterator find(InputIterator first, InputIterator last, const T& val);

Vous trouverez ci-dessous le code qui utilise la fonction std::find pour rechercher un élément dans un tableau. Ici, nous utilisons une variable booléenne, present, et la fonction std::find pour itérer sur le tableau points.

La fonction std::find prend trois arguments :

1. la variable points, qui sert d’itérateur pour la position initiale du tableau
2. l’expression points+x, qui sert d’itérateur pour la dernière position du tableau
3. et la variable key, qui est la valeur à rechercher

Si une valeur n’est pas trouvée, cette fonction renvoie l’itérateur à la fin du tableau, mais nous pouvons imprimer l’instruction souhaitée en fonction de la valeur present de la variable.

Exemple de code :

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  int x = sizeof(points) / sizeof(*points);

  bool present = std::find(points, points + x, key) != points + x;

  if (present) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;
}

Production:

The element is present

Si le passage des arguments mentionnés ci-dessus est déroutant, vous pouvez également passer deux itérateurs au début et à la fin du tableau en utilisant respectivement les fonctions begin() et end().

Exemple de code :

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  bool present = std::find(begin(points), end(points), key) != end(points);

  if (present) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;
}

Production:

The element is present

Voyez comment nous pouvons utiliser directement les fonctions begin() et end() pour simplifier le code. Cela fonctionne exactement comme les arguments du code précédent.

Utilisez Std::Count pour vérifier si un tableau contient un élément en C++

Une autre façon pourrait être d’utiliser l’algorithme std::count. Essentiellement, cet algorithme compte le nombre de fois qu’un élément est vu dans une plage donnée.

Si la valeur renvoyée du compte n’est pas zéro, cela implique que l’élément est présent dans le tableau. L’algorithme std::count compte également les occurrences d’un élément entre la plage [first, last).

Syntaxe:

int counter(Iterator first, Iterator last, T &val)

Regardez le code pour comprendre comment cela fonctionne.

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  cout << std::count(begin(points), end(points), key);
}

Production:

2

Voyez comment nous passons les arguments requis à cette fonction et affichons le résultat. Etant donné que la valeur key 56 est présente à deux endroits dans le tableau points, nous obtenons la sortie sous la forme 2.

Maintenant, nous allons fusionner ceci avec une variable booléenne, present, pour vérifier si le nombre de la variable key est supérieur à zéro ou non. Si oui, cela signifie simplement que l’élément est présent dans le tableau.

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  bool present = std::count(begin(points), end(points), key) > 0;

  if (present) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;
}

Production:

The element is present

Naturellement, cet algorithme est plus lent en termes de performances que std::find car il parcourt tout le tableau pour trouver le nombre d’un élément.

Utilisez std::binary_search pour vérifier si un tableau contient un élément en C++

Si un tableau est trié, le moyen le plus efficace de vérifier si un tableau contient un élément en C++ est d’utiliser l’algorithme de recherche binaire. La bibliothèque standard de C++ fournit un algorithme binary_search pour faire de même.

L’algorithme std::binary_search retourne la valeur true si l’élément est trouvé dans la plage [first, last). Sinon, il renvoie false.

Dans le code ci-dessous, nous avons créé une fonction appelée checkEle() à l’intérieur de laquelle nous trions d’abord le tableau à l’aide de la fonction sort(), puis utilisons l’algorithme std::binary_search pour rechercher l’élément key.

Exemple de code :

#include <algorithm>
#include <iostream>
using namespace std;

bool checkEle(int a[], int x, int key) {
  if (x <= 0) {
    return false;
  }
  sort(a, a + x);
  return std::binary_search(a, a + x, key);
}

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  int x = sizeof(points) / sizeof(*points);

  bool present = checkEle(points, x, key);

  if (present) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;
}

Production:

The element is present

Ceci n’est utile que lorsque le tableau est déjà trié car utiliser d’abord la fonction sort() pour trier le tableau augmente encore la complexité temporelle.

Utilisez la fonction any_of() pour vérifier si un tableau contient un élément en C++

Nous pouvons utiliser la fonction any_of() pour vérifier si un prédicat est conforme à tous les éléments présents dans une plage donnée. Si oui, il renvoie true ; sinon, il renvoie false.

Syntaxe:

template <class InputIterator, class UnaryPredicate>
bool any_of(InputIterator begin, InputIterator end, UnaryPredicate p);

Regardez le code pour comprendre comment le prédicat est défini. Ici, en plus d’appeler la fonction any_of(), nous utilisons également la condition and qui vérifie simultanément si l’élément actuel est égal à la key que nous recherchons.

Si la condition est satisfaite pour n’importe quel élément, alors la valeur de la variable booléenne present est mise à jour en true.

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;

int main() {
  int points[] = {23, 45, 56, 12, 34, 56};
  int key = 56;

  bool present =
      std::any_of(begin(points), end(points), [&](int i) { return i == key; });

  if (present) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;
}

Production:

The element is present

C’est ainsi que la fonction any_of() peut rechercher un élément dans un tableau. Il s’agit de la façon dont nous pouvons rechercher un élément dans un tableau en C++.

Conclusion

Cet article a présenté diverses approches pour vérifier si un tableau contient un élément en C++. Nous avons vu comment une simple boucle for est utilisée pour cela en C++ et avons également travaillé avec des algorithmes comme std::find, std::count et std::binary_search.

Bien que toutes ces méthodes atteignent le même objectif. C’est totalement à vous de décider de la meilleure approche que vous aimez.