1000 Outils

Complexité algorithmique (Big-O)

Comprenez et comparez les complexités algorithmiques grâce à notre référence visuelle interactive. De O(1) constant à O(n!) factoriel, chaque complexité est illustrée avec des graphiques de croissance, des exemples concrets d'algorithmes et un tableau comparatif du nombre d'opérations. Un outil indispensable pour optimiser vos algorithmes et réussir vos entretiens techniques.

Comparaison visuelle de la croissance (n = 1 à 8)

O(1)
O(log n)
O(n)
O(n log n)
O(n²)
O(n³)
O(2ⁿ)
O(n!)
n=1
n=2
n=3
n=4
n=5
n=6
n=7
n=8

Détail des complexités

Nombre d'opérations selon la taille de l'entrée

Complexitén=10n=100n=1 000n=10 000
O(1)1111
O(log n)3,36,61013,3
O(n)101001 00010 000
O(n log n)3366410 000133 000
O(n²)10010 0001 000 000100 000 000
O(n³)1 0001 000 00010⁹10¹²
O(2ⁿ)1 0241,27 × 10³⁰
O(n!)3 628 800

Conseils pour optimiser vos algorithmes

  • Évitez les boucles imbriquées : deux boucles for imbriquées sur n éléments donnent O(n²). Cherchez une solution en O(n) ou O(n log n).
  • Utilisez les bonnes structures de données : une table de hachage (HashMap) offre O(1) pour la recherche au lieu de O(n) pour un tableau.
  • Divisez pour régner : les algorithmes qui divisent le problème en deux à chaque étape sont en O(log n) ou O(n log n).
  • Pensez au compromis espace/temps : stocker des résultats intermédiaires (memoization) peut transformer un O(2ⁿ) en O(n).

Qu'est-ce que la notation Big-O ?

La notation Big-O (ou notation asymptotique) décrit comment le temps d'exécution ou l'espace mémoire d'un algorithme évolue en fonction de la taille de l'entrée (n). Elle caractérise le comportement dans le pire cas quand n devient très grand. O(n) signifie que le temps croît linéairement avec la taille des données : doubler les données double le temps. O(n²) signifie que doubler les données quadruple le temps. Cette notation permet de comparer l'efficacité des algorithmes indépendamment du matériel.

Les complexités les plus courantes en pratique

En développement quotidien, vous rencontrez principalement O(1) pour l'accès en table de hachage, O(log n) pour la recherche binaire, O(n) pour le parcours de tableaux, O(n log n) pour les tris efficaces (merge sort, quick sort), et O(n²) pour les boucles imbriquées. La règle d'or : si votre algorithme a une complexité de O(n²) ou pire sur de grandes données, cherchez une meilleure approche. La plupart des problèmes courants ont une solution en O(n) ou O(n log n).

Comment analyser la complexité de votre code

Pour déterminer la complexité Big-O, identifiez les boucles : une boucle for sur n éléments est O(n), deux boucles imbriquées sont O(n²). Les appels récursifs qui divisent le problème en deux (dichotomie) sont O(log n). Les algorithmes diviser pour régner qui combinent division et itération (merge sort) sont O(n log n). Les constantes et termes inférieurs sont ignorés : O(3n + 5) se simplifie en O(n), O(n² + n) en O(n²). Seul le terme dominant compte pour les grandes valeurs de n.

Questions fréquentes

Outils similaires