Complexité algorithmique — 00 — Le code qui marche en dev et meurt en prod
Pourquoi un code rapide sur 100 lignes devient inutilisable sur 1 million. Introduction à la complexité algorithmique comme dette technique qui dort.
Articles : complexité
14 articles sur le thème "complexité".
Algorithmes de tri — 01 — Tri par sélection et tri par insertion
Les deux tris quadratiques fondamentaux : sélection et insertion. Principe, code en TypeScript et Python, complexité, stabilité, et pourquoi l'insertion est meilleure.
Graphes — 01 — Représenter un graphe : liste vs matrice d'adjacence
Les deux façons de stocker un graphe en mémoire : liste d'adjacence et matrice d'adjacence. Leurs coûts en temps et en mémoire, et comment choisir selon la densité.
Algorithmes de tri — 00 — Pourquoi étudier le tri quand sort() existe déjà
Tous les langages ont un tri intégré. Pourquoi comprendre les algorithmes de tri reste utile : choisir, déboguer, et raisonner sur la complexité.
Complexité algorithmique — 06 — Choisir la bonne structure de données
Une méthode pour choisir la structure de données adaptée à un problème réel : identifier l'opération chaude, puis sélectionner array, Set, Map ou structure triée.
Algorithmes de tri — 02 — Le tri à bulles, à connaître mais pas à utiliser
Le tri à bulles : principe, code, pourquoi il est O(n²), et pourquoi il sert surtout d'exemple pédagogique plutôt que d'outil de production.
Complexité algorithmique — 01 — La notation Big-O, lue sans maths
Comprendre O(1), O(log n), O(n), O(n log n), O(n²) et O(2ⁿ) avec des exemples de code et une intuition de la vitesse de croissance.
Complexité algorithmique — 05 — Les pièges qui transforment du code propre en O(n²)
Les erreurs de complexité les plus fréquentes en revue de code : includes dans une boucle, boucles imbriquées cachées, concaténation en O(n²), recalculs inutiles.
Complexité algorithmique — 04 — La complexité spatiale et le compromis temps/espace
La mémoire a un coût, comme le temps. Mesurer la complexité spatiale, comprendre le trade-off temps/espace, et savoir quand échanger l'un contre l'autre.
Recherche et tableaux — 00 — Du parcours naïf aux patterns efficaces
Introduction aux techniques de recherche sur tableaux : pourquoi le parcours naïf est souvent un O(n²) évitable, et les patterns qui le remplacent.
Complexité algorithmique — 02 — Compter les opérations et ignorer le bruit
Déterminer la complexité d'un code : compter les opérations, garder le terme dominant, ignorer les constantes, et distinguer cas pire, moyen et meilleur.
Complexité algorithmique — 03 — Le coût des structures de données
Array, liste chaînée, hashmap, Set, arbre équilibré : leurs coûts en Big-O pour l'accès, la recherche, l'insertion et la suppression, comparés dans un tableau.
Structures de données — 00 — Choisir une structure, c'est choisir un profil de coûts
Introduction à la série structures de données : pourquoi chaque structure est un compromis, ce que la série construit, et le lien avec la complexité algorithmique.
Clean code et refactoring - 11 - Complexite cyclomatique
Mesurer la complexité du code, la réduire, et comprendre son impact sur la testabilité