ALGORITHMIQUE POUR L`APPRENTI PROGRAMMEUR

ALGORITHMIQUE POUR
L’APPRENTI PROGRAMMEUR
Auteur externe, gasche, Quentin
29 octobre 2015

Table des matières
1 Introduction 5
1.1 But du tutoriel ................................... 5
1.2 Prérequis ...................................... 5
1.3 Historique ..................................... 6
2 Présentation de la notion de complexité algorithmique 7
2.1 Qu’est-ce qu’un algorithme ? ............................ 7
2.1.1 Omniprésence des algorithmes ....................... 7
2.1.2 Rôle privilégié des ordinateurs ........................ 7
2.1.3 Notion de structure de données ....................... 8
2.2 Les grenouilles partent en vacances ........................ 8
2.2.1 Situation ................................... 8
2.2.2 Les deux possibilités ............................. 9
2.2.3 Comparaison ................................. 10
2.3 La notion de complexité .............................. 12
2.3.1 Correction de l’algorithme .......................... 12
2.3.2 Complexité ................................. 12
2.3.3 Mesure ‘asymptotique’ ............................ 13
2.3.4 Notation “grand O” ............................. 14
2.3.5 Complexité en temps, complexité mémoire ................. 15
2.3.6 Complexité dans le pire des cas ....................... 16
2.4 Un peu de pratique ................................. 17
2.4.1 Qu’est-ce qu’on attend de vous ? ....................... 17
2.4.2 Chercher le plus grand / petit élément .................... 18
2.4.3 Trouver les éléments uniques ........................ 19
2.4.4 Trouver les éléments uniques : autre solution ................ 21
3 Premiers exemples de structures de données et d’algorithmes courants 23
3.1 Notions de structures de données : tableaux et listes chaînées ........... 23
3.1.1 Définition .................................. 23
3.1.2 Ajout / retrait, taille, accès à un élément ................... 26
3.1.3 Concaténation, filtrage ............................ 29
3.1.4 Synthèse ................................... 33
3.2 Une classe d’algorithme non naïfs : diviser pour régner ............... 36
3.2.1 Gagner au jeu du ‘Plus ou Moins’ ....................... 36
3.2.2 Dichotomie : Recherche dans un dictionnaire ................ 36
3.2.3 Calcul de la complexité ............................ 37
3.2.4 Trouver un zéro d’une fonction ........................ 39
3.2.5 Diviser pour régner : exponentiation rapide ................. 42
3.3 Introduction au problème du tri .......................... 44
3.3.1 Formuler le problème du tri ......................... 44
3

Table des matières
3.3.2 Tri par sélection ............................... 45
3.3.3 Implémentation du tri par sélection ..................... 47
3.3.4 Le retour du “diviser pour régner” : Tri fusion ................ 51
4 Quelques autres structures de données courantes 63
4.1 Piles et files .................................... 63
4.1.1 Concept ................................... 63
4.1.2 Mise en pratique ............................... 64
4.2 Arbres ....................................... 67
4.2.1 Définition .................................. 68
4.2.2 Quelques algorithmes sur les arbres ..................... 70
4.2.3 Parcours en profondeur ........................... 72
4.2.4 Parcours en largeur ............................. 73
4.2.5 Comparaison des méthodes de parcours ................... 75
5 Conclusion 79
4

1 Introduction
[[information]] | Ce tutoriel a été initialement rédigé par bluestorm, lastsseldon et Cygal
Vous venez d’apprendre les bases d’un langage de programmation ? Vous vous êtes peut-être
rendu compte que parfois, en modifiant un peu votre programme, vous pouvez obtenir le même
résultat mais 2, 10 ou 1000 fois plus vite ?
De telles améliorations ne sont pas le fruit du hasard, ni même dues à une augmentation de la mé-
moire vive ou à un changement de processeur : il y a plusieurs manières de programmer quelque
chose et certaines sont incroyablement meilleures que d’autres.
Avec un peu de réflexion, et des outils théoriques de base, vous serez vous aussi en mesure de faire
de bons choix pour vos programmes. À la fin de ce tutoriel, vous serez de meilleurs développeurs,
en mesure de comprendre, corriger et concevoir des programmes plus efficaces.
1.1 But du tutoriel
Les deux notions clés de ce tutoriel sont les suivantes : la complexité, et les structures de don-
nées. La complexité est une manière d’estimer les performances d’un algorithme. Les structures
de données sont la manière dont vous organisez les informations dans votre programme. En choi-
sissant une structure de données adaptée, vous serez capables de coder des opérations très per-
formantes (de faible complexité).
Chaque algorithme résout un problème donné. Pour chaque problème, il existe un ou plusieurs
algorithmes intéressants (mais on en découvre de nouveaux tous les ans !). Nous vous présente-
rons, dans ce tutoriel, un petit panorama de problèmes “courants”, dans le but de vous familiari-
ser avec la complexité et les structures de données. Vous apprendrez par exemple à chercher un
élément qui vous intéresse à l’intérieur d’un ensemble d’éléments, à trier un ensemble, ou même
à trouver le plus court chemin d’un “endroit” à un autre.
1.2 Prérequis
Le but de ce tutoriel n’est pas de vous apprendre à programmer. Pour le lire, vous devez déjà
savoir programmer. L’apprentissage de l’algorithmique n’utilise pas de concepts bas niveau (as-
sembleur, etc.) ou de bibliothèques logicielles spécialisées (SDL, Qt…), mais vous devez être à
l’aise avec les variables, conditions, boucles et fonctions. La connaissance du concept de ‘récursi-
vité’ (si vous vous sentez en manque, il y a déjà un tuto à ce sujet sur le ZDS) est aussi un avantage.
Le langage que vous utilisez n’est pas très important, car on tentera de formuler les algorithmes
d’une manière qui en est indépendante. Nous donnerons aussi, pour les curieux, des exemples
dans quelques langages de programmation. Si vous n’y voyez pas le vôtre, trouvez-en un suffi-
samment proche, et faites un petit effort. :)
5