0229 Formation Algorithmie Cryptographie PDF

Algorithmique
http://alexandre-mesle.com
30 octobre 2008
Table des matières
1 Complexité des algorithmes 6

1.1 Borne asymptotique supérieure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 Mesure de temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Algorithmes en temps constant, O(1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2 Algorithmes de complexité linéaire, O(n) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3 Algorithmes de complexité logarithmique, O(logn) . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.4 Algorithmes de complexité quadratique O(n2 ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.5 Algorithmes de complexité O(n.logn) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.6 Algorithmes de complexité exponentielle O(k n ), k > 1 . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.7 Algorithmes de complexité polynomiale O(nk ), k fixé . . . . . . . . . . . . . . . . . . . . . . . 7
2 Algorithmes itératifs 9
2.1 Invariants de boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.1 Le principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Terminaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Le principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2 Fin de l’exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.3 Un autre exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3 Récursivité 14
3.1 Sous-programmes récursifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.1.1 Factorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Sous-programmes récursifs terminaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.1 Factorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.2 Exponentiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.3 Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Listes chaı̂nées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3.1 Notations et conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3.2 Rédaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 Exemple de calcul de complexité d’un algorithme récursif . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.1 L’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.2 Résolution exacte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.3 Vérification par récurrence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.4 Problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4.5 L’heure du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4 Arbres 33
4.1 Définitions par induction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.1.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.1.3 Expressions arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1
4.1.4 Application aux arbres binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2 Preuves par induction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2.1 Lien avec les preuves par récurrence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2.2 Application aux EATPs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.3 Algorithmique dans les arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.4 Arbres n-naires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5 Files de priorité 36
5.1 Implémentations naı̈ves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2 Tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2.2 Extraction du minumum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.3 Insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.4 Suppression du minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.5 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3 Tas binomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.1 Arbre binomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.2 Fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.3 Tas binomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.4 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.5 Extraction du minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.6 Fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6 Hachage 40
6.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.2 Collisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.2.1 Gestion des collisions par chaı̂nage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.2.2 Gestion des collisions par adressage ouvert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7 AVL 42
7.1 Arbres binaires de recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
7.2 Complexité dans le pire de cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.3 Rotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.4 AVLs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4.1 Rééquilibrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4.2 Insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4.3 Suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4.4 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
8 Modélisation 51
8.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.2.1 Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.2.2 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.2.3 Question . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.3 Sensibilisation à la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.3.1 Le tour de la table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.3.2 De la terre à la Lune . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.3.3 En bref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4.1 Difficulté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4.2 Rappels de théorie des graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4.3 Définition d’un problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4.4 Problèmes d’optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5 Problèmethèque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2
8.5.1 Arbre couvrant de poids minimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5.2 Ensemble stable maximal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5.3 Circuit eulérien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5.4 Circuit hamiltonien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.5.5 Voyageur de commerce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.5.6 SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.5.7 Couverture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.5.8 Coloration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.5.9 Plus court chemin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.5.10 Sac à dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9 Programmation linéaire 61
9.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.2 Algorithme du simplexe en bref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.3 Modéliser un programme linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.4 GLPK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.4.1 Qu’est-ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.4.2 Où le trouver ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.4.3 La documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.4.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
10 Théorie de la complexité 68
10.1 Terminologie et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.1.1 Problèmes de décision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.1.2 Instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.1.3 Algorithme polynomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.2 Les classes P et NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.2.1 La classe P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.2.2 La classe NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.2.3 Relations d’inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.3 Réductions polynomiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.3.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.3.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.3.3 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.4 Les problèmes NP-complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.4.1 Courte méditation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.4.2 3-SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.4.3 Conséquences déprimantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.4.4 Un espoir vain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
11 Introduction la cryptographie 74
11.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
11.2 La stéganographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
11.3 Les chiffres symétriques sans clé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
11.4 Les chiffres symétriques à clé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.4.1 Le chiffre de Vigenère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.4.2 Enigma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.5 Les algorithmes asymétriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.5.1 Un peu d’histoire[1] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
11.5.2 Le principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3
12 GnuPG 77
12.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.2.1 Génération d’une clé privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.2.2 Exportation de la clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.2.3 Importation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.2.4 Liste des clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
12.2.5 Chiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
12.2.6 Déchiffrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
12.2.7 Signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
12.2.8 Bref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
13 GMP 80
13.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
13.2 Quelques points délicats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
13.2.1 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
13.2.2 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
13.2.3 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
13.2.4 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
13.2.5 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
13.2.6 Pour terminer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
14 Arithmétique 84
14.1 Divisibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
14.2 Division euclidienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
14.3 PGCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
14.4 Nombres premiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
14.5 Nombres premiers entre eux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
14.6 Décomposition en produit de facteurs premiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
14.6.1 Application à la divisibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
14.6.2 Application au calcul du PGCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.7 Théorème de Bezout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.7.1 Théorème de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.8 Algorithme d’Euclide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.8.1 Algorithme d’Euclide pour le PGCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.8.2 Algorithme d’Euclide étendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
14.8.3 Morceaux choisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
14.8.4 Applications avec GMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
15 Arithmétique modulaire 91
15.1 Congruences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
15.2 Rappels d’algèbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
15.2.1 Monoı̈des . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
15.2.2 Groupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
15.2.3 Anneaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
15.2.4 Corps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
15.2.5 Relations d’équivalence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
15.3 Espaces quotients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
15.3.1 Classes d’équivalence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
15.3.2 Z/nZ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
15.4 Inverses modulaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
15.4.1 Eléments inversibles et fonction φ d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
15.4.2 Pratique de l’inversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4
16 RSA 97
16.0.3 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
16.0.4 Résistance aux attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
A Corrigés des programmes 99

A.1 Fonctions récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
A.2 Fonctions récursives terminales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
A.3 Itérateurs et applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
A.4 Tours de Hanoı̈ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
A.5 Suite de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
A.6 Pgcd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
A.7 Pavage avec des L . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
A.8 Complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
A.9 Listes chaı̂nées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
A.10 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
A.11 Tri par insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
A.12 Transformée de Fourier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A.13 Polynômes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
A.14 Tas binomiaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
A.15 AVL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
A.16 Knapsack par recherche exhaustive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
A.17 Prise en main de GLPK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
A.18 Le plus beau métier du monde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
A.19 Prise en main de GMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
A.20 Algorithme d’Euclide étendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
A.21 Espaces Quotients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
B Rappels mathématiques 157

B.1 Sommations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
B.1.1 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
B.2 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
B.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
B.2.2 Opérations ensemblistes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
B.2.3 Cardinal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
B.2.4 n-uplets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
B.2.5 Parties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
B.2.6 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
B.2.7 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
B.2.8 Classification des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
B.2.9 Application réciproque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
B.3 Raisonnements par récurrence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
B.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
B.3.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
B.3.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
B.4 Analyse combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
B.4.1 Factorielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
B.4.2 Arrangements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
B.4.3 Combinaisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
B.4.4 Triangle de Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
B.4.5 Liens avec les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
B.5 Exercices récapitulatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
B.5.1 Echauffement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
B.5.2 Formule de Poincaré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
B.5.3 La moulinette à méninges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
5
Chapitre 1
Complexité des algorithmes
Un algorithme, programmé dans un langage différent, ou lancé sur une machine différente, ne mettra pas le temps
à exécuter. Il serait pourtant important de trouver un moyen de mesurer son temps d’exécution, pour le comparer par
exemple à d’autres algorithmes. Nous nous intéresserons à un critère, appelé complexité dans le pire des cas, qui
nous permettra d’évaluer les performances d’un algorithme en terme de temps d’exécution.
1.1 Borne asymptotique supérieure

Une suite u est de borne asymptotique supérieure v si pour n assez grand, u est majorée par v à une constante
près. Plus formellement,
Définition 1.1.1 un ∈ O(vn ) si ∃N ∈ IN, ∃k ∈ IR, ∀n ≥ N, un ≤ k.vn

Pour n supérieur à N , u est majorée par k.v, donc par v à la constante k près. Si N et k existent, alors un ∈ O(vn ).
En pratique, on utilise la propriété suivante :
un
Propriété 1.1.1 un ∈ O(vn ) ssi lim =l
n−→+∞ vn
un
Plus simplement, un ∈ O(vn ) si vn converge vers une constante (notée l dans la propriété).
1.2 Mesure de temps d’exécution

Un algorithme prend en entrée une quantité de données que nous noterons en règle générale n, par exemple la taille
d’un tableau, le nombre d’élément d’une liste chaı̂née, le nombre de noeuds d’un graphe, etc. Nous considérerons le
nombre d’opérations un exécuté par l’algorithme et tenterons de classifier u en utilisant une fonction v. Ce critère est
intéressant pour plusieurs raisons :
– Quelle que soit le temps que mette une machine particulière à exécuter une opération, nous compterons le nombre
d’opérations.
– Se limiter au dénombrement des opérations n’est pas suffisant, ce qui nous intéresse vraiment est la façon dont
le nombre d’opérations effectuées par l’algorithme croı̂t en fonction du nombre n de données.
Nous considérerons en règle générale le temps d’exécution dans le pire des cas. Quelques bornes asymptotiques
supérieures sont à considérer avec un attention particulière :
1.2.1 Algorithmes en temps constant, O(1)

Un algorithme est en temps constant si son temps d’exécution est indépendant du nombre de données. Par exemple,
retourner le premier élément d’une liste chaı̂née. En effet, que la liste contienne un seul élément ou 1010 éléments, le
temps d’exécution de l’algorithme ne variera pas en fonction de n.
6
1.2.2 Algorithmes de complexité linéaire, O(n)
Un algorithme est de complexité linéaire si le temps de calcul croı̂t de façon linéaire en fonction du nombre de
données. Si vous traitez deux fois plus de données, le temps d’exécution sera multiplié par deux. Par exemple, la
recherche séquentielle dans un tableau non trié est de complexité linéaire. En effet, on effectue une recherche en
parcourant le tableau avec une boucle (ou un algorithme récursif). Chacune des itérations se fait en temps constant,
il suffit donc de compter le nombre d’itérations. Dans le pire des cas, l’élément que l’on recherche est celui qui est
examiné en dernier. Il est donc nécessaire d’effectuer n itérations.
1.2.3 Algorithmes de complexité logarithmique, O(logn)

Un algorithme de complexité algorithmique croit de façon linéaire en fonction de 2n , cela signifie que pour doubler
le temps d’exécution, il faut mettre au carré le nombre de données. Par exemple, la recherche par dichotomie dans un
tableau trié. Si le tableau contient 230 éléments, il faudra à peu près 30 itérations pour trouver l’élément recherché,
contre 230 avec une recherche séquentielle. Pour la plupart, ces algorithmes sont dans la pratique très performants.
1.2.4 Algorithmes de complexité quadratique O(n2 )

Certains algorithmes de tri, par exemple, sont construits avec deux boucles imbriquées, et effectuent un nombre
d’itérations de l’ordre de n2 . Bon nombre de problèmes pour lesquels il existe des algorithmes quadratiques admettent
aussi des algorithmes de meilleure complexité.
1.2.5 Algorithmes de complexité O(n.logn)

D’autres algorithmes de tri sont de complexité O(n.logn), c’est le meilleur résultat qu’il est possible d’obtenir avec
des tris de comparaisons.
1.2.6 Algorithmes de complexité exponentielle O(k n ), k > 1

Ces algorithmes sont tellement longs à l’exécution, qu’on ne les utilise presque jamais. Malheureusement, il existe
des problèmes pour lesquels les seuls algorithmes de résolution exacte connus à l’heure actuelle sont de complexité
exponentielle.
1.2.7 Algorithmes de complexité polynomiale O(nk ), k fixé

Nous appelons ainsi tous les algorithmes dont le temps d’exécution peut être majoré par un polynôme. Nous
utiliserons le terme polynomial par opposition à exponentiel. En algorithmique, il sera très important de faire la
différence entre les algorithmes polynomiaux, utilisables en pratique, et les algorithmes exponentiels, inutilisables en
pratique.
Exercice 1 - Tableaux
Déterminer la complexité dans le pire cas (précisez quel est ce pire cas) des opérations suivantes sur un tableau
t = [t1 , . . . , tn ] à n éléments non triés,
1. Affichage du k-ème élément de t.
2. Affichage des éléments de t.
3. Calcul de la somme cumulée des éléments de t.
4. Décalage vers la droite de la tranche [tk , . . . , tn ] et insertion d’un élément au rang k.
5. Décalage vers la gauche de la tranche [tk+1 , . . . , tn ] pour supprimer tk .
6. Recherche séquentielle d’un élément.
7. Vérification de l’appartenance de chaque élément de t à un tableau q non trié.
7
Exercice 2 - Listes chaı̂nées
Déterminer la complexité dans le pire des cas (précisez de quel cas il s’agit) des opérations ci-dessous sur une liste
chaı̂née l = l1 −→ l2 −→ . . . −→ ln à n éléments non triés. La seule information à notre disposition au début de
l’exécution de chacun de ces algorithmes est un pointeur vers le premier élément de la liste. :
1. Affichage du k-ème élément de l.
2. Affichage des éléments de l.
3. Calcul de la somme cumulée des éléments de l.
4. Suppression du premier élément.
5. Suppression de l’élément de rang k, adresse du (k − 1)-ème élément connue.
6. Suppression de l’élément de rang k, adresse du (k − 1)-ème élément inconnue.
7. Recherche séquentielle d’un élément.
8. Vérification de l’appartenance de chaque élément de l à une liste q non triée.
Exercice 3 - Tri par sélection

Le tri par sélection d’un tableau [t1 , . . . , tn ] se fait comme suit. On fait varier i de 1 à n − 1. Pour chaque itération
de i, on recherche dans la tranche [ti , . . . , tn ] le plus petit élément et on l’échange avec ti . Déterminer la complexité
du tri par sélection.
Exercice 4 - Hauteur minimale d’un arbre binaire

Un arbre binaire est un arbre dont chaque noeud a 2 fils. Un arbre vide, donc sans noeud, noté ∅, est de profondeur
h(∅) = −1. Un noeud est une feuille si ses deux fils sont des arbres vides. Soit x un noeud, l et r ses fils la hauteur de x
est alors h(x) = 1 + max(h(l), h(r)). La hauteur d’un arbre binaire est la hauteur de son noeud de hauteur maximale,
donc de la racine. La racine r est de profondeur p(r) = 0, tout noeud x de père y est de profondeur p(x) = p(y) + 1.
1. Quelle est la hauteur d’une feuille d’un arbre binaire ?
2. Comment disposer les noeuds pour que la hauteur d’un arbre binaire à n noeuds soit minimale ?
3. Nous ne considérerons dorénavant que des arbres binaires dans lesquels les noeuds sont disposés comme décrit
dans la question précédente. Soit A un arbre de profondeur h, déterminer pour tout k ∈ {0, . . . , h − 1} le nombre
de noeuds de A dont la profondeur est k.
4. Encadrer le nombre de noeuds de profondeur h.
5. Donner la borne inférieure du nombre n de noeuds d’un arbre binaire de profondeur h.
6. Majorer h en fonction de n.
7. Donner une borne asymptotique supérieure de la hauteur h d’un arbre binaire à n noeuds de hauteur minimale.
8
Chapitre 2
Algorithmes itératifs
Un algorithme itératif est contruit avec des boucles, par opposition à récursif qui remplace les boucles par ds appels
à lui-même.
2.1 Invariants de boucle

2.1.1 Le principe
On prouve la validité d’un algorithme itératif à l’aide de la méthode des invariants de boucle.
Définition 2.1.1 Un invariant de boucle est une propriété qui est vraie à chaque passage dans la boucle.
On raisonne par récurrence pour montrer qu’une telle propriété est préservée à chaque itération de la boucle. Elle
suffit à prouver la validité de l’algorithme si elle est trivialement vraie à la première itération et qu’à la dernière
itération, sa véracité entraı̂ne celle de l’algorithme. Voyons cela sur un exemple.
2.1.2 Exemple
On divise deux entiers strictement positifs a et b en déterminant deux entiers q et r tels que a = bq + r avec
0 ≤ r < b. Voici un algorithme déterminant q et r :
q ←− 0
r ←− a
tant que r ≥ b
q ←− q + 1
r ←− r − b
fin tant que
On choisit comme invariant de boucle la propriété a = bq + r.

– Comme q est initialisé à 0 et r à a, alors la propriété a = bq + r = b.0 + a est vérifiée avant le premier passage
dans la boucle.
– Avant une itération arbitraire, supposons que l’on ait a = bq + r, montrons que cette propriété est conservée
par cette itération. Soient q ′ la valeur de q à la fin de l’itération et r′ la valeur de r à la fin de l’itération. Nous
devons montrer que a = bq ′ + r′ . On a q ′ = q + 1 et r′ = r − b, alors bq ′ + r′ = b(q + 1) + (r − b) = bq + r = a.
La propriété est bien conservée.
2.2 Terminaison
2.2.1 Le principe
La démonstration ci-dessus est incomplète, d’une part on n’a pas démontré que le programme s’arrêtait, et de plus
rien ne montre (pour le moment) que s’il s’arrête, on aura bien 0 ≤ r < b. On montre qu’un programme s’arrête en
9
prouvant que la séquence formée par les valeurs des variables au fil des itérations converge vers une valeur satisfaisant
la condition d’arrêt.
2.2.2 Fin de l’exemple

– Commençons par montrer que le programme s’arrête. La séquence formée par les valeurs de r au fil des itérations
est strictement décroissante. Il y a donc nécessairement un moment où la valeur de r sera strictement inférieure
à celle de b.
– Maintenant, nous pouvons terminer la preuve de validité :
– Si le programme s’arrête, c’est que la condition du Tant que n’est plus satisfaite, donc que r < b.
– Il reste à montrer que r ≥ 0. Comme r est diminué de b à chaque itération, si r < 0, alors à l’itération
précédente la valeur de r était r′ = r + b, or r′ = r + b < b car r < 0. Nous venons de montrer que si r
était strictement négatif, alors la boucle se serait arrêtée à l’itération précédente, ce qui est absurde. Donc
nécessairement r ≥ 0.
Résumons, le programme s’arrête avec 0 ≤ r < b et la propriété a = bq + r est vérifiée à chaque itération, ces deux
propriétés nous démontrent que l’algorithme effectue bien la division de a par b.
2.2.3 Un autre exemple

Déterminons un algorithme qui calcule le produit de deux entiers a et b avec a positif ou nul sans effectuer de
multiplication.
p ←− 0
m ←− 0
tant que m < a
p ←− p + b
m ←− m + 1
fin tant que
– Montrons que le programme se termine. La séquence formée par les valeurs prises par m au fil des itérations est
strictement croissante, il y a donc un moment où m ≥ a. Donc l’algorithme se termine.
– Considérons comme invariant de boucle p = m.b, montrons par récurrence qu’il est vérifiée.
– m est p sont initialisés à 0, on a bien 0 = 0.b.
– montrons maintenant que la propriété est conservée. Supposons qu’au début d’une itération donnée, on ait
p = m.b. Soient p′ et m′ les valeurs de ces variables à la fin de cette itération, montrons que l’on a p′ = m′ .b.
On a les relations p′ = p + b et m′ = m + 1. Donc p′ = p + b = m.b + b = (m + 1).b = m′ .b. La propriété est
donc conservée par chaque itération de l’algorithme.
– La première de valeur de m qui nous fera sortir de la boucle est a, donc après la dernière itération on aura
p = mb = ab. Ce programme place donc dans p le produit de a par b.
Exercice 1 - Exponentiation
Ecrire un algorithme de calcul de bn où n est un entier positif ou nul. Prouver sa terminaison et sa validité.
Exercice 2 - Plus grand élément

Ecrire un algorithme de recherche du plus grand élément dans un tableau. Prouvez sa terminaison et sa validité.
On rappelle que m est le plus grand élément du tableau T = [T1 , . . . , Tn ] si les deux conditions suivantes sont vérifiées :
– ∀i ∈ {1, . . . , n}, m ≥ Ti
– ∃j ∈ {1, . . . , n}, m = Tj
Exercice 3 - Tri par insertion

Nous allons écrire et démontrer la validité de l’algorithme du tri par insertion. Nous rappelons que T = [T1 , . . . , Tn ]
est trié si ∀i ∈ {1, . . . , n − 1}, Ti ≤ Ti+1 . Etant donné le programme suivant :
10
Procédure insere(T, k)
i ←− k tant que i > 0 ∧ T [i − 1] > T [i]
echanger(T [i − 1], T [i])
i ←− i − 1
fin tant que
FIN
Prouver que si on passe en paramètre à insere un tableau T dont les k − 1 premiers éléments sont triés, alors à la
fin de son exécution, les k premiers éléments dont triés. Etant donné le programme suivant :
Procédure triInsertion(T [n])
pour i ∈ {2, . . . , n}
insere(T, i)
fin pour
FIN
Démontrer la terminaison et la validité de triInsertion.

Voici le corrigé de la première question : L’algorithme se termine bien car les valeurs prises par i forment une
séquence de nombres entiers strictement décroissante. Si l’on ne sort pas de la boucle avec Ti−1 ≤ Ti , on aura forcément
i = 1 après la dernière itération. Prenons comme invariant de boucle la conjonction des conditions suivantes :
– La tranche T1 , . . . , Ti−1 est triée
– La tranche Ti , . . . , Tk est triée
– i < k ⇒ Ti−1 ≤ Ti+1
Prouvons cette propriété par récurrence :
– A la première itération, on a i = k. Comme T1 , . . . , Ti correspond à la tranche T1 , . . . , Tk−1 donc par hypothèse
cette tranche est triée. La tranche Ti , . . . , Tk est réduite au seul élément Tk , elle est donc nécessairement triée.
Comme ¬(i < k), la troisième condition est trivialement vérifiée.
– Supposons qu’au début d’une itération arbitraire, les trois propriétés soient vérifiées. Soient i′ la valeur de i et
T ′ le tableau T à la fin de cette itération. Montrons alors que
– La tranche T1′ , . . . , Ti′′ −1 est triée
– La tranche Ti′′ , . . . , Tk′ est triée
– i′ < k ⇒ Ti′′ −1 ≤ Ti′′ +1
D’une part, on a i > 1 et Ti−1 > Ti . Par ailleurs, i′ = i − 1, Ti−1 ′
= Ti et Ti′ = Ti−1 . Tous les autres éléments de
′
T et de T coı̈ncident. Montrons les trois propriétés :
– Par hypothèse de récurrence, la tranche T1 , . . . , Ti−1 est triée, donc la tranche T1 , . . . , Ti−1 que l’on obtient en
ne comptabilisant pas le dernier élément est aussi triée. Comme les éléments de T et T ′ d’indices différents de
i et i + 1 sont les mêmes et que i − 1 = i′ , alors T1′ , . . . , Ti′′ est triée.
– Par hypothèse de réccurrence Ti , . . . , Tk est triée, en ne considérant pas le premier élément, on a Ti+1 , . . . , Tk ,
comme les éléments de cette tranche coı̈ncident avec T ′ , alors Ti′′ +2 , . . . , Tk′ est triée. Par ailleurs, on a Ti′′ = Ti
et Ti′′ +1 = Ti−1 , comme Ti−1 > Ti , alors Ti′′ < Ti′′ +1 . Si i < k, alors par hypothèse de récurrence, on a
Ti−1 ≤ Ti+1 , donc Ti′′ +1 ≤ Ti′′ +2 . Dans ce cas, on a Ti′′ < Ti′′ +1 ≤ Ti′′ +2 avec Ti′′ +2 , . . . , Tk′ triée. Donc
Ti′′ , . . . , Tk′ est triée. Si i = k, alors la tranche Ti′′ , . . . , Tk′ est réduite aux deux éléments Ti′′ < Ti′′ +1 , elle est
donc triée.
– Quelle que soit la valeur de i, on a nécessairement i′ < k, il faut donc montrer que Ti′′ −1 ≤ Ti′′ +1 . Or
Ti′′ −1 = Ti−2 et Ti′′ +1 = Ti−1 . Par hypothèse de récurrence, T1 , . . . , Ti−1 est triée, donc on a Ti−2 ≤ Ti−1 , d’où
Ti′′ −1 ≤ Ti′′ +1 .
Après la denière itération, si i = 1, alors la première tranche ne contient aucun élément et la deuxième condition
de l’invariant de boucle permet de conclure que toute la tranche T1 , . . . , Tk est triée. Si par contre, on sort de la boucle
parce que Ti−1 ≤ Ti , alors comme, d’après l’invariant de boucle, T1 , . . . , Ti−1 et Ti , . . . , Tk sont triées, alors T1 , . . . , Tk
est triée.
Exercice 4 - Tri à bulle

Ecrire et démontrer la validité de l’algorithme du tri à bulle.
11
2.3 Complexité
On détermine la complexité d’un programme itératif en comptant le nombre d’itérations. Lorsque deux boucles
sont imbriquées, on est amené à compter pour chaque itération de la boucle principale le nombre d’itérations de la
boucle imbriquée et à les additionner. Par exemple,
pour i ∈ {1, . . . , n − 1}
pour j ∈ {i + 1, . . . , n}
(* opération en O(1) *)
fin pour
fin pour
A l’itération i de l’algorithme, la boucle imbriquée effectue n − (i + 1) + 1 = n − i itérations. On détermine donc

le nombre total d’itérations en sommant les n − i, donc avec
n−1
X ((n − 1) − 1 + 1)(n − 1 + n − (n − 1)) (n − 1)n
(n − 1) + (n − 2) + . . . + (n − (n − 1)) = (n − i) = = ∈ O(n2 )
i=1
2 2
Exercice 5 - Sommations
Simplifier les sommes suivantes :
n+2
X
– i
i=1
n
X
– i+1
i=0
P n
– en i=1 ln(i)
X
– (3i − 2)
i=1
n n−1
X X
– 1
i=1 j=i
Xn n−1
X
– (3( 1) − 2)
i=1 j=i
n+3
X
– (i − 1)
i=5
Xn
– (2n − 3i)
i=1
Exercice 6 - Tris quadratiques

Calculer les complexités du tri par insertion et du tri à bulle.
Morceaux choisis
Exercice 7 - Polynômes
n
X
Nous représenterons un polynôme P (x) = p0 xn + p1 xn−1 + . . . + pn−1 x + pn = pi xn−i de degré n à l’aide d’un
i=0
tableau [p0 , p1 , . . . , pn−1 , pn ] à n + 1 éléments. Notez bien que ce tableau est indicé à partir de 0.
12
1. Que fait la fonction suivante ?
Fonction mystery([p0 , . . . , pn ], x)
somme ←− 0
pour i ∈ {0, . . . , n}
terme ←− 1
j ←− 1
tant que j ≤ n − i
terme ←− terme × x
j ←− j + 1
fin tant que
terme ←− terme × pi
somme ←− somme + terme
fin pour
retourner somme
FIN
2. Quelle est la complexité de mystery ?

3. Écrire la procédure derive([p0 , . . . , pn ]) remplaçant p par sa dérivée.
k+1 k
!
X X
4. Prouver que pi xk+1−i = x pi xk−i + pk+1
i=0 i=0
5. Déduire de la relation ci-dessus une fonction evalue([p0 , . . . , pn ], x) prenant P et x en paramètres, et retournant
P (x).
6. Prouver la validité de la fonction d’évaluation, vous utiliserez les questions précédentes.
7. Quelle est la complexité de evalue ?
Exercice 8 - Tranche minimale

Etant donné un tableau T [n], un tranche est une suite d’éléments contigüs de T . Une tranche [Ti , . . . , Tj ] est
entièrement déterminée par l’indice i de début et l’indice j de fin. La valeur de la tranche [Ti , . . . , Tj ] est donnée par
la somme
j
X
Vij = Tk
k=i
Nous souhaitons mettre au point un algorithme de recherhe de la tranche minimale.

1. Ecrivez un algorithme construit avec trois boucles imbriquées. Calculez sa complexité.
2. Utilisez le fait que Vij+1 = Vij + T [j + 1] pour écrire un algorithme construit avec deux boucles imbriquées.
Calculez sa complexité.
ˆ
3. Soient Mij la valeur de la tranche minimale incluse dans la tranche [Ti , . . . , Tj ], et soit Mij la tranche minimale
ˆ
de [Ti , . . . , Tj ] contenant Tj . Donnez une relation entre Mij+1 , Mij et Mij .
4. En déduire un algorithme de recherche de la tranche minimale construit avec une seule boucle. Déterminer sa
complexité.
13
Chapitre 3
Récursivité
3.1 Sous-programmes récursifs

Un sous-programme récursif est un sous-programme qui s’appelle lui-même. Par exemple :
Procédure countDown(n)
si n ≥ 0 alors
af f icher(n)
countDown(n − 1)
fin
FIN
Ce sous-programme affiche n si celui-ci est positif ou nul, puis se rappelle en passant n − 1 en paramètre. Il va se
rappeler jusqu’à ce que le paramètre prenne la valeur −1, affichant ainsi un compte à rebours dont la dernière valeur
affichée sera 0. Lorsque qu’un sous-programme se rappelle, on dit qu’il effectue un appel récursif. Pour observer ce
que cela fait, considérez le programme suivant :
#include<s t d i o . h>
void countDown ( i nt n )
{
i f ( n >= 0 )
{
p r i n t f ( ”%d\n” , n ) ;
countDown ( n − 1 );
}
}
i nt main ( )
{
countDown ( 1 0 ) ;
return 0 ;
}
Il affiche
10
9
8
7
6
5
4
14
3
2
1
0
Observons bien la procédure countdown :

– La première chose faite est le test n ≥ 0, il faut toujours tester la condition d’arrêt avant de faire quoi que ce
soit. Si cela n’est pas fait correctement, le sous-programme peut boucler indéfiniment.
– Dans l’appel récursif, la valeur n − 1, et non pas n, est passée en paramètre. Si vous ne faites pas décroı̂tre la
valeur de n, le sous-programme se comportera de façon identique à chaque appel récursif, donc bouclera.
– L’appel récursif est fait après l’affichage de n, si vous permutez l’affichage et l’appel récursif, les nombres seront
affichés dans l’ordre croissant. un sous-programme est récursif terminal si la dernière instruction exécutée est
un appel récursif, ce qui est le cas ici.
Beaucoup de sous-programmes sont beaucoup plus faciles à implémenter de façon récursive. Un sous-programme
utilisant des boucles mais pas la récursivité est dit itératif. Comme la récursivité permet d’éviter de faire des boucles,
on oppose souvent la mode récursif au mode itératif. On exposera divers algorithmes s’implémentant naturellement
de façon récursive, notamment le tri fusion, et les algorithmes dans les listes et les arbres. Pour le moment nous nous
limiterons au calcul de valeurs définies par récurrence.
3.1.1 Factorielle
Soit n un nombre entier positif ou nul, le nombre n!, dit ”factorielle n”, est défini comme suit :
n
Y
n! = 1 × 2 × . . . × n = i
i=1
avec le cas particulier 0! = 1. On observe que
n! = [1 × . . . × (n − 1)] × n = [(n − 1)!] × n

Cette relation nous permet de réduire le calcul de la factorielle d’un nombre n au calcul de la factorielle de n − 1.
En utilisant cette relation on obtient un algorithme récursif calculant la factorielle d’un nombre n.
Fonction f actorielle(n)
si n = 0 alors
retourner 1
sinon
retourner n × f actorielle(n − 1)
fin
FIN
– Observez bien que la condition d’arrêt est testée dès le début de l’exécution de l’algorithme, et qu’elle permet
de calculer la valeur 0!
– Dans le cas général, le calcul n! se fait en passant par le calcul de (n − 1)!. Comme la valeur passée en paramètre
dans l’appel récursif est n − 1 et est strictement inférieure à n, alors la séquence des valeurs passées en paramètre
au fil des appels récursifs
n −→ n − 1 −→ . . . −→ 1 −→ 0
est strictement décroissante et converge vers 0. Il est très important de vérifier que quelques soient les valeurs
passées en paramètre, la séquence de valeurs formée par les appels récursifs converge vers une valeur satisfaisant
la condition d’arrêt, 0 dans le cas présent.
– On remarque par ailleurs que cet algorithme n’est pas récursif terminal, en effet l’appel récursif précède une
multiplication par n, la dernière instruction n’est donc pas un appel récursif.
Les doutes des plus sceptiques seront, je l’espère apaisés par la vue du sous-programme suivant :
long f a c t o r i e l l e ( long n )
{
i f ( n == 0 )
15
return 1 ;
return n ∗ f a c t o r i e l l e ( n − 1 ) ;
}
Exercice 1 - Opérations arithmétiques entières

Considérez l’algorithme suivant :
Fonction addition(a, b)
si a = 0 alors
retourner b
sinon
retourner 1 + addition(a − 1, b)
fin
FIN
1. Quelle relation arithmétique utilise-t-il ?

2. Modifiez-le pour qu’il puisse additionner des nombres négatifs.
3. Ecrivez un algorithme récursif soustrayant deux nombres de signes quelconques.
4. Ecrivez un algorithme récursif multipliant deux nombres de signes quelconques.
5. Ecrivez un algorithme récursif divisant deux nombres de signes quelconques.
6. Ecrivez un algorithme récursif calculant ab , avec des valeurs de b entières positives ou nulles.
Exercice 2 - La fonction mystery

Considérons la fonction suivante :
Fonction mystery(n)
si n = 0 alors
retourner 2
sinon
retourner [mystery(n − 1)]2
fin
FIN
1. Que fait cette fonction ?

2. Prouvez par récurrence votre conjecture de la question précédente.
n
3. Écrire une fonction récursive mysteryBis(a, b, n) sur le même modèle que mystery retournant a(b ) . Vous utili-
m
serez la fonction puissance(x, m) qui retourne x .
4. Prouvez la validité de mysteryBis.
3.2 Sous-programmes récursifs terminaux

Bon nombre de sous-programmes non terminaux peuvent être réécrits de façon terminale. Cela se fait par l’ajout
d’un paramètre, appelé accumulateur. La forme d’un programme récursif terminal est la suivante :
Fonction f (. . . , r)
si conditionDArret alors
retourner r
sinon
instructions
fin
FIN
Il faut faire en sorte qu’une fois la condition d’arrêt vérifiée le paramètre r contienne le résultat.
16
3.2.1 Factorielle
Étudions un exemple,
Fonction f actorielleT (n, r)
si n = 0 alors
retourner r
sinon
retourner f actorielleT (n − 1, r × n)
fin
FIN
Tout d’abord, on remarque que f actorielleT est bien une fonction récursive terminale. Ensuite observons que si
l’on invoque f actorielleT (n, 1), on obtient la séquence suivante :
(n, 1) −→ (n − 1, n) −→ (n − 2, n × (n − 1)) −→ . . .
n
Y
. . . −→ (i, k) −→ . . .
k=i+1
n
Y n
Y n
Y
. . . −→ (2, k) −→ (1, k) −→ (0, k)
k=3 k=2 k=1
Qn
Au moment où la condition d’arrêt est vérifiée, le paramètre r contient la valeur k=1 k, à savoir n!. On se sert de
l’accumulateur pour fabriquer le résultat. Démontrons par récurrence sur n que f actorielleT (n, r) = r(n!) :
– Tout d’abord, on constate que f actorielleT (0, r) = r
– Supposons que f actorielleT (n − 1, r′ ) retourne la valeur (n − 1)! × r′ , donc f actorielleT (n − 1, n × r) = (n −
1)!(r × n) = r(n!). D’où f actorielleT (n, r) = f actorielleT (n − 1, n × r) = r(n!)
On en déduit qu’en posant r = 1, on a f actorielleT (n, 1) = n! On encapsule f actorielleT dans le sous-programme
f actorielle que l’on redéfinit de la sorte :
Fonction f actorielle(n)
retourner f actorielleT (n, 1)
FIN
3.2.2 Exponentiation
Essayons de créer une fonction récursive terminale calculant bn , comme cette valeur s’obtient par des multiplications
successives, l’accumulateur a est une valeur par lequel le résultat sera multiplié. Nous souhaitons donc mettre un point
une fonction puissanceT (a, b, n) qui retourne a(bn ). On obtiendra bn en initialisant a à 1. On détermine une relation
de récurrence entre bn et bn−1 de la sorte : bn = b.bn−1 , donc abn = (ab)bn−1 , à savoir puissanceT (a × b, b, n − 1).
Allons-y,
Fonction puissanceT (a, b, n)
si n = 0 alors
retourner a
sinon
retourner puissanceT (a × b, b, n − 1)
fin
FIN
Prouvons par récurrence sur n que puissanceT (a, b, n) = abn .

– On a bien puissanceT (a, b, 0) = a = ab0
– Supposons que puissanceT (a′, b, n − 1) = a′ bn−1 , donc puissanceT (ab, b, n − 1) = (ab)bn−1 = abn . D’où
puissanceT (a, b, n) = puissanceT (ab, b, n − 1) = abn .
17
On calcule donc bn en invoquant puissanceT (1, b, n). On redéfinit puissance(b, n) de la sorte :
Fonction puissance(b, n)
retourner puissanceT (1, b, n)
FIN
Vous avez des doutes ? Traduisez donc ces sous-programmes en C en observez ce qui se passe...
Exercice 3 - Récursion terminale

Reprennez tous les sous-programmes de l’exercice précédent et rédigez-les sous forme récursive terminale. Vous
prouverez par récurrence la validité de chacune d’elle.
3.2.3 Itérateurs
Exercice 4 - Introduction aux itérateurs
Etant donné une fonction f , on note f n la composition de f par elle-même n fois. Par exemple : f 3 = f ◦ f ◦ f , si
f : x 7→ x + 1, alors f 3 (x) = f (f (f (x))) = x + 3. Par convention, on a f 0 = id, avec id : x 7→ x.
1. Si f : x 7→ x + 1, démontrez par récurrence que f n : x 7→ x + n
2. Si f : x 7→ 2x, démontrez par récurrence que f n : x 7→ 2n x
3. Si f : x 7→ x2 , démontrez par récurrence que f n : x 7→ x( 2n )
4. Ecrire une fonction récursive applyF non terminale prenant en paramètre une fonction f , un nombre n et un
argument x, et retournant f n (x). Ce type de fonction sera appelé un itérateur.
5. Ecrire une version récursive terminale de applyF .
6. Soit f : (a, b) 7→ (a + b, b), montrez par récurrence que f n : (0, b) 7→ (bn, b)
7. Ecrire une fonction f prenant en paramètre le couple (a, b) et retournant (a + b, b).
8. Ecrire la fonction multiplie en utilisant f et applyF .
Exercice 5 - Applications des itérateurs

1. Réfléchir à un moyen d’implémenter les itérateurs en C, n’oubliez pas que la fonction itérée peut prendre et
retourner plusieurs paramètres.
2. Pour des raisons de lisibilité du code, nous utiliserons des structures pour représenter les couples. Cela a pour
inconvénient un manque de généricité de la fonction f . Utiliser des tableaux offrirait une souplesse optimale mais
alourdirait considérablement le code du fait des allocations et libérations de la mémoire nécessaires. Implémentez
en C la fonction multiplie de l’exercice précédent, vous utiliserez bien évidemment un itérateur.
3. Ecrivez la fonction f actorielle à l’aide d’un itérateur, démontrez sa validité et traduisez-là en C.
4. Ecrivez la fonction puissance à l’aide d’un itérateur, démontrez sa validité et traduisez-là en C.
Exercice 6 - Itérateurs et aspirine

Dans les questions précédentes, l’itérateur faisait décroı̂tre n de 1 à chaque appel récursif. Soit f la fonction à itérer
et x la valeur en 0, nous pouvons définir un tel itérateur I de la sorte :
– I(f, n, x) = f (I(f, n − 1, x))
– I(f, 0, x) = x
Nous étendons une telle fonction en ajoutant en paramètre une fonction de décrément δ, on obtient :
– I(δ, f, n, x) = f (n, I(δ, f, δ(n), x))
– I(δ, f, 0, x) = x.
1. Implémentez la fonction I(δ, f, n, x) en en utilisant le prototype suivant unsigned long applyFD(int (*delta)(int
k), unsigned long (*f)(couple), int n, unsigned long x).
2. Ecrivez une fonction f telle que I(δ, f, n, b) = bn , vous utiliserez la relation de récurrence bn = b.bn−1 et b0 = 1
et poserez δ : x 7→ x − 1.
18
3. Prouvez que I(δ, f, n, b) = bn
4. Ecrivez en C la fonction unsigned long slowPuissanceIT(unsigned long b, unsigned long n), vous utili-
serez applyFD et traduirez en C les fonctions f et δ définies dans la question préccédente.
5. Ecrivez deux fonctions f et δ telles que I(δ, f, n, 1) = n!
6. Prouvez que I(δ, f, n, 1) = n!
7. Ecrivez en C la fonction unsigned long fatorielleIT(unsigned long b, unsigned long n), vous utiliserez
applyFD.
8. Ecrivez une fonction récursive f astP uissance(b, n) calculant bn sans utiliser d’itérateur, vous utiliserez le fait
n n
que bn = (b2 ) 2 si n est pair et bn = b(b2 )⌊ 2 ⌋ sinon.
9. Traduisez-là en C en utilisant le prototype suivant unsigned long fastPuissance(unsigned long b, unsigned
long n).
10. Majorez le nombre d’appels récursifs en fonction de n, est-ce performant ?
11. Ecrivez la fonction f et la fonction δ de sorte que I(δ, f, n, b) = bn . Notez le fait que f prend le couple (n, b) en
paramètre.
12. Prouvez par récurrence la validité de I(δ, f, n, b) = bn .
13. Ecrivez en C la fonction unsigned long fastPuissanceIT(unsigned long b, unsigned long n), vous utili-
serez la fonction applyFD.
Exercice 7 - Itérateurs et nombres de Fibonacci

Fn 1 1 Fn
1. Soit , un vecteur de deux nombres de fibonacci consécutifs. Que donne le produit ?
Fn−1 1 0 Fn−1
n
1 1 F1 Fn+1
2. Prouvez par récurrence que = .
1 0 F0 Fn

1 1
3. On calcule donc le n-ème nombre de Fibonacci en mettant préalablement la matrice à la puissance
1 0
n. Nous allons utiliser pour ce faire la même règle que pour f astP uissance. Ecrivez une fonction multM at
prenant
en paramètre
deux quadruplets
(x11 , x12 , x21 , x22 ) et (y11 , y12 , y21 , y22 ) représentant deux matrices X =
x11 x12 y11 y12
et Y = . multM at retourne un quadruplet représentant le produit matriciel XY .
x21 x22 y21 y22
4. Définir une fonction matP ow(X, n) mettant un matrice X, à la puissance n. Vous utiliserez I(δ, multM at, n, X).
5. Ecrire une fonction multM atV ec retournant le produit d’une matrice, représentée par un quadruplet, et d’un
vecteur, représenté par un couple.
6. Ecrire en C la fonction quadruplet applyFDQ(int (*delta)(int k), unsigned long (*f)(int, quadruplet),
int n, quadruplet x), vous utiliserez le même modèle mathématique, mais en transmettant comme deuxième
paramètre à f un quadruplet.
7. Ecrire la fonction f astF ibonacci(n), retournant le n-ième nombre de fibonacci.
8. Quelle est la complexité de f astF ibonacci ?
9. Implémenter les fonctions :
(a) quadruplet multMat(quadruplet x, quadruplet y)
(b) quadruplet applyFDQ(unsigned long (*delta)(unsigned long), quadruplet (*f)(unsigned long,
quadruplet), unsigned long n, quadruplet x
(c) quadruplet matPow(quadruplet x, unsigned long n)
(d) couple multMatVec(quadruplet x, couple y)
(e) unsigned long fastFibonacciIT(unsigned long l).
19
3.3 Listes chaı̂nées
3.3.1 Notations et conventions
La récursivité est particulièrement adaptée lorsque l’on souhaite manipuler des listes chaı̂nées. Nous utiliserons
pour ce faire les fonctions suivantes :
1. premier(l) retourne la donnée se trouvant dans le premier élément de la liste chaı̂née l.
2. suivants(l) retourne un pointeur l′ vers le deuxième élément de l, cette fonction ne produit aucun effet de bord
et ne modifie pas le chaı̂nage.
3. ajoute(z, l) ajoute la donnée z au début de la liste l et retourne un pointeur vers la liste obtenue, elle modifie
le chaı̂nage.
4. estV ide(l) retourne vrai si et seulement si la liste l ne contient aucun élément.
5. listeV ide() retourne une constante que nous identifierons à la liste vide, c’est-à-dire ne contenant aucun élément.
Vous prendrez soin de ne pas confondre les listes et les données. Ces dernières sont génériques, vous pouvez placer
dans une liste des données de n’importe quel type, même d’autres listes... Nous noterons mathématiquement les listes
entre des crochets, par exemple [1, 4, 3, 7]. La liste vide, retournée par la fonction listeV ide() sera notée []. Vous pourrez
créer une liste à un élément par exemple en écrivant
ajoute(4, listeV ide())

Cette instruction crée la liste [4]. Pour créer une liste à deux éléments, vous utiliserez le même principe :
ajoute(3, ajoute(4, listeV ide()))

Cette instruction crée la liste [3, 4]. Les éléments de la liste sont indicés à partir de 1. Nous ne gérerons pas la
mémoire, on considérera qu’un garbage collector s’en occupera.
3.3.2 Rédaction
Les règles de la récursivité sont les mêmes quand on manipule des listes chaı̂nées, on teste le cas de base en premier :
la liste vide, et on fait en sorte que la séquence formée par les valeurs passées en paramètre au file des appels récursifs
converge vers la liste vide. Par exemple,
Procédure sommeListe(l)
si estV ide(l) alors
retourner 0
sinon
retourner premier(l) + sommeListe(suivants(l))
fin
FIN
Cette fonction retourne la somme des éléments de l.
Exercice 8 - Prise en main

Ecrire les fonctions suivantes en pseudo-code :
– listP rint(l), affiche les éléments de la liste l.
– listDeleteByIndex(l, k) retourne une liste contenant les éléments de la liste l sauf celui d’indice k.
– listDeleteByV alue(l, a), retourne une liste contenant les éléments de l sauf le premier rencontré à avoir la valeur
a.
– listDeleteAllByV alue(l, a), retourne une liste contenant les éléments de l sauf tous les éléments ayant la valeur
a.
– listOcurrences(l, a), retourne une liste contenant les indices de toutes les ocurrences de a dans l.
– listIndexesU nsorted(l, i) retourne une liste contenant tous les éléments de la liste l dont l’indice se trouve dans
la liste i. i n’est pas supposée triée.
20
–
– listIndexesSorted(l, i) retourne une liste contenant tous les éléments de la liste l dont l’indice se trouve dans la
liste i. i est supposée triée.
– listDeleteByIndexes(l, i) retourne une liste contenant tous les éléments de l dont l’indice se trouve dans i, i est
supposée triée.
Exercice 9 - Tris
Ecrire les fonctions suivantes en pseudo-code :
– listInsert(l, a), insère la donnée k dans la liste l, retourne un pointeur vers le premier élément de la liste.
– listInsertionSort(l), retourne les éléments de l triés par la méthode du tri par insertion.
– listSplit(l), retourne un couple de listes (m, n) dans lesquelles ont été repartis de façons arbitraire les éléments
de l et telle que le nombre de données de m et n diffère au plus de 1.
– listM erge(l1, l2), retourne une liste l triée contenant les éléments de l1 et de l2. l1 et l2 sont supposées triées.
– listF usionSort(l) retourne une liste contenant les éléments de l triés avec la méthode du tri fusion.
3.4 Exemple de calcul de complexité d’un algorithme récursif

3.4.1 L’algorithme
La complexité d’un algorithme récursif s’exprime en règle générale par l’intermédiaire d’une relation de récurrence.
Par exemple, l’affichage des éléments d’une liste chaı̂née, donné par l’algorithme suivant :
Procédure af f icheListe(l)
si ¬estV ide(l) alors
af f icher(premier(l))
af f icheListe(suivants(l))
fin
FIN
Soit un le nombre d’instructions élémentaires exécutées par af f icheListe si la liste l comporte n maillons. Si n = 0,
l’algorithme s’exécute en temps constant. Sinon, l’appel récursif nécessite un−1 opérations, les autres opérations (au
nombre de k) s’exécutent en temps constant. On définit donc u comme suit : un = un−1 + k, comment exprimer un
en fonction de u0 , de n et de k ?
3.4.2 Résolution exacte

Il apparaı̂t que u est une suite arithmétique de raison k et de premier terme u0 , donc un = u0 + kn. Comme
u0 + kn
−→ k, alors un ∈ O(n), donc af f icheListe est de complexité linéaire. On remarque que, dans ce type
n
de suite, uo et k sont des valeurs n’ayant pas de conséquence sur le caractère linéaire de la complexité de ce type
d’algorithme. On se permettra donc, dans la plupart des cas, de les remplacer par 1. Nous aurons donc les fois
suivantes u0 = 1 et un = un−1 + 1, le résultat, en terme de complexité sera le même.
3.4.3 Vérification par récurrence

Il est fréquent que l’on ne parvienne pas à exprimer un en fonction de u0 et de n, certaines récurrences sont très
difficile à résoudre. Une autre façon de classifier une suite un dans un O est de conjecturer ce O, puis de le démontrer
par récurrence. Par exemple, démontrons par récurrence que un ∈ O(n). Si c’est le cas, supposons que un est majorée
par une suite linéaire, c’est à dire de la forme an + b. Choisissons b tel que b ≥ u0 = 1 et a > 1.
– L’hypothèse sur b implique que a(0) + b ≥ u0 .
– Supposons que si an + b ≥ un , alors montrons que a(n + 1) + b ≥ un+1 . On a un+1 = un + 1 ≤ an + b + 1 ≤
an + b + a = a(n + 1) + b.
21
On montre aisément que a et b choisis conformément aux conditions précédant la démonstration par récurrence
an + b
détermine une suite an + b qui majore un . On remarque que an + b croı̂t de façon linéaire, en effet −→ a, donc
n
on a an + b ∈ O(n). Comme un est majorée par une suite linéaire, un ∈ O(n).
Prouvons pour le sport que si un ≤ vn et vn ∈ O(wn ), alors un ∈ O(wn ). Comme vn ∈ O(wn ), alors ∃k, ∃N, ∀n >
N, vn ≤ k.wn , comme un ≤ vn , alors pour les mêmes valeurs k et N , un ≤ vn ≤ k.wn et de ce fait un ≤ k.wn .
Deux ensembles de méthodes ressortent dans les exemples :
– La résolution exacte, elle nécessite le connaissance de bon nombre de méthodes mathématiques, bien qu’élégante,
elle devient vite très compliquée.
– La conjecture d’une majoration suivie d’une preuve par récurrence de cette majoration. La preuve est en règle
générale plus simple à mettre en oeuvre, la partie la plus difficile est de conjecturer une majoration valide et la
moins grossière possible.
3.4.4 Problèmes
Exercice 10 - Tours de Hanoı̈
On dispose de n disques numérotés de 1 à n. Les disques peuvent être empilés sur des socles à partir du moment
où tout disque repose sur un disque de numéro plus élevé. On dispose de trois socles S1 , S2 et S3 , les n disques sont
empilés sur le socle de gauche S1 , ceux du milieu et de droite S2 et S3 sont vides. Le but est de déplacer toute la
pile de disques sur le socle de droite, sachant qu’on ne peut déplacer les disques que un par un, et qu’il ne faut qu’à
aucun moment, un disque numéroté k se trouve sur un disque numéroté m avec m < k (i.e un disque plus petit). Par
exemple, si n = 3, on a
1
2
3
------------
2
3 1
------------
3 2 1
------------
1
3 2
------------
1
2 3
------------
1 2 3
------------
2
1 3
------------
1
2
3
------------
On dispose d’un sous-programme deplaceDisque(Si, Sj ) qui enlève le disque se trouvant au sommet de la pile Si
et la place au sommet de la pile Sj .
1. Trouver un algorithme récursif deplaceDisques(n, Sf rom, Svia , Sto ) permettant de déplacer n disques du socle
Sf rom au socle Sto en utilisant Svia comme socle intermédiaire.
2. Codez en C un programme qui affiche chaque étape du déplacement des n disques, que remarquez-vous lorsque
l’on prend des grandes valeurs de n ?
22
3. Déterminer une relation de récurrence permettant de dénombrer le nombre d’étapes nécessaires pour déplacer n
disques. Résolvez-là.
4. Est-il envisageable de déplacer 100 disques en un temps raisonnable ?
Exercice 11 - Suite de Fibonacci

1. Ecrire une fonction récursive unsigned long fibo(unsigned long l) calculant le n-ème nombre de fibonacci
Fn défini par récurrence de la sorte : Fn = Fn−1 + Fn−2 avec F0 = 0 et F1 = 1.
2. Soit un le nombre d’appels récursifs nécessaires pour calculer Fn . Prouvez par récurrence que un ≥ Fn .
3. Exprimer Fn en fonction de n en résolvant la récurrence linéaire.
4. Déterminer la complexité de fibo en passant par une borne asymptotique inférieure.
5. On considère la fonction φ : (a, b) 7→ (a + b, a). Prouvez que φ(Fn−1 , Fn−2 ) = (Fn , Fn−1 ).
6. On note φk la composition de k fonctions φ. Par exemple, φ2 = φ ◦ φ et φ2 (a, b) = φ(φ(a, b)) = φ(a + b, a) = (2a +
b, a+b). Par convention, φ0 est la fonction identité, notée id. Prouver par récurrence que (Fn+1 , Fn ) = φn (F1 , F0 )).
7. Implémentez φ avec le sous-programme void phi(unsigned long* l1, unsigned long* l2), notez que les
deux variables l1 et l2 sont passées en paramètre par référence.
8. Ecrivez le corps du sous-programme void applyF(void (*f)(unsigned long*, unsigned long*), int n,
unsigned long* l1, unsigned long* l2), applyF applique n fois la fonction f, en utilisant comme paramètre
lors du premier appel les variables pointées par l1 et l2.
9. Utilisez applyF et phi pour coder unsigned long fastFibo(unsigned long l)
10. Majorer la complexité de applyF lorsqu’on lui passe le sous-programme phi en paramètre, prouver ce résultat
par récurrence.
11. Quelle est la complexité de fastFibo ? Porte-t-elle bien son nom ?
Exercice 12 - Pgcd
Le plus grand commun diviseur de deux entiers relatifs a et b, noté pgcd(a, b), est défini par la relation de récurrence
pgcd(a, b) = pgcd(b, a mod b), avec pgcd(a, 0) = a.
1. Ecrire une fonction récursive calculant le pgcd de deux entiers relatifs.
2. Ecrire une fonction itérative retournant le i-ème nombre de fibonacci.
3. Ecrire les deux sous-programmes unsigned long pgcd(unsigned long a, unsigned long b) et unsigned
long fibonacci(unsigned long l)
4. Tester la fonction pgcd avec des nombres de fibonacci consécutifs. Qu’observez-vous ?
5. Si on s’intéresse au nombre d’appels récursifs nécessaires pour calculer un pgcd, quel est le pire des cas ?
Fn+1
6. Quel est la valeur du quotient ?
Fn
7. En déduire que les entrées de la forme (Fn+1 , Fn forment les pires cas.
8. Combien d’itérations sont nécesaires pour calculer pgcd(Fn+1 , Fn ) ?
9. Prouver que Fn est majoré par une suite géométrique.
√
1+ 5
10. Prouver que le nombre d’appels récursifs est majoré par un logarithme de base φ = .
2
11. Quelle est la complexité de pgcd, est-ce efficace ?
Exercice 13 - Pavage avec des L

Soit n un nombre positif fixé. On considère une grille carrée de 2n × 2n cases. Un case arbitraire est noircie, toutes
les autres sont libres. Le problème consiste à paver toute la grille sauf la case noircie avec des pièces en forme de L.
Ces pièces occupent trois cases :
1. résolvez le problème pour n = 0.
23
2. résolvez le problème pour tout n ≥ 0, vous montrerez que si l’on est capable de résoudre ce problème pour une
valeur n donnée, alors il est possible de le résoudre pour une valeur n + 1.
3. programmez cet algorithme en C, remplissez chaque case avec un caractère. Vous représenterez une pièce en
affectant le même caractère à toutes les cases occupées par cette pièce. Par exemple (avec n = 4),
@ @ ? ? ; ; : : + + * * & & % %
@ > > ? ; 9 9 : + ) ) * & $ $ %
A > B B < < 9 = , ) - - ’ ’ $ (
A A B 8 8 < = = , , - # # ’ ( (
E E D 8 J J I I 0 0 / # 5 5 4 4
E C D D J H H I 0 . / / ! 5 3 4
F C C G K H L L 1 . . 2 6 3 3 7
F F G G K K L " 1 1 2 2 6 6 7 7
U U T T P P O " " j i i e e d d
U S S T P N O O j j h i e c c d
V S W W Q N N R k h h l f f c g
V V W M Q Q R R k k l l b f g g
Z Z Y M M _ ^ ^ o o n b b t s s
Z X Y Y _ _ ] ^ o m n n t t r s
[ X X \ ‘ ] ] a p m m q u r r v
[ [ \ \ ‘ ‘ a a p p q q u u v v
Vous remarquez que la case noircie est celle avec le point d’exclamation. Représentez la matrice en mémoire
de sorte à faciliter l’implémentation récursive de l’algorithme. C’est à dire en indicant de la façon suivante (si
n = 3) ;
0 1 4 5 16 18 20 21
2 3 6 7 17 19 22 23
8 9 12 13 24 25 28 29
10 11 14 15 26 27 30 31
32 33 36 37 48 49 52 53
34 35 38 39 50 51 54 55
40 41 44 45 56 57 60 61
42 43 46 47 58 59 62 63
3.4.5 L’heure du code

Maintenant c’est l’heure du code. Etes-vous capable de programmer les algorithmes étudiés dans les exercices
précédents ? C’est ce que nous allons voir...
Exercice 14 - Echauffement : représentation des complexes

Ecrivez les fonctions du fichier complexe.c correspondant au fichier complexe.h ci-dessous :
#i f n d e f COMPLEXE H
#d ef i n e COMPLEXE H
#include ” l i n k e d L i s t . h”
/∗
Type complexe
∗/
typedef s tr u ct
{
24
/∗
Partie r e e l l e
∗/
double r e ;
/∗
p a r t i e imaginaire
∗/
double im ;
/∗
module
∗/
double mod ;
/∗
argument , nu l s i l e nombre e s t 0 + 0 i
∗/
double a r g ;
} complexe , ∗ pComplexe ;
double reComplexe ( c o m p l e x e c ) ;
/∗
Retourne l a p a r t i e i m a g i n a i r e
∗/
double imComplexe( c o m p l e x e c ) ;
/∗
Retourne l e module
∗/
double modComplexe ( c o m p l e x e c ) ;
/∗
Retourne l ’ argument
∗/
double argComplexe ( c o m p l e x e c ) ;
/∗
A f f i c h e c so u s forme e x p o n e n t i e l l e
∗/
void printExpComplexe ( c o m p l e x e c ) ;
/∗
A f f i c h e l ’ a f f i x e de c
∗/
void p r i n t A f f C o m p l e x e ( c o m p l e x e c ) ;
/∗
Cree un complexe a p a r t i r de son a f f i x e
∗/
c o m p l e x e makeAffComplexe ( double r e , double im ) ;
/∗
Cree un complexe a p a r t i r de sa forme e x p o n e n t i e l l e
∗/
c o m p l e x e makeExpComplexe( double mod , double a r g ) ;
/∗
Retourne l e c o nju g u e de c
∗/
c o m p l e x e c o n j u g u e Co m ple xe ( c o m p l e x e c ) ;
/∗
S o u s t r a i t c1 e t c2
∗/
c o m p l e x e subComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 ) ;
/∗
Ad d it io nne c1 e t c2
∗/
c o m p l e x e addComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 ) ;
/∗
M u l t i p l i e c1 e t c2
∗/
c o m p l e x e multComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 ) ;
/∗
Multiplie c par l e reel d
25
∗/
c o m p l e x e multReelComplexe ( double d , c o m p l e x e c ) ;
/∗
D i v i s e c2 par c1
∗/
c o m p l e x e divComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 ) ;
/∗
Eleve c a l a puissance n
∗/
c o m p l e x e p u i ssCo m p l e x e ( c o m p l e x e c , unsigned long n ) ;
/∗
Retourne un p o i n t e u r v e r s une c o p i e du complexe c .
∗/
pComplexe copyComplexe ( c o m p l e x e c ) ;
#en d i f
Exercice 15 - Une bibliothèque de listes chaı̂nées

Ecrivez les fonctions du fichier linkedList.c correspondant au fichier linkedList.h ci-dessous :
#i f n d e f LINKED LIST H
#d ef i n e LINKED LIST H
/∗
M a il l o n de l a liste chainee
∗/
typedef s tr u ct l
{
/∗
p o i n t e u r v e r s l a donnee
∗/
void∗ d a t a ;
/∗
pointeur vers l e maillon suivant
∗/
s tr u ct l ∗ n e x t ;
} link ;
/∗
Type e n c a p s u l a n t l a liste chainee
∗/
typedef s tr u ct
{
/∗
nombre d ’ e l e m e n t s de l a liste chainee
∗/
int s i z e ;
/∗
p o i n t e u r v e r s l e p r e m ie r e l e m t n de l a liste chainee
∗/
link ∗ f i r s t ;
/∗
p o i n t e u r v e r s l e d e r n i e r e l e m e nt de l a liste chainee
∗/
link ∗ last ;
} linkedList ;
/∗
Cree une l i s t e c h a i n e e ne c o nt e na nt aucun e l e m e nt .
∗/
linkedList ∗ linkedListCreate ( ) ;
/∗
Ajo u t e l ’ e l e m e nt x dans a l a f i n de l a liste chainee l
∗/
void l i n k e d L i s t A p p e n d ( l i n k e d L i s t ∗ l , void∗ x ) ;
26
/∗
Ajo u t e l e m a i l l o n l k a l a f i n de l a liste l
∗/
void l i n k e d L i s t A p p e n d L i n k ( l i n k e d L i s t ∗ l , link ∗ lk );
/∗
Ajo u t e l ’ e l e m e nt x dans au d e b u t de l a liste chainee l
∗/
void l i n k e d L i s t P u s h ( l i n k e d L i s t ∗ l , void∗ x ) ;
/∗
Ajo u t e l e m a i l l o n l k au d e b u t de l a liste l
∗/
void l i n k e d L i s t P u s h L i n k ( l i n k e d L i s t ∗ l , link ∗ lk ) ;
/∗
Retourne l a t a i l l e de l a liste l
∗/
int l i n k e d Li st Ge t S i z e ( l i n k e d L i s t ∗ l ) ;
/∗
Retourne un p o i n t e u r v e r s l e p r e m ie r m a i l l o n de
l a l i s t e c h a i n e e l , NULL s i l e s t v i d e .
∗/
link ∗ linkedListGetFirst( linkedList ∗ l );
/∗
Retourne un p o i n t e u r v e r s l e p r e m ie r m a i l l o n de l ,
e n l e v e ce m a i l l o n de l a l i s t e l . Retourne NULL
si l est vide .
∗/
link ∗ linkedListUnlinkFirst( linkedList ∗ l ) ;
/∗
Retourne une l i s t e c h a i n e e c o nt e na nt t o u t e s l e s images
d e s donnees par l a f o n c t i o n f . En p o sa nt f = id , on o b t i e n t
une f o n c t i o n de c o p i e .
∗/
l i n k e d L i s t ∗ l i n k e d L i s t M a p ( l i n k e d L i s t ∗ l , void∗ ( ∗ f ) ( void ∗ ) ) ;
/∗
Concatene l e s deux l i s t e s b e g i n e t end , l a deuxieme e s t a j o u t e e
a l a f i n de l a p r e m ie r e .
∗/
void l i n k e d L i s t C o n c a t ( l i n k e d L i s t ∗ b e g i n , l i n k e d L i s t ∗ end ) ;
/∗
Ap p l iq u e l a f o n c t i o n f a t o u t e s l e s donnees de l a l i s t e l .
P a sse r une f o n c t i o n d ’ a f f i c h a g e permet par exemple d ’ a f f i c h e r
l e s donnees de chaque m a i l l o n .
∗/
void l i n k e d L i s t A p p l y ( l i n k e d L i s t ∗ l , void ( ∗ f ) ( void ∗ ) ) ;
/∗
Desalloue l et tous ses maillons , applique le destructeur fr
a l a donnee de chaque m a i l l o n .
∗/
void l i n k e d L i s t D e s t r o y ( l i n k e d L i s t ∗ , void ( ∗ f r ) ( void ∗ ) ) ;
#en d i f
Exercice 16 - Tri par insertion

Nous allons implémenter le tri par insertion d’une liste chaı̂née : Vous utiliserez les sous-programmes suivants et
n’utiliserez aucune boucle, seule la récursivité est autorisée.
– link* insert(link* list, link* item, int (*estInf)(void*, void* )), insère dans la liste list triée le
maillon item. On a estInf(i, j) si et seulement si la clé de i est strictement inférieure à celle de j.
27
– link* triInsertion(link* list, int (*estInf)(void*, void*)), trie par insertion la liste list en utili-
sant la fonction de comparaison estInf.
– void linkedListSort(linkedList* l, int (*estInf)(void*, void*)), trie la liste l en modifiant le chaı̂nage,
vous n’oublierez pas de mettre à jour l->first et l->last.
– Identifez le pire des cas et observez la façon dont le temps d’exécution croı̂t avec le nombre de maillons. Est-ce
que cela corrobore les conclusions théoriques ?
Exercice 17 - Tri fusion

Le tri par fusion se fait en coupant un tableau en deux sous-tableaux de tailles égales à un élément près, en triant
récursivement les deux sous-tableaux puis en interclassant leurs éléments. Ecrire en C une fonction de tri fusion de
listes chaı̂nées. Vous prendrez garde à ne pas recopier les maillons, et à seulement modifier le chaı̂nage. Vous utiliserez
les sous-programmes énoncés ci-après. Notez bien le type des paramètres.
– void split(linkedList* source, linkedList* dest1, linkedList* dest2), répartit les maillons de source
dans dest1 et dest2.
– void merge(linkedList* source1, linkedList* source2, linkedList* dest, int (*inf) (void*, void*)),
interclasse les listes source1 et source2 et place le résultat dans la liste dest. Le fonction pointée par f retourne
1 si la clé premier paramètre est inférieur à la clé du deuxième paramètre, 0 sinon.
– void triFusion(linkedList* l, int (*inf)(void*, void*)), tri la liste l en modifiant le chaı̂nage.
– Comparez son temps d’exécution à celui du tri par sélection. Déterminez sa complexité. Est-ce un algorithme de
tri efficace ?
Exercice 18 - Transformée discrète de Fourier

Nous allons étudier la transformée discrète de Fourier et la façon dont on peut la calculer efficacement. Etant
donné un vecteur a = (a0 , . . . , an−1 ), la transformée discrète de Fourier de a est un vecteur b = (b0 , . . . , bn−1 ), noté
b = T F (a) dont le p-ème élément est
n−1
X p
bp = ak (e n 2πi )k
k=0
1. Commençons par étudier les racines

√ complexes
√ de 1. Vous vous doutez probablement 1 a deux racines carrées
−1 3 −1 3
−1 et 1. Vérifiez que 1, + i et − i sont 3 racines cubiques de 1.
2 2 2 2
2. Vérifiez que 1, 1 + i, −1 et 1 − i sont 4 racines quatrièmes de 1.
1 k
3. Vérifiez que Wn = {e n 2πi+ n 2iπ |k ∈ {0, . . . , n − 1}} est l’ensemble des racines n-èmes de 1.
1
4. Posons ωn = e n 2πi , véfifiez que Wn = {ωnk |k ∈ {0, . . . , n − 1}}.
5. Prouvez que pour tous n et k, ωnk+n = ωnk .
On considère l’algorithme
Fonction A(a, x, n)
r ←− 0
pour i ∈ {0, . . . , n − 1}
y ←− 1
pour j ∈ {1, . . . , i}
y ←− y × x
fin pour
r ←− r + ai × y
fin pour
retourner r
FIN
n−1
X
1. Soit P (x) = a0 + ai xi un polynome de degré n − 1. Que vaut l’algorithme A(P, x, n) ?
i=1
28
2. Quelle est la complexité de A ?
3. La méthode de Horner est basée sur la relation suivante P (x) = a0 + x(a1 + x(a2 + x(. . .))). Ecrivez l’algorithme
récursif horner qui calcule P (x) en utilisant cette relation.
4. Quelle est la complexité de horner ?
n−1
X
5. Soit P (x) = a0 + ai xi un polynôme de degré n − 1 et b = T F (a). Montrez que bp = P (wnp ).
i=1
6. Comment calculer T F (a) en utilisant le sous-programme horner ? Ecrivez le sous-programme T F .
7. On note T F −1 la transformée inverse de Fourier, nous admettrons que si a = T F −1 (b), alors
n−1
1X
aq = bk ωn−kq
n
k=0
Ecrivez le sous-programme T F −1 .
8. Quelle sont les complexités de T F et de T F −1 ?
2k
9. Prouvez que pour tous n et k, ω2n = ωnk .
10. Supposons que n est pair, donc qu’il existe m tel que n = 2m. Soit a[0] = (a0 , a2 , . . . , a2m ), a[1] = (a1 , a3 , . . . , a2m+1 ),
b[0] = T F (a[0] ) et b[1] = T F (a[1] ). Soit q ∈ {0, . . . , m − 1}, montrez que
bq = b[0] q [1]
q + ωn bq
puis que
bq+m = b[0] q+m [1]
q + ωn bq
11. Ecrire le sous-programme F F T qui calcule la transformée discrète de Fourier d’un vecteur de taille n = 2k en
utilisant la relation de récurrence ci-dessus.
12. Quelle est la complexité de F F T ?
13. Supposons que n est pair, donc qu’il existe m tel que n = 2m. Soit b[0] = (b0 , b2 , . . . , b2m ), b[1] = (b1 , b3 , . . . , b2m+1 ),
y [0] = T F −1 (b[0] ) et y [1] = T F −1 (b[1] ). Soit p ∈ {0, . . . , m − 1} et y = T F −1 (b). Montrez que
1 [0]
yp = (y + ωn−p yp[1] )
2 p
puis que
1 [0]
yp+m = (y + ωn−(p+m) yp[1] )
2 p
14. Ecrire le sous-programme F F T −1 qui calcule la transformée inverse de Fourier d’un vecteur de taille n = 2k en
utilisant la relation de récurrence ci-dessus.
15. Quelle est la complexité de F F T −1 ?
16. Ecrivez les fonctions du fichier fourier.c correspondant au fichier fourier.h ci-dessous.
#i f n d e f FOURIER H
#d ef i n e FOURIER H
#include ” c o m p l e x e . h”
/∗
Retourne l a t r a n s f o r m e e d i s c r e t e de Fo u r ie r du v e c t e u r l .
Al g o r it h m e i t e r a t i f en O( n ˆ 2 ) .
∗/
linkedList ∗ transformeeFourierIt ( linkedList ∗ l );
/∗
Retourne l a t r a n s f o r m e e d i s c r e t e de Fo u r ie r i n v e r s e
du v e c t e u r l . Al g o r it h m e i t e r a t i f en O( n ˆ 2 ) .
∗/
linkedList ∗ transformeeInverseFourierIt ( linkedList ∗ l );
29
/∗
Retourne l a t r a n s f o r m e e d i s c r e t e de Fo u r ie r du v e c t e u r l , de t a i l l e
n = 2ˆm. Al g o r it h m e r e c u r s i f en O( n l o g n ) .
∗/
l i n k e d L i s t ∗ FFT( l i n k e d L i s t ∗ l ) ;
/∗
du v e c t e u r l de t a i l l e n = 2ˆm. Al g o r it h m e r e c u r s i f en
O( n l o g n ) .
∗/
l i n k e d L i s t ∗ i n v e r se F F T ( l i n k e d L i s t ∗ l ) ;
#en d i f
Vous utiliserez les fonctions auxiliaires suivantes :

1. linkedList* uniteRacinesComplexe(complexe c, unsigned long n), retourne les n racines n-ème de 1.
2. complexe horner(link* p, complexe x), retourne l’image de x par le polynôme p.
Exercice 19 - Représentation des polynômes

Nous souhaitons implémenter une bibliothèque de représentation des fonctiosn polynômes. La plupart des opérations
sont relativement simples à rédiger. La plus délicate est la multiplication. Prenons un exemple, pour multiplier P (x) =
1 + x + 22 et Q(x) = 1 − x + x2 , il y a deux façons de procéder.
1. En multipliant ”bêtement” : P (x)Q(X) = (1+x+22 )(1−x+x2 ) = 1(1−x+x2 )+x[(1−x+x2 )+2x(1−x+x2 )] =
(1 − x + x2 ) + x[1 + x − x2 + 2x3 ] = 1 − x + x2 + x + x2 − x3 + 2x4 = 1 + 2x2 − x3 + 2x4 .
2. Une autre méthode consiste à passer par une interpolation. Le polynôme P Q sera évidemment de degré 4, donc
en ayant 5 points par lesquels passa la courbe de P Q, il est possible d’interpoler ses coefficients. Pour trouver
ces points, il suffit d’évaluer P et Q en 5 points, par exemple {1, 2, 3, 4, 5}, On obtient 2 vecteurs
{(1, P (1)), (2, P (2)), (3, P (3)), (4, P (4)), (5, P (5))}
et
{(1, Q(1)), (2, Q(2)), (3, Q(3)), (4, Q(4)), (5, Q(5))}
Cela nous donne 5 points par lesquels passe la courbe de P Q :
{(1, P (1)Q(1)), (2, P (2)Q(2)), (3, P (3)Q(3)), (4, P (4)Q(4)), (5, P (5)Q(5))}
Il suffit ensuite d’effectuer une interpolation des coefficients a, b, c, d et e de la courbe de P Q, cela se fait en
résolvant le système d’équations
{a14 + b13 + c12 + d11 + e = P (1)Q(1), a24 + b23 + c22 + d21 + e = P (2)Q(2), . . .}
Chacune de ces méthoes requiert O(n2 ) opérations. Il est cependant possible d’affiner la deuxième en choisissant
judicieusement les points servant à évaluer puis à interpoler. En prenant Wn comme ensemble de points, on ramène les
évaluations de ces points à des transformées de Fourier et l’interpolation à une transformation inverse de Fourier. Cela
permet de multiplier des polynômes en O(n log2 n). Voyez [2] pour un exposé davantage détaillé. Ecrivez les fonctions
du fichier polynomes.c correspondant au fichier polynomes.h ci-dessous. Vous prendrez soin de vous assurer que la
multiplication à l’aide de la transformée de Fourier est plus rapide que la version pour boeufs.
#i f n d e f POLYNOME H
#d ef i n e POLYNOME H
#include ” f o u r i e r . h”
/∗
Nous r e p r e s e n t e r o n s un polynome a v e c une l i s t e c h a i n e e c o nt e na nt
l e s c o e f f i c i e n t s du polynome par o r d r e de d e g r e c r o i s s a n t .
∗/
/∗
Retourne un polynome v i d e .
∗/
30
l i n k e d L i s t ∗ makePolynome ( ) ;
/∗
Retourne une c o p i e de l , c o p i e a u s s i l e s coefficients .
∗/
l i n k e d L i s t ∗ copyPolynome ( l i n k e d L i s t ∗ l ) ;
/∗
D e t r u i t l e polynome l e t s e s c o e f f i c i e n t s .
∗/
void d e st r o y P o l y n o m e ( l i n k e d L i s t ∗ l ) ;
/∗
A f f i c h e polynome l e p l u s proprement p o s s i b l e .
∗/
void p r i n t P o l y n o m e ( l i n k e d L i s t ∗ polynome ) ;
/∗
Retourne l e d e g r e de l .
∗/
int degreePolynome( l i n k e d L i s t ∗ l ) ;
/∗
Ajo u t e un monome de c o e f f i c i e n t c o e f f a l a f i n du polynome , faisant
a i n s i c r o u t r e son d e g r e de 1 .
∗/
void appendCoeffPolynome ( l i n k e d L i s t ∗ polynome , double c o e f f ) ;
/∗
Cree e t r e t o u r n e l e polynome de d e g r e n−1 dont l e s
c o e f f i c i e n t s s o n t p a s s e s dans l e t a b l e a u d .
∗/
l i n k e d L i s t ∗ makeArrayPolynome( double∗ d , i n t n ) ;
/∗
Retourne l e polynome nu l .
∗/
l i n k e d L i s t ∗ z e r o P o l y n o me ( ) ;
/∗
Retourne l e polynome u n i t e .
∗/
l i n k e d L i s t ∗ u n i t P o l y n o me ( ) ;
/∗
Ajo u t e l a c o n s t a n t e d au polynome l .
∗/
void addRealPolynome( l i n k e d L i s t ∗ l , double d ) ;
/∗
M u l t i p l i e l e polynome l par l e r e e l d .
∗/
void multRealPolynome ( l i n k e d L i s t ∗ l , double d ) ;
/∗
M u l t i p l i e l e polynome l par Xˆn
∗/
void multXNPolynome ( l i n k e d L i s t ∗ l , i n t n ) ;
/∗
M u l t i p l i e l e polynome l par c o e f f ∗Xˆ exp
∗/
void multMonomePolynome ( l i n k e d L i s t ∗ l , double c o e f f , i n t exp ) ;
/∗
A d d i t i o n e l e s deux polynomes a e t b , r e t o u r n e c e t t e somme.
∗/
l i n k e d L i s t ∗ addPolynome ( l i n k e d L i s t ∗ a , l i n k e d L i s t ∗ b ) ;
/∗
M u l t i p l i e a e t b avec l a recurrence
( a 0 + a 1X + . . . + a nXˆn)Q(X)
= a 0 ∗ Q(X) + X ∗ ( a 1 + a 2 X. . . + a n Xˆ(n−1)) ∗ Q(X)
∗/
l i n k e d L i s t ∗ slowMultPolynome ( l i n k e d L i s t ∗ a , l i n k e d L i s t ∗ b ) ;
/∗
M u l t i p l e a e t b en p a s s a n t par une t r a n s f o r m e e de f o u r i e r .
∗/
l i n k e d L i s t ∗ multPolynome ( l i n k e d L i s t ∗ a , l i n k e d L i s t ∗ b ) ;
31
/∗
E v a l u e l e polynome l en x a v e c l a methode de Horner .
∗/
double e v a l u a t e P o l y n o m e ( l i n k e d L i s t ∗ l , double x ) ;
#en d i f
32
Chapitre 4
Arbres
4.1 Définitions par induction

On remarque que l’ensemble des arbres binaires est défini par induction. C’est-à-dire à partir d’un ensemble
d’atomes et de règles. Les atomes sont les éléments de l’ensemble qui sont indécomposables, par exemple l’arbre vide
∅. Les règles permettent à partir d’éléments d’un ensemble de créer d’autres éléments. Par exemple, si A et B sont des
arbres binaires, et r un noeud, alors le triplet (A, r, B) est un arbre binaire.
4.1.1 Définition
On définit un ensemble E par induction en deux étapes :
– La base La base est une liste d’éléments de E qui sont des atomes. On les notes A et on la propriété A ⊂ E.
– L’induction L’induction est un ensemble de règles permettant de créer un élément de E avec d’autres éléments
de E. Chaque règle est une fonction f : E k −→ E telle que si (E1 , . . . , Ek ) est un k-uplet d’éléments de E, alors
f (E1 , . . . , Ek ) ∈ E.
4.1.2 Exemple
Considérons l’ensemble IN des entiers naturels, on le définit de la sorte :
– Base la seul atome de IN est 0. Donc On les note A = {0}.
– Induction On prend comme unique règle la fonction s : x 7→ x + 1 appelée successeur. Pour tout élément n de
IN, on a s(n) ∈ N .
On conviendra donc que IN est l’ensembles de tous les éléments faisant soit partie de A, soit pouvant être obtenu
par application d’un nombre fini de règles. Par exemple, 0 ∈ IN, car 0 ∈ A, 4 ∈ IN, car 0 ∈ A et 4 = s(s(s(s(0)))) ∈ IN
(vous remarquez que 4 s’obtient par application d’un nombre fini de règles).
4.1.3 Expressions arithmétiques

Une expression arithmérique totalement parenthésée (EATP) se définit de la sorte,
– Base Tout nombre x ∈ IR est une EATP.
– Induction Soit E, E ′ deux EATPs, alors (E + E ′ ), (E − E ′ ), (E × E ′ ) et (E/E ′ ) sont des EATPs.
Une juxtaposition de symboles X est une EATP s’il est possible de générer X en applicant un nombre fini de fois les
règles précédentes. Si l’on souhaite définir formellement une EATP, il convient de les représenter de façon ensembliste.
On redéfinit donc l’ensemble E des EATPs de la sorte :
– Base IR ⊂ E
– Induction ∀E, E ′ ∈ E, +(E, E ′ ), −(E, E ′ ), ×(E, E ′ ), /(E, E ′ ) ∈ E.
Cette définition met en correspondance des expressions comme (3 + (4 × 5)) avec des ensembles de la forme
+(3, ×(4, 5)), plus faciles à manier dans des algorithmes. Naturellement, on représentera toute expression arithmérique
par un arbre binaire. Les feuilles représenteront les atomes de nos expressions et les noeuds représenteront les règles.
33
4.1.4 Application aux arbres binaires
Soit f une fonction prenant an argument un arbre binaire, la façon la plus claire et la précise de définir une telle
fonction est souvent de la caractériser par induction. Par exemple
Définition 4.1.1 On note h(A) la hauteur de l’arbre A. On la définit par induction :

– h(∅) = −1
– h((Ag , r, Ad )) = 1 + max(h(Ag ), h(Ad ))
Définition 4.1.2 On note |A| le nombre de noeuds d’un arbre A. On le définit par induction :
– |∅| = 0
– |(A, r, B)| = 1 + |A| + |B|
4.2 Preuves par induction

4.2.1 Lien avec les preuves par récurrence
Si on veut montrer que tout élément de IN vérifie une propriété, par exemple ∀n ∈ IN, n(n + 1) est pair, on va
construire par induction l’ensemble E ⊂ IN des n ∈ IN tels que n(n + 1) est pair. Si les atomes de IN et de E sont
les mêmes et que l’on parvient à construire IN et E avec les mêmes règles, alors IN = E. Nous avons deux étapes à
effectuer pour le vérifier :
– Base la seul atome de IN est 0. Comme 0 × 1 = 0 est pair, alors 0 ∈ E.
– Induction La seule règle que nous avons à examiner est s : x 7→ x + 1. Prenons un élément arbitraire de E (E
n’est pas vide puisqu’il contient 0), notons-le n. Montrons que s(n) ∈ E. On a s(n) = n + 1, donc s(n) ∈ E si
(n + 1)(n + 1) est pair. Or (n + 1)(n + 2) = (n + 1)n + (n + 1)2, comme n ∈ E, alors n(n + 1) pair. Par ailleurs
2(n + 1) est évidemment pair. Comme la somme de deux nombres pairs est paire, alors s(n) ∈ E.
Nous venons de montrer que IN peut être construit de la même façon que E, donc IN ⊂ E (et par conséquent
E = IN). Comme E est l’ensemble des entiers n tels que n(n + 1) est pair, alors pour tout élément n de IN, n(n + 1)
est pair. Ce que nous venons de faire est en fait une preuve par récurrence. La raisonnement par récurrence est un cas
particulier du raisonnement par induction.
4.2.2 Application aux EATPs

On veut démontrer que toute EATP contient au moins autant de parenthèses que d’opérateurs. Procédons en ayant
à l’esprit la définition d’une EATP :
– Base Les seules EATPs atomiques les expressions réduites à un réel, dont ne contenant ni parenthèse, ni
opérateur.
– Induction Les quatre règles à considérer sont de la même forme : E = (Eg oEd ) où o est un opérateur binaire,
Eg , Ed deux EATPs, et E une EATP non atomique pour laquelle on cherche à démontrer la propriété. Par hy-
pothèse d’induction, Eg et Ed contiennent au moins autant de parenthèses que d’opérateurs. Et dans l’expression
(Eg oEd ) on ajoute plus de parenthèses que d’opérateurs, donc E contient au moins autant de parenthèses que
d’opérateurs.
Exercice 1 - Opérandes et opérateurs

Démontrez par induction que dans toute EATP, il y a une opérande de plus qu’il n’y a d’opérateurs.
4.3 Algorithmique dans les arbres

On définit une bijection cle entre les noeuds de A et un ensemble (E, >) totalement ordonné. On note cle(x) la clé
du noeud x. En général, on prend E = IN.
Nous représenterons chaque noeud d’un arbre binaire avec une structure ABR contenant les champs suivants :
– cle
– g
– d
34
Si a est une variable de type AB alors a.cle est la clé de la racine de l’arbre a, a.d est un pointeur vers le sous-arbre
droit, a.g est un pointeur vers le sous-arbre gauche. Si un pointeur ne pointe vers aucune valeur, on dira qu’il prend
la valeur null. On fera une allocation dynamique en utilisant la fonction AB(fg , c, fd ) pour créer un noeud de clé c et
de sous-arbre gauche (resp. droit) fg (resp. fd ) de type AB.
Exercice 2 - Nombre de noeuds

Ecrire une fonction retournant le nombre de noeuds formant un arbre A.
Exercice 3 - Hauteur
Ecrire une fonction retournant la hauteur d’un arbre A.
Exercice 4 - Profondeur
Ecrire une fonction retournant la profondeur d’un noeud x dans un arbre A.
4.4 Arbres n-naires

Définition 4.4.1 A est un arbre n-aire de si une des conditions suivantes est vérifiée
– A est un arbre vide, on le note abusivement A = ∅.
– A = (d, l) où
– d est la racine de A
– l est un k-uplet (k ≤ n) d’arbres n-aires.
On remarque qu’un arbre 1-aire est une liste chaı̂née. Nous représenterons un arbre n-aire avec une structure
ARBRE, dont le constructeur est de même nom.
35
Chapitre 5
Files de priorité
Une file de priorité est une structure de donnée permettant de stocker un ensemble d’éléments munis d’une clé
d’ordre total, et dans laquelle on s’intéresse aux opérations suivantes :
– Extraction du plus petit élément
– Ajout d’un élément
– Suppression du plus petit élément
5.1 Implémentations naı̈ves

Une première idée serait d’implémenter une file de priorité avec un tableau non trié. Dans ce cas, on a :
– Extraction du plus petit élément en O(n)
– Ajout d’un élément en O(1)
– Suppression du plus petit élément O(n)
Cette solution est peu satisfaisante. Avec un tableau trié, une liste chaı̂née triée ou non, on obtient des résultats
peu satisfaisants. Nous allons devoir méditer sur des solutions permettant d’obtenir des temps de calcul au moins
inférieurs à O(log2 n).
Exercice 1 - Tableau non trié

Justifier les résultats de complexité.
Exercice 2 - Tableau trié

Déterminer les complexités des trois opérations dans le cas où le tableau est trié.
Exercice 3 - Liste chaı̂née non triée

Déterminer les complexités des trois opérations dans le cas où on utilise une liste chaı̂née non triée.
Exercice 4 - Liste chaı̂née triée

Déterminer les complexités des trois opérations dans le cas où on utilise une liste chaı̂née triée.
5.2 Tas
5.2.1 Définition
Un tas est un arbre binaire vérifiant les propriétés suivantes :
1. Tous les niveaux sont remplis sauf éventuellement le dernier.
2. Dans le dernier niveau, les noeuds sont disposés le plus à gauche possible.
36
3. Tous noeud possède une clé inférieure à celle de ses deux fils.
Par exemple,
1
2 6
7 3 7 11
8 12
Vous remarquez que les trois premiers niveaux sont remplis et que dans le quatrième niveau, les noeuds disposés
le plus à gauche possible. De même, on constate que chaque noeud a une clé inférieure à celle de ses fils.
Exercice 5 - Définition
Représenter un tas contenant les éléments suivants : {3, 87, −1, 0, 3, 9, 54, −3}. Vous disposerez les éléments à votre
convenance du moment que l’arbre considéré est bien un tas.
Exercice 6 - Hauteur
Majorer la hauteur d’un tas contenant n éléments.
5.2.2 Extraction du minumum

Vous remarquez que le plus petit élément est à la racine. Par conséquent l’extraction est trivialement en temps
constant.
5.2.3 Insertion
Pour insérer un élément dans un tas, on choisit l’unique emplacement qui permet de conserver les deux premières
propriétés ? Ensuite on réequilibre le tas. Le soin de cette procédure vous est laissé en exercice.
Exercice 7 - Ajout
Décrire la procédure permettant de déterminer où insérer un nouvel élément dans un tas.
5.2.4 Suppression du minimum

Supprimer la dernière feuille du tas est simple, c’est la seule operation qui conserve les deux premières propriétés.
La solution que nous préconiserons sera de permuter la racine avec le dernier élément. Il suffira ensuite d’équiliber le
tas autour de la racine.
Exercice 8 - Equilibrage d’un tas

Décrire une façon d’équilibrer un tas après insertion d’un nouvel élément. Donner un invariant de boucle. Est-ce
que le programme se termine ?
5.2.5 Implémentation
En règle générale, on implémente un tas avec un tableau. Les éléments sont disposés dans l’ordre d’un parcours en
largeur de la gauche vers la droite.
37
Exercice 9 - Indices
Nous indicerons les tableaux à partir de 1. Déterminez une relation de récurrence entre l’indice d’un noeud et les
indices de ses voisins (père, fils gauche, fils droit).
Exercice 10 - Performances
Faites le point sur les temps d’exécution des diverses opérations. Est-ce efficace ?
5.3 Tas binomial

Ajoutons maintenant une opération : la fusion. Etant données deux fils de priorités, comment les fusionner effica-
cement ?
5.3.1 Arbre binomial

Un arbre binomial d’ordre n (noté Bn ) est défini par induction de la façon suivante :
– B0 est réduit à un seul noeud.
– Bn est construit de la façon suivante :
B n−1
B n−1
Voici par exemple B0 , B1 , B2 , B3 et B4 :
Exercice 11 - Représentation graphique

Représenter les 5 premiers arbres binomiaux.
Exercice 12 - Propriétés
Prouver par induction les propriétés suivantes :
1. Bn contient 2n noeuds.
2. Bn est de hauteur n.
3. La racine de Bn a n fils.
4. Les n fils de la racine de Bn sont B0 , B1 , . . ., Bn−1 .
5. Il y a Cnk noeuds de profondeur k dans Bn .
5.3.2 Fusion
Etant donnés deux arbres binomiaux, on les fusionne en faisant de l’un un fils de la racine de l’autre. Cette opération
(jeu d’adresses) se fait en temps constant.
38
5.3.3 Tas binomial
Un tas binomial est une liste d’arbres binomiaux vérifiant les propriétés suivantes :
– Dans chaque arbre, tout noeud est de clé inférieure à ses fils.
– Tous les arbres sont d’ordres distincts.
5.3.4 Implémentation
Les tas binomiaux ne sont pas triviaux à implémenter. On représente un tas binomial par une liste chaı̂née d’arbre
binomiaux. Chaque arbre binomial est représenté par un ordre, une clé, et un pointeur vers la liste chaı̂née de ses fils.
Le premier des fils est l’arbre d’ordre le plus élevé.
Exercice 13 - Implémentation
Représenter graphiquement la représentation en mémoire d’un tas binomial.
Exercice 14 - Représentation binaire de n

Montrer qu’il est toujours possible de répartir n clés dans des arbres binomiaux d’ordres distincts. Majorer le
nombre d’arbres binomiaux nécessaires en fonction de n.
5.3.5 Extraction du minimum

Comme tous les arbres sont équilibrés, le plus petit élément du tas est nécessairement une racine. Il suffit donc
d’examiner tous les racines.
Exercice 15 - Complexité
Quelle est la complexité de l’extraction du minimum ?
5.3.6 Fusion
Etant donnés deux tas binomiaux, il est possible de les fusionner en utilisant comme sous-programme la fusion de
deux arbres.
Exercice 16 - Fusion
Décrire une méthode récursive permettant de fusionner deux tas binomiaux. Quelle en est la complexité ?
Exercice 17 - Autres opérations

Décrire de quelle façon ramener à une fusion l’insertion d’un nouvel élément. Que se passe-t-il si l’on supprime la
racine d’un arbre binomial ? En déduire un moyen de ramener la suppression d’un élément à une fusion. Déterminer
les complexités de ces deux opérations.
39
Chapitre 6
Hachage
6.1 Principe
Une table de hachage est une structure de données indexée par des valeurs V = {1, . . . , m}, comme un tableau.
On dit alors que cette table est de taille m. Une table de hachage contient des éléments posédant chacun une clé, on
note C = {1, . . . , n} l’ensemble des clés. Il existe en règle générale beaucoup plus de clés que d’indices dans une table.
On affecte à chaque élément, donc à chaque clé, un (ou plusieurs) indice dans la table. Pour ce faire, on dispose d’une
fonction de hachage h : C −→ V , qui à toute clé c associe un indice h(c) permettant de placer (rechercher, ou
supprimer) un élément dans la table de hachage.
6.2 Collisions
Comme |C| > |V |, h ne peut être injective. Par conséquent, il est possible que des éléments se téléscopent, c’est-à-
dire que deux clés distinctes aient la même image par h. Deux techniques existent pour gérer les collisions :
1. Le chaı̂nage
2. L’adressage ouvert
6.2.1 Gestion des collisions par chaı̂nage

Pour résoudre les collisions par chaı̂nage, on place dans chaque emplacement de la table non pas les éléments
eux-mêmes, mais un pointeur vers une liste chaı̂née contenant ces éléments. Si un emplacement est déjà ocupé par
un ensemble d’éléments T au moment de l’insertion de e, alors on place e à la fin de la liste chaı̂née formée par les
éléments de e.
6.2.2 Gestion des collisions par adressage ouvert

L’adressage ouvert consiste à étendre la fonction de hachage en un ensemble de fonctions {hi |i ∈ V }, lors de
l’insertion d’un élément e, on applique d’abord h1 à la clé de e, si l’emplacemnet est disponible, alors on y place e,
sinon on lui cherche un nouvel emplacement avec la fonction h2 , etc.
Nous ne travaillerons dorévavant que sur des tables dans lesquelles les collisions sont gérées par chaı̂nage.
Exercice 1 - Résolution par chaı̂nage

Soit h la fonction de hachage définie par h(k) = kmod8 et soit une table de hachage de taille m = 8 dans laquelle
les collisions sont résolues par chaı̂nage. Donner l’état de la table après l’insertion des clés 5, 28, 19, 15, 20, 33, 12, 17
et 10.
40
Exercice 2 - Temps moyen de recherche d’un noeud
On considère une fonction de hachage h qui répartit uniformément les clés dans une table de hachage de taille m
dans laquelle les collisions sont résolues par chaı̂nage.
1. Si n clés sont présentes dans la table, quelle est la longueur moyenne d’une liste.
2. Quelle est la durée moyenne d’une recherche infructueuse dans la table ?
3. On part du principe que si r(x) est le rang d’insertion de la clé x dans la table, les n valeurs que peut prendre
r(x) sont équiprobables. Déterminer la durée moyenne d’une recherche de x.
4. Quelle est la durée moyenne de recherche d’une clé présente dans la table ?
5. Quelle est la durée moyenne moyenne de recherche d’une clé dans une table de hachage de taille m contenant
O(m) clés ?
41
Chapitre 7
AVL
7.1 Arbres binaires de recherche

Définition 7.1.1 Soit A un arbre binaire dont chaque noeud est muni d’une clé. A est un arbre binaire de recherche
si pour tout noeud x,
– ∀y ∈ Ag (x), cle(y) < cle(x)
– ∀z ∈ Ad (x), cle(x) < cle(z)
Pour davantage d’informations, voir [2].
Exercice 1 - Définition
Construire tous les ABR contenant les valeurs {1, 2, 3}
Exercice 2 - Notation ensembliste

1. Ecrire un algorithme plaçant dans une variable v l’arbre ((∅, 3, ∅), 1, (∅, 2, ∅))
2. Dessiner le graphe obtenu
3. Est-ce un ABR bien formé ?
Exercice 3 - Insertions
1. Dessiner l’arbre A(v) défini comme suit :
– a = (∅, 4, ∅)
– b = ((∅, 11, ∅), 7, ∅)
– c = (∅, 3, (∅, 9, ∅))
– d = ((∅, 12, ∅), 6, (∅, 2, ∅))
– v = ((a, 5, b), 1, (c, 10, d))
2. Est-ce un ABR bien formé ?
3. Changer l’ordre des noeuds de sorte que A(v) devienne un ABR.
4. Insérez le noeud de clé 8 dans cet arbre
Exercice 4 - Suppression
On notera
– succA (x) le successeur de x dans A, c’est-à-dire l’élément de A(x) de plus petite clé parmi les éléments de clé
supérieure à celle de x.
– premier(A(x)) le plus petit élément de A(x)
1. Prouvez que si un noeud x d’un arbre A a deux fils, alors succA (x) n’a pas de fils gauche.
2. Montrez que y = succA (x) si et seulement si y = premier(Ad (x) ou x = dernier(Ag (y)).
3. Supprimez la racine de l’arbre de l’exercice précédent
42
Exercice 5 - Fonctions récursives
1. Ecrire une fonction insérant une clé x dans un arbre A et retournant l’arbre obtenu.
2. Ecrire une fonction retournant la clé minimale de l’arbre A.
3. Ecrire une fonction prenant un arbre A en paramètre et retournant le couple (A privé de sa clé minimale, la clé
minimale de A).
4. Ecrire une fonction retournant vrai si et seulement si l’arbre A passé en paramètre est un ABR bien formé.
5. Ecrire une fonction prenant en paramètres un arbre A est une valeur c, et retournant l’arbre A dans lequel aura
été supprimé le noeud de clé c.
Exercice 6 - Application au tri

Ecrire une fonction triAbr(l) prenant en paramètre une liste l contenant des éléments d’un ensemble totalement
ordonné et retournant un liste contenant les éléments de la liste l triés par ordre croissant. Vous définirez pour ce faire
toutes les fonctions auxiliaires nécessaires pour rendre l’algorithme lisible.
7.2 Complexité dans le pire de cas

La complexité dans le pire des cas est peu satisfaisante. Insérons dans un arbre des éléments par ordre croissant,
et il seront disposés en liste. Chaque opération se fera de la sorte en un temps O(n). Ces performances sont les mêmes
qu’avec des listes chaı̂nées. On en conclut que dans le pire des cas, les ABR ne sont pas plus performants que des
vulgaires listes chaı̂nées. Nous allons nous intéresser, dans la suite de ce cours, à des arbres binaires de recherche
quelque peu particuliers, dans lesquels toute opération se fera en temps O(log2 (n)).
Exercice 7 - complexité moyenne d’une recherche

Soit un ensemble E = {1, . . . , n} de n clés. Nous voulons déterminer le nombre moyen an de noeuds visités lors
de la recherche d’une de ces clés dans un ABR contenant les clés de E. On suppose que les ordres d’insertion sont
équiprobables. Par ailleurs, on considère que la probabilité de rechercher la clé i ∈ E est n1 .
1
1. Montrer que la probabilité que la racine ait la clé i est n.
2. Notons ain le nombre moyen de comparaisons nécessaires pour trouver une clé dans un arbre à n clés dont la
racine porte la clé i. Exprimer an en fonction de {ain |i ∈ E}.
3. On pose a0 = 0. Combien valent a11 et a1 ?
i−1 1 n−i
4. Montrer que ∀i ∈ E, ain = (ai−1 + 1) + + (an−i + 1)
n n n
n−1
2 X
5. En déduire que an = 1 + 2 iai
n i=1
1
6. En déduire que an = ((n2 − 1)an−1 + 2n − 1)
n2
Z n−1 Z n
1 dx 1 dx
7. Utiliser le fait que log2 (n − 1) = et que ≤ pour prouver par récurrence qu’il existe α
ln2 1 x n n−1 x
tel que an ≤ αlog2 (n)
8. Quelle est la complexité moyenne de la recherche d’une clé de E dans un ABR ?
7.3 Rotations
Nous allons étudier une opération sur les ABR s’appelant la rotation (je vous conseille de faire des dessins si vous
tenez à vous représenter les choses concrètement). Il existe deux rotations simples (la rotation droite et la rotation
gauche), et deux rotations doubles (la rotation droite-gauche et la rotation gauche-droite). La rotation droite est définie
de la sorte :
43
rotationDroite(((B, y, C), x, D)) = (B, y, (C, x, D))
De façon symétrique, on définit la rotation gauche :
rotationGauche((B, x, (C, y, D)) = ((B, x, C), y, D)

La rotation gauche-droite se définit à l’aide des deux précédentes :
rotationGaucheDroite((G, x, D)) = rotationDroite(rotationGauche(G), x, D)

Et on définit pour finir la rotation droite-gauche de façon symétrique
rotationDroiteGauche((G, x, D)) = rotationGauche(G, x, rotationDroite(D))
7.4 AVLs
Si pour un noeud v d’un ABR, les hauteurs des sous-arbres droit et gauche de v diffèrent de au plus 1, on dit que
ce noeud est équilibré. Un AVL est un ABR dans lequel tous les noeuds sont équilibrés.
7.4.1 Rééquilibrage
Les rotations vont servir à maintenir l’équilibre de chaque noeud. Nous allons nous intéresser à l’équilibre d’un
arbre de racine v dont les deux sous-arbres (G et D) sont équilibrés, et ont des hauteurs qui diffèrent de 2. Supposons,
sans perte de généralité, que h(D) = n, et que h(G) = n + 2. Soit G = (B, y, D), alors deux cas se présentent :
– si h(B) = n + 1, alors une rotation droite de v équilibre l’arbre.
– si h(B) 6= n + 1, alors une rotation gauche-droite de v équilibre l’arbre.
7.4.2 Insertion
Pour insérer un noeud, procédez comme avec des ABR pour l’ajouter en tant que feuille. Ensuite, contrôlez
l’équilibre de chaque noeud et faites des rotations si nécessaire sur le chemin allant de la feuille nouvellement insérée
à la racine.
7.4.3 Suppression
De la même façon qu’avec des ABR, on supprime un noeud en le remplaçant par le noeud du plus grande clé du
sous-arbre gauche, ou celui de plus petite clé du sous-arbre droit. La suppression du minimum ou du maximum a
les mêmes conséquences que pour l’insertion, il est nécessaire de contrôler l’équilibre de chaque noeud sur le chemin
menant du père de la feuille supprimée à la racine.
7.4.4 Compléments
Pour plus de détails, je vous conseille de vous reporter à [3]. L’applet [4] illustre graphiquement le fonctionnement
d’un AVL.
Exercices
Exercice 8 - Implémentation en C
Ecrivez les fonctions du fichier avl.c correspondant au fichier avl.h ci-dessous :
#i f n d e f AVL H
#d ef i n e AVL H
typedef s tr u ct
{
44
/∗
P o int e u r v e r s une f o n c t i o n p e r m e t t a nt de
r e c u p e r e r l a c l e de chaque donnee .
∗/
i n t ( ∗ getKey ) ( void ∗ ) ;
/∗
P o int e u r v e r s une f o n c t i o n p e r m e t t a nt de
de d e t r u i r e chaque donnee .
∗/
void ( ∗ f r e e D a t a ) ( void ∗ ) ;
/∗
P o int e u r v e r s l a r a c i n e de l ’ a r b r e .
∗/
void∗ r o o t ;
} avl ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne un AVL v i d e .
∗/
a v l ∗ a v l C r e a t e ( i n t ( ∗ getKey ) ( void ∗ ) , void ( ∗ f r e e D a t a ) ( void ∗ ) ) ;
/∗
M o d ifie l a f o n c t i o n de d e s t r u c t i o n d e s donnees .
∗/
void a v l S e t F r e e F u n c t i o n ( a v l ∗ a , void ( ∗ f r e e D a t a ) ( void ∗ ) ) ;
/∗
Affiche les c l e s de l ’AVL a dans l ’ o r d r e c r o i s s a n t , O(n ) .
∗/
void a v l P r i n t K e y s ( a v l ∗ a ) ;
/∗
I n s e r e l a donnee v dans l ’AVL a , O( l o g n ) .
∗/
void a v l I n s e r t ( a v l ∗ a , void∗ v ) ;
/∗
Retourne l a donnee de c l e x s i elle s e t r o u v e dans l ’AVL a ,
NULL sinon , O( l o g n ) .
∗/
void∗ a v l F i n d ( a v l ∗ a , i n t x ) ;
/∗
Supprime l e noeud de c l e k de l ’AVL a , a p p l i q u e l a f o n c t i o n
de d e s t r u c t i o n a l a donnee de c l e k , O( l o g n ) .
∗/
void avlRemove ( a v l ∗ a , i n t k ) ;
/∗
D e t r u i t l ’AVL a , a p p l i q u e l a f o n c t i o n de d e s t r u c t i o n a
t o u t e s l e s donnees du sous−a r b r e , O(n ) .
∗/
void a v l D e s t r o y ( a v l ∗ a ) ;
/∗
Retourne une l i s t e c h a i n e e c o nt e na nt t o u t e s l e s donnees
de l ’AVL a d i s p o s e e s dans l ’ o r d r e c r o i s s a n t , O(n ) .
∗/
l i nk e dL i s t ∗ avlToList ( avl ∗ a ) ;
#en d i f
Et voici avl.c.
#include<m a l l o c . h>
#include ” a v l . h”
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
45
/∗
Noeud de l ’ABR.
∗/
typedef s tr u ct nd
{
/∗
k e y e s t l a c l e du noeud c o u r a nt .
∗/
i n t key ;
/∗
p o i n t e u r v e r s l ’ e l e m e nt de c l e k e y
∗/
void∗ d a t a ;
/∗
h a u t e u r du sous−a r b r e :
0 s i ce noeud e s t une f e u i l l e .
∗/
int height ;
/∗
P o int e u r v e r s l e sous−a r b r e d r o i t .
∗/
s tr u ct nd ∗ l e f t ;
/∗
P o int e u r v e r s l e sous−a r b r e gauche .
∗/
s tr u ct nd ∗ r i g h t ;
} node ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a h a u t e u r de l ’ a r b r e de r a c i n e l ,
−1 s i l e s t v i d e .
∗/
i n t g e t H e i g h t ( node ∗ l )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a p l u s grande d e s deux v a l e u r s i et j .
∗/
i n t max ( i n t i , i n t j )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Met a j o u r l a h a u t e u r de l a r a c i n e l en f o n c t i o n d e s
h a u t e u r s d e s r a c i n e s d e s deux sous−a r b r e s .
∗/
void s e t H e i g h t ( node∗ l )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Cree un noeud c o nt e na nt l a donnee data ,
a ya nt pour sous−a r b r e gauche l e t
pour sous−a r b r e d r o i t r .
∗/
node∗ n o d e Cr e a t e ( i n t ( ∗ getKey ) ( void ∗ ) , node∗ l , void∗ data , node∗ r )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne un a v l v i d e
46
∗/
a v l ∗ a v l C r e a t e ( i n t ( ∗ getKey ) ( void ∗ ) , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
F a i t de f r e e D a t a l a f o n c t i o n de d e s t r u c t i o n d e s donnees .
∗/
void a v l S e t F r e e F u n c t i o n ( a v l ∗ a , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Affiche toutes l e s c l e s du sous−a r b r e de r a c i n e n dans
l ’ ordre c r o i s s a n t .
∗/
void n o d e P r i n t K e y s ( node ∗ n )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e pour t o u s l e s noeuds du sous−a r b r e de r a c i n e n
l a d i f f e r e n c e e n t r e l e s h a u t e u r s du sous−a r b r e d r o i t e t
gauche .
∗/
void n o d e P r i n t L e v e l s ( node∗ n )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n d r o i t e de l ’ a r b r e de r a c i n e x ,
r e t o u r n e l a r a c i n e de l ’ a r b r e a p r e s r o t a t i o n .
∗/
node∗ r o t a t e R i g h t ( node ∗ x )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n gauche de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e L e f t ( node ∗ x )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n gauche−d r o i t e de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e L e f t R i g h t ( node ∗ x )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n d r o i t e −gauche de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e R i g h t L e f t ( node ∗ x )
{
47
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
R e e q u i l i b r e l ’ a r b r e de r a c i n e x , r e t o u r n e l a r a c i n e de
l ’ a r b r e a p r e s r e e q u i l i b r a g e . On p a r t du p r i n c i p e
que l e s h a u t e u r s d e s sous−a r b r e s d r o i t e t gauche d i f f e r e n t
de au p l u s 1 .
∗/
node∗ b a l a n c e ( node∗ x )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
I n s e r e l a donnee v dans l ’ a r b r e de r a c i n e n
e t r e e q u i l i b r e l ’ a r b r e , r e t o u r n e l a r a c i n e de
l ’ arbre apres inse rtion et re e q u i l i b r a g e .
∗/
node∗ n o d e I n s e r t ( i n t ( ∗ key ) ( void ∗ ) , node∗ n , void∗ v )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
I n s e r e l a donnee v dans l ’ a r b r e a , O( l o g n ) .
∗/
void a v l I n s e r t ( a v l ∗ a , void∗ v )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Affiche les c l e s de l ’AVL a dans l ’ o r d r e c r o i s s a n t , O(n )
∗/
void a v l P r i n t K e y s ( a v l ∗ a )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e pour chaque noeud l a d i f f e r e n c e e n t r e l e s hauteurs
d e s sous−a r b r e s d r o i t e t gauche de l ’AVL.
∗/
void a v l P r i n t L e v e l s ( a v l ∗ a )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a donnee de c l e k s i elle s e t r o u v e dans l e sous−a r b r e
de r a c i n e n , NULL sino n .
∗/
void∗ f i n d N o d e ( node∗ n , i n t k )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
NULL sinon , O( l o g n)
∗/
void∗ a v l F i n d ( a v l ∗ a , i n t x )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
48
/∗
F a i t p o i n t e r ∗max v e r s l e noeud de c l e maximale dans
l e sous−a r b r e de r a c i n e n , d e t a c h e l e noeud ∗max de l ’ a r b r e
e t r e t o u r n e l a r a c i n e de l ’ a r b r e a p r e s s u p p r e s s i o n .
∗/
node∗ removeMax ( node∗ n , node ∗∗ max )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
F a i t p o i n t e r ∗min v e r s l e noeud de c l e minimale dans
l e sous−a r b r e de r a c i n e n , d e t a c h e l e noeud ∗min de l ’ a r b r e
∗/
node∗ removeMin ( node∗ n , node ∗∗ min )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Supprime l e noeud de c l e k du sous−a r b r e de r a c i n e n ,
a p p l i q u e l a f o n c t i o n de d e s t r u c t i o n a l a donnee de ce noeud ,
e t r e t o u r n e l a r a c i n e de l ’ a r b r e a p r e s l a s u p p r e s s i o n .
∗/
node∗ removeNode ( node ∗ n , i n t k , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
void avlRemove ( a v l ∗ a , i n t k )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
P l a c e dans l a l i s t e c h a i n e e l t o u t e s l e s donnees
du sous−a r b r e de r a c i n e n dans l ’ o r d r e c r o i s s a n t .
∗/
void n o d e To L i st ( node∗ n , linkedList ∗ l )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
l i nk e dL i s t ∗ avlToList ( avl ∗ a )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e t r u i t t o u s l e s noeuds du sous−a r b r e de r a c i n e n ,
a p p l i q u e l a f o n c t i o n de d e s t r u c t i o n f r a t o u t e s l e s
donnees du sous−a r b r e .
∗/
void n o d e D e st r o y ( node∗ n , void ( ∗ f r ) ( void ∗ ) )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
49
/∗
∗/
void a v l D e s t r o y ( a v l ∗ a )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Pour t e s t e r les algorithmes
∗/
void d e s t r o y I n t ( void∗ i )
{
f r e e ( ( int ∗) i ) ;
}
i n t g e t I n t K e y ( void∗ i )
{
return ∗ ( ( i n t ∗ ) i ) ;
}
void doNothing ( )
{
i n t main ( )
{
int i ;
int∗ d ;
linkedList ∗ l ;
l i n k ∗ m;
a v l ∗ a = a v l Cr e a t e ( getIntKey , d e s t r o y I n t ) ;
f o r ( i = 0 ; i < 40 ; i ++)
{
d = ( int ∗) malloc ( s i zeo f ( int ) ) ;
∗d = i ;
avlInsert (a , d ) ;
}
avlPrintKeys ( a ) ;
avlPrintLevels (a );
f o r ( i = 0 ; i < 40 ; i +=5)
avlRemove ( a , i ) ;
l = avlToList ( a ) ;
f o r (m = l i n k e d L i s t G e t F i r s t ( l ) ; m != NULL ; m = m−>n e x t )
p r i n t f ( ”%d −> ” , ∗ ( i n t ∗ ) (m−>d a t a ) ) ;
p r i n t f ( ” \n” ) ;
l i n k e d L i s t D e s t r o y ( l , doNothing ) ;
avlSetFreeFunction( a , de stroyInt ) ;
avlDestroy (a ) ;
return 0 ;
}
50
Chapitre 8
Modélisation
8.1 Définition
Modéliser est une des compétences les plus importantes en algorithmique. A partir d’un problème concret (in-
dustriel, logistique, économique, etc.), on effectue une modélisation en formalisant le problème avec une terminologie
mathématique, et en reformulant la question de façon précise. Meilleure est la modélisation, plus il est simple de
résoudre le problème.
8.2 Exemple
Voici un exemple de problème : comment placer 8 reines sur un échiquer de sorte qu’aucune ne puisse s’emparer
d’une autre ? Si vous souhaitez réaliser un programme qui résolve ce problème, vous allez d’abord devoir le modéliser
mathématiquement. Dans la plupart des problèmes, on a
– des données : les emplacement des reines
– des contraintes : toutes les reines sont placées, il n’existe pas de couple de reines sur la même ligne, la même
colonne, ou la même diagonale
– une question : est-il possible de placer ces huit reines sans violer de contrainte ?
Il faut donc commencer par réfléchir à une façon de modéliser les emplacement des reines.
8.2.1 Données
Première modélisation
On pourrait, naı̈vement prendre une matrice M de dimensions 8 ∗ 8, et placer 0 dans une case s’il ne s’y trouve pas
de reine, 1 s’il s’en trouve une.
Ou bien considérer huit couples de données qui contiendraient les coordonnées de la case sur laquelle serait placée
chaque reine. Ainsi, la i-ème reine occupe la case (li , ci )
Ou plus simplement, puisqu’il n’y a qu’une reine par ligne, un vecteur de 8 valeurs nous donnerait la colonne sur
laquelle serait placée chaque reine. ci est donc la colonne sur laquelle on a placé la reine de la ligne i.
Bref
Considérons comme critère la place mémoire occupée, il va de soi que ces solutions sont de qualité croissante. Nous
allons voir qu’elles le sont aussi quand il s’agit de poser les contraintes.
51
8.2.2 Contraintes
La façon d’exprimer les contraintes dépend de la façon dont ont été représentées les données.
8 X
X 8
– toutes les reines sont placées : mij = 8
i=1 j=1
X8
– une reine par ligne : ∀i ∈ {1, . . . , 8}, mij = 1
i=1
8
X
– une reine par colonne : ∀j ∈ {1, . . . , 8}, mij = 1
j=1
X X
– pas plus d’une reine par diagonale : ∀p ∈ {2, . . . , 16}, mij ≤ 1 et ∀p ∈ {−7, . . . , 7}, mij ≤ 1.
i+j=p i−j=p
compliqué, non ?
Deuxième modélisation
– toutes les reines sont placées : rien à faire
– une reine par ligne : ∀i ∈ {1, . . . , 8}, ∀j ∈ {1, . . . , 8} tel que i 6= j, li 6= lj
– une reine par colonne : ∀i ∈ {1, . . . , 8}, ∀j ∈ {1, . . . , 8} tel que i 6= j, ci 6= cj
– pas plus d’une reine par diagonale : ∀i ∈ {1, . . . , 8}, ∀j ∈ {1, . . . , 8} tel que i 6= j, |ci − cj | =
6 |li − lj |
C’est plus simple, non ?
Troisième modélisation
– toutes les reines sont placées : rien à faire
– une reine par ligne : rien à faire
– une reine par colonne : ∀i ∈ {1, . . . , 8}, ∀j ∈ {1, . . . , 8} tel que i 6= j, ci 6= cj
– pas plus d’une reine par diagonale : ∀i ∈ {1, . . . , 8}, ∀j ∈ {1, . . . , 8} tel que u 6= j, |i − j| =
6 |ci − cj |
Encore plus simple.
Bref
Vous remarquez que ces modèles sont aussi de qualité croissante si on prend comme critère la simplicité de l’ex-
pression des contraintes.
8.2.3 Question
La question est à chaque fois la même : quelles valeurs donner aux variables pour ne violer aucune contrainte ?
Mais le nombre de jeux de valeurs à donner aux variables n’est pas le même à chaque fois.
1. 264 possibilités, ce qui est de loin supérieur au nombre d’atomes dans l’univers...
2. (82 )8 possibilités, c’est déjà mieux, ça fait ((23 )2 )8 = 248 combinaisons possibles.
3. 88 possibilités, à savoir (23 )8 = 224 combinaisons, ce qui représente seulement quelques millions de possibilités...
Parmi les modélisations proposées, la dernière est donc la meilleure sur tous les plans. Seul inconvénient pour le
moment, on ne voit pas comment résoudre ce problème sans énumérer toutes les possibilités... Nous répondrons à cette
question dans les cours suivants.
8.3 Sensibilisation à la complexité

8.3.1 Le tour de la table
Vous vous attablez deux fois par jour avec votre petite famille de seulement 8 personnes pour manger. Il vous vient
l’idée de changer de place à chaque repas de sorte que l’on ait jamais deux fois la même configuration (i.e. toutes les
52
personnes à la même place). Combien de temps vous faudra-t-il pour vous attabler suivant toutes les configurations
possibles ?
8.3.2 De la terre à la Lune

Vous disposez d’une feuille de papier d’un dixième de millimètre d’épaisseur. Vous décidez de la plier plusieurs
fois sur elle-même (tant que c’est possible). A votre avis, est-il possible de faire 10 pliages, où votre feuille aura-t-elle
la même épaisseur que le Petit Robert ? Pourrez-vous effectuer 30 pliages, ou l’épaisseur de votre feuille sera-t-elle
comparable à la taille d’une terrain de football ? Et en supposant que vous soyez capable de la plier 50 fois sur
elle-même, à combien de fois la distance de la terre à la Lune l’épaisseur de cette feuille sera-t-elle égale ?
8.3.3 En bref
Lorsque vous cherchez des solutions à des problèmes combinatoires, bannissez d’entrée de jeu toute méthode basée
sur une exploration exhaustive de l’ensemble des solutions.
8.4 Terminologie
8.4.1 Difficulté
Nous allons passer en revue dans la section suivante quelques problèmes classiques d’optimisation combinatoire.
Nous les classerons en deux catégories
– Les problèmes faciles : c’est-à-dire ceux qui se résolvent en temps polynomial, autrement dit sans avoir à
explorer l’intégralité des solutions.
– Les problèmes difficiles : c’est-à-dire ceux qu’on ne peut résoudre qu’en explorant toutes les solutions. On dit
que ces problèmes sont NP-Complets.
La définition ci-dessus est très shématique, tenez-vous en à celle-ci pour le moment, un cours sera ultérieurement
consacré à l’etude des problèmes NP-Complets.
8.4.2 Rappels de théorie des graphes

La plupart des problèmes exposés ci-après sont des problèmes de théorie des graphes. Un graphe G est un couple
(S, A) où S est l’ensemble des sommets (ou noeuds) et A l’ensemble des arêtes (ou arcs). Nous ne verrons que des
exemples dans lesquels l’ensemble S est fini, sachant qu’il peut contenir n’importe quoi (des entiers, des réels, des
couples de matrices, ds sous-ensembles de IR, des graphes, etc.). L’ensemble A par contre ne peut contenir que des
couples (si le graphe est orienté, des paires si le graphe n’es pas orienté) d’éléments de S. Par exemple, G = (S, A)
avec
S = {(1, 2), (2, 3), (1, 3), (4, 5), (5, 4)}
et
A = {((1, 2), (2, 3)), ((1, 2), (1, 3)), ((4, 5), (5, 4)), ((5, 4), (4, 5)), ((1, 3), (1, 3)), ((2, 3), (1, 2))}
est un graphe (orienté en l’ocurrence). Si un graphe est orienté, on ne dit plus sommets mais noeuds, et on ne dit plus
arêtes mais arcs.
Les graphes sont quelquefois valués, c’est-à-dire qu’il existe une application de A dans un sous-ensemble de IR. Ils
sont quelquefois pondérés, c’est-à-dire qu’il existe une application de S dans un sous-ensemble de IR.
8.4.3 Définition d’un problème

La plupart des problèmes suivants sont définis en deux temps :
– des données
– une question
Les questions permettent de classer les problèmes en plusieurs catégories :
– les problèmes de décision : questions de la forme “existe-t-il...”, la réponse est oui ou non.
– les problèmes de satisfaction de contraintes : questions de la forme “trouver une solution vérifiant...”. La
réponse doit juste satisfaire des contraintes.
53
– les problèmes d’optimisation : questions sous la forme ”trouver ... minimal (ou maximal) tel que...”. La réponse
doit satisfaire des contraintes et être optimale.
8.4.4 Problèmes d’optimisation

Dans un problème d’optimisation, la valeur que l’on cherche à maximiser, ou à minimiser, s’appelle la fonction
objectif. Une solution d’un problème d’optimisation est dite
– réalisable si elle ne viole aucune contrainte.
– optimale si elle est la meilleure des solutions réalisables.
Notez qu’il peut y avoir plusieurs solutions optimales. Tout comme il peut ne pas y avoir de solution réalisable,
dans ce cas le problème d’optimisation n’a pas de solution.
8.5 Problèmethèque
8.5.1 Arbre couvrant de poids minimal
Soit G = (S, A) un graphe non orienté muni d’une valuation des arêtes c, T = (ST , SA ) est un arbre couvrant G si
– T est un arbre
– ST = S
– T est connexe
Le poids de T est X
c(a)
a∈AT
Le problème de l’arbre couvrant de poids minimal est le suivant :

– données : un graphe G, une valuation c
– question : trouver l’arbre T de plus petit poids parmi les arbres couvrant G.
Ce problème (d’optimisation) est facile, les deux algorithmes les plus connus sont ceux de Primm et de Kruskall.
8.5.2 Ensemble stable maximal

Soit G = (S, A) un graphe non orienté muni d’une pondération p un sous-ensemble K de S est un ensemble stable
si
∀a = (e, e′ ) ∈ A, e 6∈ K ou e′ 6∈ K
Le poids de cet ensemble stable est X
p(s)
s∈K
Le problème de l’ensemble stable maximal est défini comme suit :

– données : un graphe G, une pondération p
– question : trouver le sous-ensemble K de poids maximal parmi les ensembles stables de G.
Ce problème est NP-Complet dans le cas général, polynomial si le graphe est un arbre ou est biparti
8.5.3 Circuit eulérien

Etant donné un graphe G orienté ou non, un circuit eulérien dans G est un circuit passant par une et une seule
fois par chaque arête de G. Le problème est le suivant :
– données : un graphe G
– question : trouver un circuit eulérien dans G.
Ce problème est polynomial, il se résoud avec un algorithme inspiré par les travaux d’Euler sur les graphes.
54
8.5.4 Circuit hamiltonien
Soit G un graphe (orienté ou non), un circuit hamiltonien dans G est un circuit passant par une et une seule fois
par chaque sommet de G. Le problème du circuit hamiltonien est le suivant :
– question : trouver un circuit hamiltonien dans G.
Ce problème est NP-Complet.
8.5.5 Voyageur de commerce

Soit G un graphe (orienté ou non) valué par une fonction c, le poids d’une chemin (ou d’un circuit) K la somme,
pour toute arête a de K, des c(a).
– question : trouver un circuit hamiltonien de poids minimal dans G.
8.5.6 SAT
Soit une expression booléenne à n variables sous forme clausale (conjonction de disjonctions), par exemple,
(x1 ∨ ¬x3 ∨ x2 ) ∧ (¬x2 ) ∧ (¬x1 ∨ x3 ) ∧ (x3 ) ∧ (x1 ∨ x2 ∨ x3 ∨ x4 )

Les clauses (contenant des disjonctions) sont notées
{C1 , c2 , . . . , ck }
Toute clause est formée de ki littéraux

Ci = l1i , l2i , . . . , lki i
chaque littéral l est soit une variable (l = xj ), soit la négation d’une variable (l =6 xj ). Une affectation A des variables
est une application de {x1 , . . . , xn } dans {true, f alse}.
– Si A(xj ) = true, alors l est satisfait si l = xj , non satisfait sinon
– si A(xj ) = f alse, alors lj est satisfait si l = ¬xj , non satisfait si l = xj
Une clause est satisfaite si au moins un des littéraux qui la forment est satisfait. Une expression sous forme clausale
est satisfaite si toutes les clauses sont satisfaites. Le problème est le suivant :
– données : n variables, k clauses de chacune ki littéraux, chacun correspondant à une variable ou à la négation
d’une variable.
– question : trouver une affectation qui satisfasse toutes les clauses (donc au moins un littéral par clause)
Ce problème (de satisfaction de contraintes) est NP-Complet dans le cas général, et facile si les clauses contiennent au
plus 2 littéraux.. Remarquons que si la question avait été ”existe-t-il une affectation qui satisfasse toutes les clauses ?”,
ce problème serait un problème de décision.
8.5.7 Couverture
Soit G = (S, A) un graphe non orienté muni d’une pondération p un sous-ensemble K de S est une couverture si
∀a = (e, e′ ) ∈ A, e ∈ K ou e′ ∈ K
Le poids de cette couverture est X

p(s)
s∈K
Le problème de la couverture minimale est défini comme suit :

– données : un graphe G, une pondération p
– question : trouver le sous-ensemble K de poids minimal parmi les couvertures de G.
Ce problème est NP-Complet dans le cas général, polynomial si le graphe est un arbre ou est biparti.
55
8.5.8 Coloration
Soit G = (S, A) un graphe non orienté, une k-coloration c de g est une application de S dans un ensemble E tel
que |E| = k vérifiant
∀(e, e′ ) ∈ A, c(e) 6= c(e′ )
Le problème de la k-coloration est défini comme suit :
– question : trouver une k-coloration de G.
Le nombre chromatique χG d’un graphe est la plus petite coloration de ce graphe. Autrement dit,
χG = min{k|G est k − colorable}
– question : trouver le nombre chromatique de G.
Ce problème est aussi NP-Complet.
8.5.9 Plus court chemin

Soit g un graphe orienté (ou non) muni d’une valuation de arêtes c. Un chemin C de longueur p dans G est un
p-uplet (c1 , . . . , cp ) d’éléments de A tel que si ci = (si , ti ), alors pour tout i ∈ {1, . . . , p − 1}, ti = si+1 . C est un chemin
de u ∈ S à v ∈ S si s1 = u et tp = v.
Le problème du plus court chemin dans un graphe valué se définit comme suit :
– données : un graphe G valué, deux sommets u et v
– question : trouver le plus court chemin de u à v dans G.
Ce problème est polynomial, Les deux algorithmes les plus connus sont
– Dijkstra : très rapide, O(|S| + |A|) dans le pire des cas, mais ne fonctionne qu’avec les valuations positives, ne
nécessite pas le parcours de tout le graphe.
– Bellman : un peu moins rapide, il présente l’avantage de fonctionner avec des valuations négatives, sauf si le
graphe contient un circuit absorbant (i.e. négatif).
8.5.10 Sac à dos

Etant donné un ensemble A = {a1 , . . . , an }, des poids positifs{pi |i ∈ {1, . . . , n}}, des valeurs positives X {vi |i ∈
{1, . . . , n}}, et une constante positive K. Une solution réalisable est un sous-ensemble I de {1, . . . , n} tel que pi ≤ K,
X i∈I
la valeur de la fonction objectif est vi . Le problème du sac à dos est le suivant :
i∈I
– données : un ensemble A muni de deux valuations {pi |i ∈ {1, . . . , n}} et {vi |i ∈ {1, . . . , n}}, et une constante
K>0 X X
– question : trouver le sous ensemble B de A maximisant vi sous la contrainte pi ≤ K.
i∈I i∈I
8.6 Exercices
Exercice 1 - Digicode
Vous souhaitez craker un digicode, vous devez pour cela trouver un code de k chiffres, le digicode en comportant
n.
1. Combien de chiffres seront, dans le pire des cas, saisies sur le clavier si vous décidez d’énumérer tous les codes
les uns à la suite des autres, et suivant un ordre lexicographique ?
2. Si vous décidez d’entremêler les codes les uns dans les autres, donnez un minorant de la meilleure méthode
envisageable.
56
3. Modélisez ce problème comme un problème de recherche d’un circuit hamiltonnien dans un graphe orienté. La
résolution est-elle facile ?
4. Modélisez ce problème comme un problème de recherche d’un circuit eulérien dans un graphe, le problème est-il
facile ?
Exercice 2 - Rattrapages
Un ensemble E = {e1 , . . . , en } doivent passer des sessions de rattrapages dans les matières M = {m1 , . . . , mk }.
Vous disposez d’un ensemble de couples C = (c1 , . . . , cj ) tel ci = (e, m) signifie que l’étudiant e doit repasser la matière
m. Nous souhaitons organiser les rattrapages en affectant chaque épreuve à un jour. Plusieurs épreuves puissent se
dérouler le même jour tant qu’un même candidat n’a pas deux ratrappages à effectuer le même jour. Nous souhaitons
minimiser le nombre de jours que dureront les rattrapages.
1. Comment modéliser le problème de la façon la plus simple possible ?
2. Est-il polynomial ?
Exercice 3 - Gardiens de prison

Une prison est contituée de couloirs qui s’intersectent en de multiples points. Le directeur souhaiterait, avec un
minimum de gardiens, surveiller les couloirs. il faudrait pour cela, placer les gardiens aux intersections des couloirs de
sorte que chaque couloir soit visible par au moins un gardien. Comment modéliser ce problème en théorie des graphes ?
Exercice 4 - le savant fou en voyage

Un chimiste souhaite transporter les produits A, B, C, D, E, dans des valises. Les couples de produits suivants ne
doivent en aucun cas être transportés dans la même valise :
– A et C
– A et D
– C et D
– A et B
– B et D
– A et E
– E et C
Le but est de répartir les produits dans un minimum de valises.
1. Ramenez-vous à un problème classique de théorie des graphes. Dessinez le graphe.
2. Ce problème est-il NP-Complet ?
3. Proposez une solution réalisable à trois valises pour ce problème.
Exercice 5 - ensemble stable et k-coloration

Soit G = (S, A) un graphe, k une constante strictement positive. On s’intéresse à la k-colorabilité du graphe G (i.e.
peut-on colorier le graphe G avec k couleurs ?). Nous allons créer un graphe G′ = (S ′ , A′ ) à partir de G en procédant
de la façon suivante :
– A chaque sommet s de G, on associe k sommets de G′ , notés {(s, 1), . . . , (s, k)}, tous reliés entre eux par des
arêtes.
– Pour chaque arête {e, e′ } de G, et chaque couleur j, on relie dans G′ les sommets (e, j) et (e′ , j). Notez bien que
comme les sommets sont des couples, les arêtes sont des paires de couples.
Plus formellement,
–
S ′ = {(s, j)|s ∈ S, j ∈ {1, . . . , k}}
est un ensemble de couples (sommet de G/couleur).
–
A′ = A1 ∪ A2
57
avec
A1 = {{(s, j), (s, j ′ )}|s ∈ S, 1 ≤ j < j ′ ≤ k}
un ensemble d’arêtes formant |S| sous-graphes complets de k sommets et
A2 = {{(e, j), (e′ , j)}|{e, e′ } ∈ A, j ∈ {1, . . . , k}}
un ensemble d’arêtes interconnectant ces sous-graphes.

Le but de cet exercice est de montrer qu’en trouvant un ensemble stable de |S| sommets dans G′ , on trouve aussi
une k-coloration de G.
1. Soit G le graphe de l’exercice précédent, on pose k = 3. Représentez graphiquement G′ .
2. Donnez une définition en français (avec des mots) de ce qu’est un ensemble stable.
3. Ce problème (existe-t-il un ensemble stable de |S| sommets dans G′ ?) est-il NP-Complet ?
4. Donnez un ensemble stable de 5 sommets dans ce graphe.
5. Utilisez cet ensemble stable pour déterminer une 3-coloration de G.
6. Démontrez de façon formelle et avec le plus de rigueur possible que, étant donné un graphe G arbitraire, un
nombre k > 0, G est k-colorable si et seulement s’il existe un ensemble stable de |S| sommets dans G′ .
Exercice 6 - Ordonnancement
En votre qualité de manager, vous vous retrouvez confronté au problème suivant : vous avez un ensemble de tâches
à effectuer, chacune d’elle ayant un temps d’exécution connu à l’avance et une date de fin souhaitée. De plus, il existe
pour chaque tâche une date avant laquelle il n’est pas possible de commencer son exécution. Votre équipe ne peut pas
travailler sur deux tâches différentes en même temps et il n’est pas possible de fractionner ou d’interrompre l’exécution
d’une tâche. Si l’exécution d’une tâche n’est pas achevée avant la date de fin souhaitée, on dit de cette tâche qu’elle
est en retard. Votre objectif est de déterminer un calendrier d’exécution des tâches de sorte à minimiser la somme des
retards. Voici les projets à réaliser en septembre :
numéro nom exécution au plus tôt durée deadline
1 changer la plomberie 1 1 6
2 débugger le projet A 2 3 4
3 nettoyer la voiture du PDG 1 1 6
Par exemple, l’installa-
4 installer le progiciel B 8 2 23
5 créer la base de donnée pour C 1 5 12
6 coder une interface graphique pour C 10 5 15
7 préparer le planning d’octobre 17 2 19
tion du progiciel B prend 2 jours consécutifs, elle ne peut pas commencer avant le 8 septembre, et doit se terminer au
plus tard le 23 septembre. Il possible de commencer le 8 et de terminer le 9 tout comme il est possible de commencer
le 22 et de terminer le 23.
1. Donnez une solution réalisable pour ce problème. Vous présenterez la solution sous forme d’un tableau, chaque
tâche occupera une ligne et celles-ci seront disposées dans l’ordre de leur exécution. Vous utiliserez quatre colonnes
– le nom de la tâche
– la date de début
– le temps d’exécution
– la date de fin d’éxecution
2. Formalisons le problème.
– Données : un nombre n de tâches, un ensemble de durées {d1 , . . . , dn }, un ensemble de dates de début
d’exécution au plus tôt {r1 , . . . , rn }, un ensemble de dates de fin d’exécution au plus tard {f1 , . . . , fn }, une
constante M .
– Question : Existe-t-il un ordre d’exécution des tâches tel que la somme cumulée des retards n’excède pas M ?
Nous appelerons ce problème SCHEDULING. Soient {s1 , . . . , sn } les dates de début d’exécution de chacune des
tâche. Soient {t1 , . . . , tn } les dates de fin d’exécution. Donnez une relation simple entre ti , si et di . Prenez bien
soin de vérifier que cette relation est vérifiée dans l’exemple de la question précédente.
3. L’exécution de la tâche i ne peut pas commencer avant la date ri . Exprimez cette contrainte avec les notations
des questions précédentes.
58
4. Deux tâches d’indices respectifs i et j ne peuvent pas se superposer, exprimez cette contrainte à l’aide d’une
proposition portant sur si , sj , ti et tj .
5. Combien y a-t-il de contraintes de cette forme ? Vous justifierez votre réponse en dénombrant les couples (i, j)
tels que 1 ≤ i < j ≤ n.
6. Nous notons max(a, b) la plus grande des deux valeurs a et b. A quoi correspond la valeur max(0, ti − fi ) ?
7. Nous choisissons comme fonction objectif la somme cumulée des retards. Exprimez cette fonction objectif à partir
des ti et des fi
8. Exprimez la condition “la somme cumulée des retards n’excède pas M ” avec les notations de la question
précédente
Exercice 7 - Sac-à-dos
Nous souhaitons résoudre le problème du sac à dos par énumération exhaustive des solutions, c’est à dire comme des
boeufs. Nous représenterons une solution s (réalisable ou non) par la liste chaı̂née des indices des objets sélectionnés
dans s. Nous représenterons une instance i par deux tableaux p (poids des objets) et v (valeurs des objets). Une
solution sera la liste chaı̂née des indices des objets placés dans le sac. Ecrivez les corps des sous-programmes suivants :
1. void* linkedListCopy(void* l). Copie les maillons de la liste chaı̂née l, mais pas les valeurs pointées par les
maillons. Vous utiliserez linkedListMap.
2. Ecrivez le sous-programme void knapSackPrintSolution(linkedList* l), affiche la liste des indices formant
la solution l, vous utiliserez linkedListApply.
3. Ecrivez un sous-programme linkedList* parties(linkedList* l), ce sous-programme prend en paramètre
un ensemble représenté par une liste chaı̂née et retourne une liste chaı̂née dans laquelle chaque maillon est une
liste chaı̂née contenant une partie de l. Vous utiliserez linkedListApply.
4. void knapSackPrintParties(linkedList* l), affiche toutes les parties de l, vous utiliserez linkedListApply.
5. void knapSackDestroyParties(linkedList* l) détruit l et les listes chaı̂nées pointées par chaque maillon de
cette liste.
Nous représenterons une instance du problème sac à dos avec une variable du type :
typedef struct
{
/∗
nombre t o t a l d ’ o b j e t s
∗/
long nbItems ;
/∗
t a b l e a u de n ombreO bjet s e l e m e n t s c o n t e n a n t l e p o i d s de
chaqu e e l e m e n t
∗/
long∗ w e i g h t s ;
/∗
t a b l e a u de n ombreO bjet s e l e m e n t s c o n t e n a n t l a v a l e u r de
chaqu e e l e m e n t
∗/
long∗ v a l u e s ;
/∗
Poids maximum qu ’ i l e s t p o s s i b l e de p l a c e r dans l e s a c à dos .
∗/
long maxWeight ;
} knapSack ;
59
Ecrivez les corps des sous-programmes suivants :
1. knapSack* knapSackMake(long nbItems, long maxWeight), alloue la mémoire pour contenir l’instance ainsi
que les deux tableaux.
2. void knapSackSetItem(knapSack* k, long index, long value, long weight), fixe les poids (weight) et
valeur (value) de l’objet d’indice i de l’instance k.
3. long knapSackValue(knapSack* instance, linkedList* solution), retourne la somme des valeurs des ob-
jets de instance dont les indices sont dans la liste solution. Vous utiliserez la fonction linkedListApply.
4. long knapSackWeight(knapSack* instance, linkedList* solution), retourne le poids de la solution solution
relative à l’instance instance. Vous procéderez de la même façon que dans la question précédente.
5. int knapSackIsFeasible(knapSack* instance, linkedList* solution), retourne vrai si est seulement si la
solution solution relative à l’instance instance est réalisable.
6. void knapSackPrintInstance(knapSack* k), affiche la liste des poids des des valeurs de tous les objets de
l’instance k. Par exemple,
(i = 0, v = 1, w = 1)
(i = 1, v = 2, w = 2)
(i = 2, v = 9, w = 7)
(i = 3, v = 8, w = 2)
(i = 4, v = 5, w = 7)
(i = 5, v = 6, w = 6)
(i = 6, v = 7, w = 7)
(i = 7, v = 4, w = 2)
(i = 8, v = 3, w = 7)
(i = 9, v = 10, w = 2)
(i = 10, v = 1, w = 1)
(i = 11, v = 2, w = 2)
(i = 12, v = 9, w = 7)
(i = 13, v = 8, w = 2)
(i = 14, v = 5, w = 7)
(i = 15, v = 6, w = 6)
(i = 16, v = 7, w = 7)
(i = 17, v = 4, w = 2)
(i = 18, v = 3, w = 7)
(i = 19, v = 10, w = 2)
(i = 20, v = 1, w = 1)
7. void knapSackDestroy(knapSack* k), vous avez vraiment besoin que je vous donne des indications ?
8. linkedList* knapSackListInit(long n), retourne une liste chaı̂née contenant les éléments {1, . . . , n}. Vous
l’implémenterez de façon récursive.
9. linkedList* knapSackBruteForceSolve(knapSack* k) retourne la liste chaı̂née contenant la liste des indices
des objets formant la solution optimale du problème k.
10. Jusqu’à quelle valeur de n parvenez-vous à résoudre le problème ?
11. Montrez que le temps d’exécution est proportionnel au nombre de maillons crées, toutes listes confondues.
12. Evaluez le nombre de maillons en fonction de n, donnez la complexité de la résolution de knapsack par énumération
de toutes les solutions.
13. Est-ce que cela vous explique pourquoi l’exécution est si longue ?
60
Chapitre 9
Programmation linéaire
9.1 Exemple
Nous disposons de 500 kilos de matière première MA , et de 600 kilos de matière première MB . Pour fabriquer un
exemplaire de produit P1 il faut 10 kilos de MA et 20 kilos de MB , pour fabriquer un exemplaire de produit P2 il faut
20 kilos de MA et 10 kilos de MB . La vente d’un exemplaire de P1 rapporte 10 euros, celle d’une exemplaire de P2
rapporte 12 euros. Soit x1 le nombre de produits P1 fabriqués x2 le nombre de produits P2 fabriqués. Comment fixer
x1 et x2 pour maximiser les bénéfices ?
Ce problème se modélise et se note de la façon suivante :

 max 10x1 + 12x2

s.c. 10x1 + 20x2 ≤ 500


 20x1 + 10x2 ≤ 600
x1 , x2 ≥ 0

9.2 Algorithme du simplexe en bref

Le but de ce cours n’est pas de vous apprendre comment on résoud les programmes linéaires, mais comment on
les modélise. Ces problèmes se résolvent, en pratique, en temps polynomial. Un des algorithmes les plus connus est
l’algorithme du simplexe. Je n’expliquerai ici que le principe, pour plus de détails, voir [5]. Les contraintes peuvent
être représentées par des demi-plans. L’ensemble des solutions réalisables est l’intersection de ces demi-plans, cette
intersection forme un polygone convexe. Soit z un réel, l’ensemble des couples (x, y) tel que la fonction objectif prend
la valeur z est une droite dz .
En Augmentant la valeur de z, on “déplace” dz . On cherche donc la plus grande valeur de z telle qu’au moins
un point de dz se trouve dans l’ensemble des solutions réalisables. Il se trouve qu’à l’optimum, la droite dz passe par
un des sommets du polygone des solutions réalisables. L’algorithme du simplexe parcours les sommets de ce polygone
jusqu’à atteindre cet optimum. Cette méthode se généralise facilement à un nombre de variables et de contraintes
arbitraires.
9.3 Modéliser un programme linéaire

Un programme linéaire à n variables et à m contraintes est de la forme suivante :


 max c1 x1 + . . . + ci xi + ... + cn xn


 s.c. a11 x1 + . . . + a1i xi + ... + a1n xn ≤ b1
. .. .. ..



 .. . . .

 aj1 x1 + . . . + aji xi + ... + ajn xn ≤ bj

 .. .. .. ..
. . . .




am1 x1 + . . . + ami xi + ... + amn xn ≤ bm

61
Soient x le vecteur à n lignes et 1 colonne
 
x1
 .. 
 . 
xn
c le vecteur à n lignes et 1 colonne
 
c1
 .. 
 . 
cn
Alors on exprime la valeur de la fonction objectif avec le produit scalaire ct x. Soit A la matrice à m lignes et n
colonnes
 
a11 . . . a1i . . . a1n
 .. .. .. 
 . . . 
 
 aj1 . . . aji . . . ajn 
 
 . .. ..
 ..

. . 
am1 . . . ami . . . amn
et b le vecteur à m lignes et 1 colonne
 
b1
 .. 
 . 
bm
Alors les contraintes s’écrivent
Ax ≤ b
Finalement, un programme linéaire est de la forme
max ct x

s.c. Ax ≤ b
Exercice 1 - Problème de transport

Une entreprise de fabrication de mort aux rat dispose de n points de fabrication, produisant pi (1 ≤ i ≤ n) tonnes
par jour. Il faut acheminer dans m points de vente les quantités dj (1 ≤ j ≤ m). On a bien sûr
n
X m
X
pi ≥ dj
i=1 j=1
Le coût d’acheminement de 1 tonne de mort au rat du point de fabrication i au point de vente j est donné par c(i, j).
Comment faire pour satisfaire la demande de chaque point de vente tout minimisant le coût total d’acheminement ?
Modélisez ce problème par un programme linéaire.
Exercice 2 - Minimiser le nombre de transactions

m personnes partent en vacances et paient de façon anarchique pendant leur séjour. A leur retour, ils font les
comptes et le chargé des comptes dessine un graphe orienté G = (S, A) muni d’une valuation c où
– chaque élément de S est une personne
– chaque couple (i, j) ∈ A signifie la personne i doit c(i, j) euros à la personne j
Représentez le graphe correspondant aux donnés suivantes :
1. A doit 147 euros à C
62
2. B doit 57 euros à A
3. E doit 228 euros à B
4. B doit 129 euros à D
5. D doit 78 euros à A
6. C doit 45 euros à B
7. B soit 187 euros à E
On remarque que ce graphe contient des circuits, et que pour certains couples, de sommets, il existe plusieurs
chemins. Utiliser le graphe tel qu’il est pour planifier les remboursements conduirait à des remboursements redondants
(C donne à B qui donne à A qui donne à C...). En réfléchissant, il remarque que peu importe qui rembourse qui, ce qui
compte, c’est que chacun retrouve son argent. Pour simplifier le problème, il décompose donc S en deux sous-ensembles
S + (ceux à qui on doit de l’argent qu’ils n’en doive) et S − (ceux qui doivent de l’argent plus qu’on leur en doit).
Chaque sommet s est étiqueté par la valeur
X X
| c(s, t) − c(t, s)|
t∈Γ+ (s) t∈Γ− (s)
Quels sont les sommets et les étiquettes des sommets de ce nouveau graphe ? La question est de trouver comment
placer les arêtes de la façon la plus simple possible. Modélisez ce problème comme un problème de flot max. Nous
souhaitons maintenant minimiser le nombre de transaction. Est-ce possible avec un algorithme de flot maximum ?
Nous verrons dans une autre section que ce problème est NP-Complet.
Exercice 3 - Plaques d’égoût

Une entreprise de fabrication de plaques d’égoûts dispose de n points de fabrication, produisant pi (1 ≤ i ≤ n)
plaques par jour. Il faut chaque jour acheminer dans m centres les quantités dj (1 ≤ j ≤ m). Toutes les distances sont
suffisament courtes pour que chaque trajet puisse être fait par un seul camion dans une même journée. La production
est faite telle que
n
X m
X
pi = dj
i=1 j=1
Chaque camion à une contenance K, le problème est comment affecter chaque camion à un centre de fabrication et
un centre de livraison pour utiliser un minimum de camions ? Montrez que ce problème est le même que le précédent.
Exercice 4 - Regression linéaire et écart-absolu

Soit une série statistique bivariée {(xi , yi )|i = 1, . . . , n}, une regression linéaire consiste en la recherche de la droite
passant au plus près des points représentés dans un repère orthonormé à deux dimensions.
Soit y = ax + b l’équation de cette droite. Alors, on approxime yi avec la valeur axi + b. L’écart absolu entre yi et
son approximation est |axi + b − yi |. Nous souhaitons minimiser la somme es écarts absolus
n
X
|axi + b − yi |
i=1
Modélisez ce problème comme un problème de programmation linéaire.
9.4 GLPK
9.4.1 Qu’est-ce que c’est ?
GLPK [6] est une librairie de résolution de programmes linéaires. Elle contient une implémentation de l’algorithme
du simplexe. Il est possible de lancer GLPK en ligne de commande, ou bien d’importer la librairie dans un programme
C.
63
9.4.2 Où le trouver ?
Utilisez urpmi ou apt-get.
9.4.3 La documentation
Le manuel de référence[7] est très complet mais quelque peu difficile à lire quand on n’est pas habitué. Cette annexe
est aussi là pour vous vous aider à le lire.
9.4.4 Les fonctions

Exemple
Nous allons illustrer le fonctionnement de GLPK en résolvant le problème


 max 10x1 + 12x2
s.c. 10x1 + 20x2 ≤ 500


 20x1 + 10x2 ≤ 600
x1 , x2 ≥ 0

Le programme C ci-dessous modélise ce problème et l’envoie dans glpk.
#include ” g l p k . h”
i nt main ( )
{
LPX∗ l p = l p x c r e a t e p r o b ( ) ;
double c o e f f s [ 4 + 1 ] ;
i nt rows [ 4 + 1 ] , c o l s [ 4 + 1 ] ;
l p x s e t o b j d i r ( lp , LPX MAX ) ;
l p x a d d r o w s ( lp , 2 ) ;
l p x s e t r o w b n d s ( lp , 1 , LPX UP , 0 . 0 , 5 0 0 . 0 ) ;
l p x s e t r o w b n d s ( lp , 2 , LPX UP , 0 . 0 , 6 0 0 . 0 ) ;
l p x a d d c o l s ( lp , 2 ) ;
l p x s e t c o l b n d s ( lp , 1 , LPX LO , 0 . 0 , 0 . 0 ) ;
l p x s e t c o l b n d s ( lp , 2 , LPX LO , 0 . 0 , 0 . 0 ) ;
l p x s e t o b j c o e f ( lp , 1 , 1 0 . ) ;
l p x s e t o b j c o e f ( lp , 2 , 1 2 . ) ;
c o e f f s [ 1 ] = 10 ; rows [ 1 ] = 1 ; c o l s [ 1 ] = 1 ;
c o e f f s [ 2 ] = 20 ; rows [ 2 ] = 1 ; c o l s [ 2 ] = 2 ;
c o e f f s [ 3 ] = 20 ; rows [ 3 ] = 2 ; c o l s [ 3 ] = 1 ;
c o e f f s [ 4 ] = 10 ; rows [ 4 ] = 2 ; c o l s [ 4 ] = 2 ;
l p x l o a d m a t r i x ( lp , 4 , rows , c o l s , c o e f f s ) ;
lpx simplex ( lp ) ;
p r i n t f ( ” v a l e u r de l a f o n c t i o n o b j e t i f : %l f \n” , l p x g e t o b j v a l ( l p ) ) ;
p r i n t f ( ” q u a n t i t e de p r o d u i t s A : %l f \n” , l p x g e t c o l p r i m ( lp , 1 ) ) ;
p r i n t f ( ” q u a n t i t e de p r o d u i t s B : %l f \n” , l p x g e t c o l p r i m ( lp , 2 ) ) ;
lpx delete prob ( lp ) ;
return 1 ;
}
N’oubliez pas de compiler vos sources avec l’option -lglpk (sinon, ça marche pas).
Importation
Avant toute chose, n’oubliez pas
#include ’ ’ g l p k . h ’ ’
64
Création, suppression
GLPK met à votre disposition le type LPX, une variable de ce type est un programme linéaire. On crée un programme
linéaire avec la fonction lpx create prob(), on le détruit avec lpx delete prob(LPX*).
Nombre de variables et de contraintes

Les programmes linéaires sont usuellement représentés par des tableaux :

 max c1 x1
 + . . . + ci xi + ... + cn xn


 s.c. a x
11 1 + . . . + a1i xi + ... + a1n xn ≤ b1
. .. .. ..



 .. . . .
 a j1 x1 + . . . + a ji xi + ... + ajn xn ≤ bj
. . .. ..


.. ..

. .




am1 x1 + . . . + ami xi + ... + amn xn ≤ bm

Vous remarquez que ce programme à n variables et à m contraintes est formé d’un grand tableau, à n + 1 colonnes,
et à m + 1 lignes. Dans la terminologie de GLPK,
– Une variable est une colonne (col)
– Une contrainte est une ligne (row)
La fonction lpx add rows(LPX*, int) spécifie le nombre de contraintes, lpx add cols(LPX*, int) spécifie le
nombre de variables.
La fonction objectif
Soyez très atentifs : les indices sous GLPK commençent à 1. La fonction lpx set obj coef(LPX*, int
numeroDeLigne, double coefficient) permet de préciser la valeur d’un coefficient de la fonction objectif. Par
exemple, pour affecter la valeur 3.0 à c2 dans le programme mylp, on utilise l’instruction lpx set obj coef(mylp,
2, 3.0). Selon le contexte, on cherche à minimiser ou à maximiser la fonction objectif, on le précise avec la fonction
lpx set obj dir(LPX*, int direction). Il existe deux directions : LPX MIN et LPX MAX.
Le deuxième membre de l’inégalité

Il n’est sujet dans cette section que du membre de droite des inégalités formant les contraintes, nous verrons
dans une partie ultérieure comment définir le membre de gauche de chaque contrainte. Il existe plusieurs formes de
contraintes, par exemple,
aj1 x1 + . . . + aji xi + . . . + ajn ≤ bj

Cette forme se note LPX UP (upper). Une contrainte de la forme
aj1 x1 + . . . + aji xi + . . . + ajn xn ≥ bj

se note LPX LOW (lower). Pour d’autres formes, reportez-vous à la documentation. On spécifie la forme d’une
contrainte avec la fonction lpx set row bnds(LPX*, int indiceLigne, int forme, double borneInf, double borneSup).
Par exemple, la forme de la contrainte
a41 x1 + . . . + a4i xi + . . . + a4n xn ≤ 67

se spécifie avec l’instruction lpx set row bnds(mylp, 4, LPX UP, 0.0, 67.0). La forme de la contrainte
a41 x1 + . . . + a4i xi + . . . + a4n xn ≥ 67

se spécifie avec l’instruction lpx set row bnds(mylp, 4, LPX LO, 67.0, 0.0). Notez que certains paramètres
sont ignorés, le quatrième si la contrainte est de la forme LPX UP, le cinquième si la contrainte est de la forme LPX LO.
65
Les domaines des variables
Il est possible d’ajouter des contraintes sur les valeurs des variables. Par exemple, les contraintes suivantes
x1 , x2 ≥ 0
font partie du programme linéaire donné en exemple. La fonction lpx set col bnds(LPX*, int indiceColonne,
int forme, double borneInf, double borneSup). Par exemple, si x est d’indice 4, et qu’on tient à l’empêcher de
prendre des valeurs négatives, on le spécifie avec l’instruction lpx set col bnds(mylp, 4, LPX LO, 0.0, 0.0).
Les coefficients des contraintes

Les coefficients des contraintes sont tous initialisés à 0. Si vous tenez à ce que certains prennent des valeurs non
nulles, vous devez le spécifier avec la fonction lpx load matrix(LPX*, int nbCoeffs, int* lignesDesCoefficients,
int* colonnesDesCoefficients, double* coefficients) ;. Cette fontion prend en paramètre la taille des trois ta-
bleaux lignesDesCoef f icients, colonnesDesCoef f icients et coef f icients. Le i-ème élément de coef f icients est le
coefficient de la contrainte d’indice colonnesDesCoef f icients[i] et de la ligne d’indice lignesDesCoef f icients[i]. Par
exemple, pour spécifier l’unique contrainte du programme linéaire

 max x1 + x2
s.c. 5x1 + 4x2 ≤ 3
x1 , x2 ≥ 0

on initialise les tableaux de la sorte

coefficients [1] = 5 ;
lignesDesCoefficients [1] = 1 ;
colonnesDesCoefficients [ 1] = 1
coefficients [2] = 4 ;
lignesDesCoefficients [2] = 1 ;
colonnesDesCoefficients [ 2] = 2
Ensuite, il n’y a plus qu’à invoquer
l p x l o a d m a t r i x ( mylp , 2 , l i g n e s D e s C o e f f i c i e n t s ,
colonnesDesCoefficients , c o e f f i c i e n t s ) ;
L’algorithme du simplexe
lpx simplex(LPX*) exécute l’algorithme du simplexe sur le problème passé en paramètre. La fonction double
lpx get obj value(LPX*) retourne la valeur de la fonction objectif à l’optimum. double lpx get col primm(LPX*,
int indiceVariable) retourne la valeur de la indiceV ariable-ème variable à l’optimum.
Exercice 5 - Prise en main de GLPK

Utilisez GLPK pour résoudre le programme linéaire :


 max 4x1 + 6x2 + 2x3
 s.c. 3x1 + 7x2 + x3 ≤ 12


3 14
5 x1 + 3x2 + 5 x3 ≤ 3
9
9x + 100 x2 + 5x3 ≤ 6

1



x1 , x2 , x3 ≥ 0

Exercice 6 - Le plus beau métier du monde

Un enseignant a donné k notes de contrôle continu à ses n élèves, et une note de partiel pour chaque élève. On
note cji la note obtenue par le i-ème élève au j-ème contrôle continu, et pi la note de partiel du i-ème élève. Il souhaite
déterminer le jeu de coefficients qui maximise la moyenne générale de la classe.
66
1. Comment résoudre ce problème ? Utilisez GLPK pour résoudre l’instance
double n o t e s P a r t i e l [N] = { 1 0 , 1 3 , 2 , 4 . 5 , 9 , 1 2 , 1 6 , 8 , 5 , 1 2 } ;
double notesCC1 [N] = {11 , 16 , 11 , 8 , 10 , 11 , 11 , 6 , 4 , 13};
double notesCC2 [N] = { 9 , 18 , 7 , 8 , 11 , 3 , 13 , 10 , 7 , 19};
2. Que remarquez-vous ?
3. Le responsable pédagogique est en total désaccord, il considère que la note de partiel doit avoir un coefficient
au moins égal à 0.5 et que deux notes de contrôle continu doivent avoir des coefficients au moins égaux à 0.1.
Comment tenir compte de ces contraintes ?
4. En raison d’un petit nombre de notes très élevées à certains examens, la moyenne générale de la classe est bonne
malgré le fait que beaucoup d’élèves ont une moyenne très basse. L’enseignant décide donc de changer de critère
et de maximiser la moyenne la plus basse. Comment procéder ?
5. Vérifiez la solution de la question précédente en calculant les moyennes de tous les élèves avec les coefficients
donnés par GLPK (ne le calculez pas à la main, programmez-le...).
67
Chapitre 10
Théorie de la complexité
Certains problèmes combinatoires sont dits NP-Complets, cela signifie qu’il n’est possible de les résoudre qu’en
passant par une recherche exhaustive dans l’ensemble des solutions, ce qui est concrètement irréalisable. Le but de ce
cours est de vous montrer comment reconnaı̂tre qu’un problème est NP-Complets, et comment le prouver.
Le chapitre de [2] sur la NP-Complétude fournit un exposé clair de la théorie de la complexité, mais utilisant des
concepts de calculabilité que je n’utilise pas dans ce cours. La lecture de ce chapitre ne pourra cependant que vous
être bénéfique. L’ouvrage [8] est la bible de la théorie de la complexité. Bien qu’il ne soit disponible qu’en anglais et
relativement difficile à se procurer, la théorie y est expliquée de façon claire, détaillée, et sans excès de formalisme.
10.1 Terminologie et rappels

10.1.1 Problèmes de décision
Nous nous restreindrons aux problèmes de décision dans le reste du cours. Un problème de décision est spécifié
par
– Des données
– Une question
Par exemple,
– Données : un graphe G, une constante k strictement positive
– Question : G est-il k-colorable ?
10.1.2 Instances
Une instance d’un problème s’obtient en précisant les valeurs des données. Par exemple,
– Données : un graphe G complet d’ordre 10, k = 9
– Question : G est-il k-colorable ?
On résout un problème de décision et décidant, pour toute instance I, si cette instance est à réponse oui ou à
réponse non. On dit plus généralement qu’un algorithme qui résout un problème de décision décide ce problème, et
toutes les instances de ce problème.
10.1.3 Algorithme polynomial

Un algorithme est polynomial si sa complexité est de l’ordre de O(nk ) où n est la taille du problème, et k une
constante indépendante de l’instance considérée.
10.2 Les classes P et NP

La théorie de la complexité est basée sur une classification des différents problèmes. Deux classes sont importantes
à connaı̂tre : P et N P .
68
10.2.1 La classe P
Un problème appartient à la classe de problèmes P s’il existe un algorithme polynomial permettant de le résoudre.
Par exemple, le plus court chemin, l’arbre couvrant dans un graphe, etc.
10.2.2 La classe NP
Etant donné un problème de décision, ce problème est dans NP s’il est possible de vérifier une solution en temps
polynomial. Considérons par exemple le problème suivant :
– Données : un graphe G
– Question : existe-t-il un cycle hamiltonien dans G ?
Supposons que ce graphe contienne 100 sommets, et qu’un de vos camarade vous dise : ”cette instance est à réponse
oui”. Vous lui demanderez certainement : ”dans quel ordre parcourir les sommets pour former un cycle hamiltonien” ?
Notez bien que malgré le fait que résoudre le problème soit infaisable en pratique, vérifier qu’un chemin est effectivement
un chemin hamiltonien est très aisé. Un cycle permettant de vérifier en temps polynomial qu’une telle instance est une
instance à réponse oui s’appelle un certificat.
Plus généralement, étant donné une instance I d’un problème Π, un certificat c est une donnée permettant de
vérifier en temps polynomial que I est une instance de Π à réponse oui.
10.2.3 Relations d’inclusion

Tout problème de P est aussi un problème de N P . Ce qui s’écrit aussi
Théorème 10.2.1 P ⊂ N P
Soit I une instance d’un problème Π appartenant à P , alors il existe un algorithme polynomial permettant de
décider Π. De ce fait, si I est à réponse oui, même un certificat vide permet de le vérifier en temps polynomial.
La question suivante empêche la plupart des chercheurs en informatique de dormir : Est-ce que P = N P ? On sait
déjà que P ⊂ N P , pour répondre à la question, il faudrait montrer :
– N P ⊂ P , autrement dit, tout problème de N P peut être résolu en temps polynomial.
– N P \ P 6= ∅, autrement dit, il existe des problèmes de N P qui ne peuvent être résolus en temps polynomial.
Notez que le problème du cycle hamiltonien appartient à N P .
– Si P = N P , alors il existe un algorithme polynomial permettant de le décider.
– Si P 6= N P , alors il convient de se demander si ce problème n’est pas dans N P \ P , le cas échéant il n’existe
aucun algorithme polynomial permettant de le décider.
Etant donné le nombre de problèmes de N P pour lesquels on ne trouve aucun algorithme polynomial, il est fort
probable que P 6= N P . Notez bien que ceci n’est qu’une conjecture, elle n’est pas démontrée à ce jour.
10.3 Réductions polynomiales

Soit Π un problème de N P pour lequel vous ne parvenez pas à trouver d’algorithme polynomial, vous nous pouvez
pas dire que ce problème n’est pas dans P , car vous ne savez pas si N P \ P est vide ou non. Il va donc falloir procéder
autrement. Nous allons introduire la notion de difficulté d’un problème, ainsi qu’un moyen de comparer des problèmes.
10.3.1 Définition
Nous allons établir une relation d’ordre sur les problèmes, nous la noterons
Π ≤ Π′
ce qui signifie ”Π est moins difficile que Π′ ”. ≤ est définie comme suit
Définition 10.3.1 Π ≤ Π′ s’il existe une fonction f de complexité polynomiale qui à toute instance I de Π associe
une instance I ′ de Π′ telle que I est à réponse oui si et seulement si I ′ est à réponse oui.
69
10.3.2 Exemple
Montrons que le problème HC (cycle hamiltonien) est moins difficile que T SP (voyageur de commerce). Pour cela,
construisons une fonction f prenant en paramètre une instance du problème HC, et créant une instance I du problème
T SP . Il est très important de déterminer f de sorte que I soit à réponse oui si et seulement si f (I) est à réponse
oui. Rappelons la définition de HC dans un graphe non orienté :
– Données : un graphe G non orienté
– Question : existe-t-il un cycle hamiltonien dans G ?
Ainsi que la définition de T SP ,
– Données : un graphe G′ non orienté muni d’une valuation c, une constante K
– Question : existe-t-il dans un G un cycle hamiltonien de longueur inférieure ou égale à K ?
Nous définissons f de la sorte, f prend en paramètre les données de HC, à savoir le graphe G = (S, A), on définit
l’instance f (I) de la sorte
– G′ = (S, A′ ), A′ contient toutes les paires de sommets qu’il est possible de former avec les sommets de G.
Autrement dit, G′ est un graphe complet.
– c(e) = 1 si e ∈ A, c(e) = 2 si e 6∈ A. Autrement dit, les arêtes de A′ ont la valeur 1 si elle se trouvaient dans A,
et toutes les arêtes qui ont été ajoutées pour obtenir un graphe complet ont la valeur 2.
– K = |S|.
Il est maintenant nécessaire de montrer que I est une instance à réponse oui si et seulement si f (I) est une instance
à réponse oui.
– Soit I une instance de HC à réponse oui. Alors il existe un cycle hamiltonien dans G. La longueur de ce cycle
dans G est |S|, à savoir le nombre de sommets. La longueur de ce cycle est aussi |S| dans G′ , car les arêtes
empruntées dans G′ étaient toutes de valuation 1.
– Soit I une instance de HC telle que f (I) est à réponse oui. Comme f (I) est à réponse oui, alors il existe un
cycle hamiltonien de longueur K = |S|. Comme ce cycle passe par |S| arêtes, et que toutes les arêtes de G′ sont
de valuation 1 ou 2, alors ce cycle n’emprunte que des arêtes de valuation 1. Comme les arêtes de valuation 1 de
G′ sont aussi des arêtes de G, alors il existe un cycle hamiltonien dans G.
10.3.3 Application
Propriété 10.3.1 Si Π ≤ Π′ et Π′ ∈ P , alors Π ∈ P .
Soit I une instance de Π, comme Π ≤ Π′ , alors il existe f polynomiale telle que I est à réponse oui si et seulement si
f (I) est à réponse oui. Comme Π′ ∈ P , alors Π′ est décidé par un algorithme polynomial. En appliquant cet algorithme
à f (I), on décide I. L’algorithme qu’on obtient est donc
– Déterminer f (I) (polynomial)
– Décider f (I) (polynomial)
Comme les deux algorithmes considérés sont polynomiaux, alors I est décidé en temps polynomial. Donc Π ∈ P .
Il est important de retenir que Π ≤ Π′ implique que l’existence d’un algorithme polynomial décidant Π′ implique
l’existence d’un algorithme polynomial décidant Π.
10.4 Les problèmes NP-complets

10.4.1 Courte méditation
Si vous vous trouvez face à un problème Π que vous ne parvenez pas à décider à l’aide d’un algorithme polynomial,
il vous suffit de montrer, par exemple, que T SP ≤ Π pour ne pas vous faire mépriser par vos supérieurs. Supposons
qu’il existe un algorithme polynomial décidant Π, alors vous en déduiriez immédiatement un algorithme décidant le
problème T SP , qui tient tout le monde en échec... Vous montrerez de ce fait non pas que le problème Π n’a pas de
solution, mais que ni vous, ni personne d’autre (encore moins vos supérieurs...), n’est capable, pour le moment, de
trouver un algorithme polynomial pour le décider.
10.4.2 3-SAT
La question que nous sommes amenés à nous poser maintenant est : existe-t-il un problème de N P au moins aussi
difficile que tous les problèmes de N P ? La réponse est oui.
70
Théorème 10.4.1 (Cook) Pour tout Π ∈ N P , Π ≤ 3 − SAT
Le problème SAT est défini dans la problèmethèque. 3 − SAT correspond au cas particulier dans lequel toutes les
clauses contiennent 3 littéraux. 3 − SAT est plus difficile que tous les problèmes de N P , cela signifie que s’il était
possible de décider 3 − SAT en temps polynomial, il serait alors possible de décider n’importe quel problème de N P
en temps polynomial.
10.4.3 Conséquences déprimantes

Propriété 10.4.1 Si Π ≤ Π′ et Π′ ≤ Π′′ , alors Π ≤ Π′′ .
Soit I une instance de Π, comme Π ≤ Π′ , alors il existe f polynomiale telle que I est à réponse oui si et seulement
si f (I) est à réponse oui. Comme Π′ ≤ Π′′ , alors il existe g polynomiale telle que f (I) est à réponse oui si et seulement
si (g ◦ f )(I) est à réponse oui. Donc la réduction (g ◦ f ) est polynomiale et I est à réponse oui si et seulement si
(g ◦ f )(I) est à réponse oui.
Définition 10.4.1 Π est NP-Complet si pour tout problème Π′ ∈ N P , on a Π′ ≤ Π

Autrement dit, Π est NP-Complet s’il est plus difficile que n’importe quel problème de N P .
Propriété 10.4.2 Si 3 − SAT ≤ Π, alors Π est NP-Complet.

Pour tout Π′ ∈ N P , Π′ ≤ 3 − SAT et 3 − SAT ≤ Π, donc Π′ ≤ Π. Alors pour tout Π′ ∈ N P , Π′ ≤ Π, donc Π est
NP-Complet.
Propriété 10.4.3 Si Π est NP-Complet, et Π ≤ Π′ , alors Π′ est NP-Complet.

Si Π est NP-Complet, alors pour tout problème Π′′ ∈ N P , Π′′ ≤ Π. Comme de plus Π ≤ Π′ , alors pour tout
problème Π′′ ∈ N P , Π′′ ≤ Π′ . Donc Π′ est NP-Complet.
Si vous voulez montrer qu’un problème est NP-Complet, il suffit de montrer qu’il est plus difficile qu’un problème
déjà connu comme étant NP-Complet.
10.4.4 Un espoir vain

Propriété 10.4.4 Si Π et Π′ sont NP-Complets, et qu’il est possible de décider Π en temps polynomial, alors on peut
décider Π′ en temps polynomial.
Comme Π′ appartient à N P , alors Π′ ≤ 3 − SAT , et comme Π est NP-Complet, alors 3 − SAT ≤ Π. Donc Π′ ≤ Π.
Si Π ∈ P , alors Π′ ∈ P .
Cette propriété est très importante, elle signifie que si on parvenait à décider un seul problème NP-Complet en
temps polynomial, alors on pourrait tous les décider en temps polynomial et on aurait P = N P .
Exercice 1 - 3-SAT/CLIQUE
3-SAT est défini de la façon suivante :
– Données : Un ensemble {Cj |j = 1, . . . , p} de clauses, un ensemble {xi |i = 1, . . . , n} de variables. Chaque clause
Cj contient 3 littéraux {lj1 , lj2 , lj3 } pouvant être de la forme xi ou ¬xi , ce que l’on notera avec une égalité pour
simplifier les notations.
– Question : Existe-t-il une valuation des variables satisfaisant au moins un littéral de chaque clause ?
Une clique est un sous-graphe complet. La taille d’une clique est le nombre de sommets qu’elle contient. On définit
le problème CLIQUE de la façon suivante :
– Données : Une graphe G non orienté, une constante K > 0
– Question : Existe-t-il dans G une clique de taille K ?
Nous considérons la réduction suivante :
– K=p
– A chaque clause Ci , on associe trois sommets s1j , s2j et s3j .
′
– Il existe une arête entre deux sommets sij et sij ′ si
71
– j 6= j ′
– si lij = x, alors lji ′ =
′
6 ¬x
3-SAT est connu pour être NP-Complet, montrez que CLIQUE est NP-Complet.
Exercice 2 - K-COLORATION/ENSEMBLE STABLE

Soit G = (S, A) un graphe, k une constante strictement positive. On s’intéresse à la k-colorabilité du graphe G (i.e.
peut-on colorier le graphe G avec k couleurs ?). Nous allons créer un graphe G′ = (S ′ , A′ ) à partir de G en procédant
de la façon suivante :
– A chaque sommet s de G, on associe k sommets de G′ , notés {(s, 1), . . . , (s, k)}, tous reliés entre eux par des
arêtes.
– Pour chaque arête {e, e′ } de G, et chaque couleur j, on relie dans G′ les sommets (e, j) et (e′ , j). Notez bien que
comme les sommets sont des couples, les arêtes sont des paires de couples.
Plus formellement,
–
S ′ = {(s, j)|s ∈ S, j ∈ {1, . . . , k}}
est un ensemble de couples (sommet de G/couleur).
–
A′ = A1 ∪ A2
avec
A1 = {{(s, j), (s, j ′ )}|s ∈ S, 1 ≤ j < j ′ ≤ k}
un ensemble d’arêtes formant |S| sous-graphes complets de k sommets et
A2 = {{(e, j), (e′ , j)}|{e, e′ } ∈ A, j ∈ {1, . . . , k}}
un ensemble d’arêtes reliant ces sous-graphes.
Démontrez de façon formelle et avec le plus de rigueur possible que, étant donné un graphe G arbitraire, un nombre
k > 0, G est k-colorable si et seulement s’il existe un ensemble stable de |S| sommets dans G′ .
Exercice 3 - CLIQUE/ENSEMBLE STABLE

Montrez que ENSEMBLE STABLE est NP-Complet, vous tiendrez compte du fait que CLIQUE est NP-Complet.
Exercice 4 - ENSEMBLE STABLE/COUVERTURE

Montrez que COUVERTURE est NP-Complet, vous tiendrez compte du fait que ENSEMBLE STABLE est NP-
Complet.
Exercice 5 - 3-SAT/SUBSET SUM

Le problème SUBSET SUM, est défini comme suit :
– Données : un ensemble A = {pi |i ∈ {1, . . . , n}} de n valeurs, une constante K.
– Question : existe-t-il un sous-ensemble I de {1, . . . , n} tel que
Σi∈I pi = K?
On peut montrer par une réduction de 3 − SAT que SU BSET SU M est NP-Complet. Effectuons la transformation
suivante :
– A chaque variable xj , on associe deux valeurs vj et vj′ dont la représentation décimale comporte p + n chiffres.
– Les p premiers chiffres représentent les clauses. Le i-ème chiffre (∈ {1, . . . , p}) de vj prend la valeur 1 si xj
apparaı̂t dans Ci , 0 sinon. Le i-ème chiffre (∈ {1, . . . , p}) de vj′ prend la valeur 1 si ¬x apparaı̂t dans Ci , 0
sinon.
– Les n derniers chiffres représentent l’indice de la variable xi , le p + j-ème chiffre de vj et de vj′ prend la valeur
1, les n − 1 autres chiffres prennent la valeur 0.
– A chaque clause Ci , on associe 2 valeurs xi et x′i de n + p chiffres dont le i-ème chiffre vaut 1 et tous les autres 0.
– On prend comme nombre K la valeur dont les p premiers chiffres valent 3 et les n derniers 1.
Utilisez la réduction polynomiale ci-dessus pour montrer que SUBSET SUM est NP-Complet.
72
Exercice 6 - PARTITION/SUBSET SUM
Le problème PARTITION est défini comme suit :
– Données : un ensemble A = {pi |i ∈ {1, . . . , n}} de n valeurs, tel que
Σni=1 pi
est pair.
– Question : existe-t-il un sous-ensemble I de {1, . . . , n} tel que
Σi∈I pi = Σi6∈I pi
Montrez que SUBSET SUM est NP-Complet, utilisez le fait que PARTITION est NP-Complet.
Exercice 7 - PARTITION/SAC A DOS

Montrez, par réduction du problème PARTITION, que SAC A DOS est NP-Complet.
Exercice 8 - Ordonnancement
1. Montrez que SCHEDULING ∈ NP.
2. Etant donné le problème PARTITION :
– Données : Un ensemble de m valeurs {v1 , . . . , vm }. X X
– Question : Existe-t-il un sous-ensemble I de {1, . . . , m} tel que vi = vi
i∈I i6∈I
Autrement dit, est-il possible de partitionner l’ensemble {v1 , . . . , vm } en deux sous-ensembles dont la somme des
valeurs est égale ? L’instance de PARTITION suivante, m = 7, (v1 , . . . , v7 ) = (1, 2, 3, 4, 5, 6, 7) est-elle à réponse
”oui” ? Vous démontrerez la justesse de votre réponse.
3. Nous savons que PARTITION est NP-Complet. Nous allons montrer à l’aide d’une réduction polynomiale f , que
PARTITION ≤ SCHEDULING. Nous construisons une fonction f qui à toute instance de PARTITION associe
une instance de SCHEDULING définie comme suit :
– n=m+1 Pn
– pour tout i ∈ {1, . . . , m}, di = vi , ri = 1, fi = j=1 vj + 1
n n
– dn = 1, rn = 21 j=1 vj + 1, fn = 12 j=1 vj + 1
P P
– M =0
Déterminer l’image de l’instance (1, 2, 3, 4, 5, 6, 7) par la fonction f . Vous présenterez votre solution sous forme
d’un tableau, vous préciserez les valeurs de toutes les données du problème.
4. L’image de cette instance est-elle à réponse ”oui” ? Vous démontrerez la justesse de votre réponse en donnant
les valeurs de début d’exécution si c’est le cas, ou bien une preuve d’impossibilité dans le cas contraire.
5. Montrez, sans excès de formalisme, que f est polynomiale.
6. Montrer que toute instance de PARTITION à réponse oui a une image par f à réponse oui.
7. Montrer que toute instance de PARTITION dont l’image est à réponse oui est à réponse oui.
8. SCHEDULING est-il NP-Complet ? Justifiez votre réponse.
73
Chapitre 11
Introduction la cryptographie
11.1 Définitions
Chiffrer une information revient à la transformer de sorte qu’elle ne puisse être intelligible que par la personne à
qui elle est destinée. La cryptologie est un terme générique regroupant deux disciplines :
– La cryptographie, qui est l’étude des méthodes de chiffrement et de déchiffrement.
– La cryptanalyse, qui est l’art de casser des messages chiffrés. Autrement dit, la cryptanalyse est l’étude des
techniques qui permettent à une personne non autorisée de décrypter (ce mot s’emploie uniquement dans ce
contexte) des messages chiffrés.
La cryptographie permet aussi de signer et d’authentifier des documents. En signant un document, on permet au
destinaire de vérifier la provenance du document, et l’authentification permet de vérifier que ce document n’a pas été
altéré.
Vous prendrez garde à ne pas confondre chiffrement et codage. Coder revient à remplacer chaque symbole (ou
suite de symboles) par un(e) autre. Cela peut servir en cryptographie, mais la réciproque est fausse.
Un chiffre est la donnée d’un algorithme de chiffrement (et/ou de signature) et de l’algorithme de déchiffrement
(et/ou de vérification et d’authentification). On utilise aussi le mot protocole, ou encore algorithme.
Nous appellerons tiers non autorisé toute personne à qui le message chiffré n’est pas destiné et qui pourrait,
pour des raisons qui lui appartiennent, être tentée de le lire.
Un canal non sécurisé est un moyen de transmission de l’information dont la sûreté n’est pas garantie, c’est-à-dire
sur lequel il est aisé pour un tiers non autorisés d’intercepter les messages. Les protocole de chiffrement trouve tout
leur intérêt lorsque l’on doit faire transiter par un canal non sécurisé des informations confidentielles.
Un message, avant le chiffrement est appelé message clair ou encore message en clair. Une fois chiffré, on
l’appelle message chiffré. Lorsqu’il a été déchiffré (a priori par son destinataire), on l’appelle message déchiffré.
11.2 La stéganographie
La stéganographie est l’art de dissimuler des messages, par exemple en utilisant les bits de poids faible d’une
image au format bmp [9], ou encore en plaçant des informations dans le slack [10]. La stéganographie n’est pas considéré
comme de la cryptographie, car le message doit pouvoir tomber entre les mains d’un tiers non autorisée
sans que celui-ci puisse le lire. Ce critère n’est évidemment pas satisfait par la stéganographie, bien que celle-ci
ait eu son heure de gloire pendant l’antiquité.
11.3 Les chiffres symétriques sans clé

Un chiffre symétrique sans clé se compose d’une fonction f qui a tout message clair M associe un message f (M ).
Le message se déchiffre avec une fonction f −1 . Par exemple, le chiffre de César,qui consiste à remplacer toute lettre
par celle qui se trouve trois positions plus loin dans l’alphabet. Cette méthode résistera aux attaques un certain temps,
mais une fois la fonction f découverte, il est trivial de déterminer f −1 , et toute la méthode est à jeter à la poubelle. Un
74
deuxième critère devant être satisfait est que même si des personnes non autorisées connaissent l’algorithme
chiffrement, elle ne doivent pas être capable de déchiffrer un message chiffré.
Exercice 1 - Chiffrement par transposition

Chiffrer un message par transposition revient appliquer un algorithme de permutation des lettres.
1. Est-il aisé de cryptanalyser un message chiffré de la sorte ?
2. Considérez-vous qu’il s’agit d’un moyen de chiffrement sûr ?
Exercice 2 - La barrière de la langue

Pendant la deuxième guerre mondiale, les américains ont utilisé pour communiquer par radio la langue des indiens
Navajos, très complexe et ne ressemblant à aucune autre pour communiquer rapidement et sûrement sans que les
japonais ne puisse comprendre les conversations. Qu’en pensez-vous ?
11.4 Les chiffres symétriques à clé

On cherche une méthode de chiffrement telle que même si le secret de l’algorithme n’est pas suffisament bien tenu,
cela n’aura pas de conséquences sur sa fiabilité. Un algorithme symétrique à clé est une fonction f qui à tout message
clair M et à toute clé K associe un message chiffré C = f (M, K). On déchiffre le message en utilisant la même clé (ou
une clé facile à trouver à partir de la première), f −1 (C, K) nous donne le message déchiffré. Cela signifie que même
en connaissant f , un tiers non autorisé ne pourra pas déchiffrer C sans K. Si K est découverte, il suffit de changer de
clé, et il sera alors possible d’utiliser le même algorithme.
11.4.1 Le chiffre de Vigenère

La méthode de Vigenère est la plus connue.
– Un message M est composé de nombres représentant des rangs de lettres dans l’alphabet
– Une clé K est composée de n nombres k1 k2 . . . kn .
– On découpe M en blocs de n nombres m1 m2 . . . mn
– A chaque bloc, on associe un bloc chiffré c1 c2 . . . cn avec ci = (mi + ki )mod26
Si n = 10, alors il existe 2610 possibilités, ce qui permet de bannir d’entré de jeu toutes les méthodes basées
sur une énumération de toutes les clés. Soit p le nombre de lettres chiffrées avec la clé K que vous avez à votre
disposition, mêmes si ces lettres proviennent de messages différents. Si le ratio np , est élevé, alors vous pouvez tenter
de cryptanalyser les messages avec des méthodes statistiques [11].
11.4.2 Enigma
Enigma est une machine à chiffrer utilisée par l’armée allemande pendant la deuxième guerre mondiale. Elle se
présentait comme une machine à écrire, mais écrivait d’autres lettres que celles qui étaient saisies. Un système de rotors
qui pivotaient à chaque pression de touche changeait la clé au fur et à mesure que l’on avançait dans l’écriture du
message. Cela ressemblait à un code de Vigenère dont la clé est aussi longue que le message, et comme les allemands
changeaient de clé chaque semaine, cela rendait irréaliste toute cryptanalyse basée sur une analyse des fréquences. La
clé utilisée était une disposition des rotors et une position initiale, ce qui faisait que même si une machine enigma
(l’algorithme) tombait entre les mains d’un ennemi de l’armée allemande, celui-ci ne pouvait déchiffrer les messages
sans connaı̂tre la disposition des rotors (la clé). Enigma a donné beaucoup de fil à retordre aux alliés, et était considéré
comme un moyen de chiffrement très efficace.
11.5 Les algorithmes asymétriques

Mais quelque soit la fiabilité théorique d’algorithme symétrique à clé, un gros problème pratique se pose : que faire
si les clés tombent entre les mains d’un tiers non autorisé ?
75
11.5.1 Un peu d’histoire[1]
Les allemands étaient obligés de faire circuler les clés en centaines d’exemplaires dans toute l’europe, en garantir
la sécurité était une tâche très difficile. Et ce qui devait arriver arriva : des anglais s’emparèrent de clés d’enigma sans
que les allemands le sachent. Comme ils disposaient de copies d’enigma depuis longtemps déjà et que les allemands
ne se savaient pas écoutés, ils purent tranquillement déchiffrer tous les messages allemands. Nombreux sont ceux qui
considèrent que cela a été décisif pour la victoire des alliés.
11.5.2 Le principe
Mettre des clés en circulation et garantir leur sécurité est considéré aujourd’hui comme un tâche impossible.
Comment échanger des clés sans prendre le risque qu’un message soit décrypé par un tiers non autorisé ? L’idée de la
réponse est d’utiliser deux clés : Ke pour chiffrer et Kd pour déchiffrer. Le destinataire du message est la seule personne
à détenir Kd , elle diffuse Ke librement. Un message M est chiffré avec une fonction f en un message C = f (M, Ke ).
Son destinataire déchiffre le message avec une fonction g telle que M = g(C, Kd ). Les deux fonctions f , g, et la clé
Ke doivent pouvoir être publiées et tomber entre les mains d’un tiers non autorisé sans qu’il puisse déchiffrer M .
Autrement dit, il doit être difficile de trouver Kd à partir de f , g, Ke et M .
On peut se représenter ce type de protocole de la façon suivante. Alice veut envoyer un message à Bob. Bob lui
envoie une boı̂te et un cadenas ouvert. Alice place le message dans la boı̂te et verrouille le cadenas. Maintenant, seul
le détenteur de la clé du cadenas peut ouvrir la boı̂te. S’il s’agit de Bob, lui seul pourra récupérer le message, même
Alice ne pourra pas le faire. Le principe le la cryptographie asymétrique est le même :
– Ke est la clé publique et permet à toute personne de chiffrer un message.
– Seule la clé privée Kd permet le déchiffrement du message.
Exercice 3 - SSH
Les chiffres à clé publique sont très gourmands en calculs, ils rendent inenvisageable le transfert de volumes importants
de données. Par contre les protocoles symétriques sont très rapides en pratique. Comment conjuguer les deux pour
communiquer de façon rapide et sécurisée à travers un canal non sécurisé.
76
Chapitre 12
GnuPG
12.1 Présentation
Gnu Privacy Guard[12] est un logiciel de chiffrement asymétrique et de gestion de clés. L’algorithme utilisé pour
signer et chiffrer est El Gamal, qui est d’une fiabilité comparable à celle d’RSA.
Il s’installe très simplement avec urpmi. Il existe sous forme de plugin pour Thunderbird, et est donc muni d’une
interface graphique. Nous l’utiliserons dans ce cours en ligne de commande, rassurez-vous il y en a très peu à apprendre.
GNU Privacy Guard est, comme son nom l’indique, sous licence GNU, vous pouvez donc en faire l’usage que vous
voulez - y compris commercial - sans risquer de vous retrouver un jour au tribunal.
12.2 Utilisation
12.2.1 Génération d’une clé privée
Avant toute utilisation du GPG, vous devez créer une clé privée. GPG vous la générera et la conservera en lieu
sûr... Pour générer votre clé privée, saisissez la commande :
gpg --gen-key
Plusieurs informations vous seront demandées, y compris un mot de passe pour déverouiller la clé privée, il est
impératif que ce mot de passe soit robuste, sinon un tiers non autorisé ayant un accès physique à votre machine aurait
accès à votre clé privée. Cette clé est stockée dans un répertoire de votre home, elle sera utilisé à chaque déchiffrement
et à chaque signature.
12.2.2 Exportation de la clé publique

Si vous souhaitez recevoir des messages chiffrés,vous devez donner votre clé publique à vos correspondants. Pour
exporter votre clé publique dans un fichier, saisissez la commande
gpg --export --armor --output nomdufichier
L’option --armor encode la clé dans un format affichable et pouvant être envoyé par mail. Vous pouvez donner ce
ficher à qui vous voulez et même le mettre sur votre page web, cette clé permet seulement de chiffrer des fichiers, seule
votre clé privée permettra leur déchiffrement.
12.2.3 Importation
Si vous souhaitez envoyer des fichiers chiffrée à un correspondant, vous aurez besoin de sa clé publique. Il lui suffit
de vous l’envoyer d’une façon similaire à celle dont vous lui aurez fourni votre clé publique. Une fois sa clé publique
entre vos mains, il ne vous reste plus qu’à saisir
77
gpg --import --armor nomdufichier
12.2.4 Liste des clés

La liste des clés publiques en votre possession s’obtient en saisissant
gpg --list-keys
12.2.5 Chiffrement
Une fois que vous detenez la clé publique d’un de vos correspondants, vous avez la possibilité de chiffrer des fichiers
que lui seul pourra déchiffrer.
gpg --encrypt --recipient destinataire --output fichierChiffré fichieràChiffrer
destinataire est une sous-chaine permettant d’identifier la clé publique du destinataire du message chiffré,
fichierChiffré est le nom du fichier généré par cette commande, fichieràChiffrer est, comme son nom l’indique,
le nom du fichier à chiffrer.
12.2.6 Déchiffrement
Vous pouvez déchiffrer un fichier chiffré avec votre clé publique en utilisant la commande
gpg --decrypt --output fichierDéchiffré fichierChiffré
12.2.7 Signature
Les messages sont automatiquement signés avec votre clé privée lors du chiffrement. La signature est vérifiée lors
du déchiffrement, à condition bien sûr, que le destinataire ait en sa possession la clé publique de l’émetteur.
12.2.8 Bref
Ces notes n’étaient qu’un survol de GnuPG, pour plus d’informations, ou en vue d’une utilisation professionnelle,
se référer à [13].
Exercice 1 - Création des clés

1. Installez GPG avec urpmi si vous êtes sous linux, et débrouillez-vous si vous êtes sous windaube.
2. Créez un couple de clés.
Exercice 2 - Echange de clés

1. Trouvez un binôme
2. Exportez vos clés publiques et échangez-les par mail.
3. Documentez-vous sur l’option fingerprint, expliquez quelle utilisation vous pourriez bien en faire.
Exercice 3 - Echange de messages

1. Placez dans des fichiers texte des messages arbitraires
2. Chiffrez-les et échangez-les.
3. Déchiffrez les messages.
78
Exercice 4 - Elargissement de la toile de confiance
Je désignerai dorénavant votre binôme par la lettre B.
1. Trouvez un trinôme C (B devra aussi trouver un trinôme D).
2. Récupérez la clé publique PC de C, vous prendrez soin de vérifier son authenticité avec son fingerprint
3. Chiffrez la clé publique PB de B et envoyez-la à C.
4. C devra déchiffrer PB et envoyer sa clé publique chiffrée à B.
5. B devra déchiffrer la clé publique de C et envoyer un message chiffré de confirmation à vous et à C.
79
Chapitre 13
GMP
13.1 Présentation
GMP[14] est un package d’arithmétique multi-précision, c’est à dire permettant de représenter des entiers, des
rationnels et des flottants avec une précision arbitraire, et non pas celle préconisée par les normes de représentation
des entiers et des flottants. Les algorithmes de cryptographie manipulent des nombres de plusieurs dizaines, voire
centaines de chiffres, ce qui nécessite l’utilisation d’une telle bibliothèque.
Vous pouvez l’installer très simplement avec urpmi ou apt-get. Comme ce package est sous licence GNU, vous
pouvez en faire l’utilisation que vous voulez. La documentation est disponible en anglais et vous donne la liste détaillée
des fonctions. Le but de ce document est juste de vous faire comprendre le fonctionnement du package en quelques
minutes.
13.2 Quelques points délicats

Le point le plus complexe est la gestion de la mémoire, vous devez, en manipulant les fonctions de GMP.h, être
très attentifs aux valeurs que vous passez en paramètre.
13.2.1 Compilation
N’ouliez pas d’importer gmp.h et d’ajouter l’option de compilation -lgmp. Sinon ça marche pas.
13.2.2 Initialisation
Le type mpz t vous est fourni avec la librairie, méfiez-vous de l’absence d’étoile, il y a nécessairement des pointeurs
derrière ce type. Des fonctions préfixées par mpz init vous permettent d’initialiser ces variables. N’oubliez jamais
l’initialisation, elle correspond à l’allocation dynamique, elle n’oubliez jamais la destruction, qui elle correspond à la
libération de la mémoire.
mpz t i ; // d e c l a r a t i o n
m p z i n i t ( i ) ; // a l l o c a t i o n
Les instructions ci-dessus déclarent un entier multiprécision i et effectuent l’allocation dynamique. La fonction
mpz init initialise i à 0. Ne pas confondre initialisation et affectation. Un fois la variable initialisée, vous pouvez
lui affecter toutes les valeurs que vous voulez. Par contre n’initialisez pas une variable déjà initialisée, vous devez
préalablement la détruire. On détruit un entier multiprécision (bref, on libère la mémoire) avec la fonction mpz clear.
mpz t i ; // d e c l a r a t i o n
m p z i n i t ( i ) ; // a l l o c a t i o n
m p z s e t u i ( i , 5 0 0 0 ) ; // a f f e c t a t i o n
/∗
U t i l i s a t i o n de i
80
∗/
m p z c l e a r ( i ) ; // l i b e r a t i o n de l a memoire
13.2.3 Les fonctions

Vous remarquerez dans la documentation que presque toutes les fonctions de manipulation d’entiers multiprécision
retounent void. Il est conseillé avec ce type de variable de ne pas utiliser les valeurs de retour, mais d’ajouter un
paramètre pour y placer le résultat. Par exemple, pour multiplier un entier multiprécision par un long, on procède de
la sorte :
// d e c l a r a t i o n s
mpz t r e s u l t a t ;
mpz t operandeGauche ;
long o p e r a n d e D r o i t e ;
EMPTY
// a l l o c a t i o n s
mpz init ( r e s u l ta t ) ;
m p z i n i t ( operandeGauche ) ;
EMPTY
// a f f e c t a t i o n s
m p z s e t u i ( operandeGauche , 1 0 0 0 ) ;
operandeDroite = 100;
EMPTY
// c a l c u l
mpz mul si ( r e s u l t a t , operandeGauche , o p e r a n d e D r o i t e ) ;
Les instructions ci-dessus effectue le calcul resultat = operandeGauche × operandeDroite, soit resultat = 1000 ×
100. Vous remarquez le résultat de la multiplication est le premier paramètre, et non pas la valeur de retour.
13.2.4 Affichage
Pour afficher ou ecrire dans un fichier la valeur d’un entier multiprécision, on utilise la fonction mpz out str (FILE
*stream, int base, mpz t op ). Si stream est égal à NULL, la valeur est ecrite dans stdout.
mpz t valeur ;
mpz init ( valeur ) ;
mpz set ui ( valeur , 1 7 ) ;
mpz o u t s t r (NULL, 1 0 , v a l e u r ) ;
mpz clear ( valeur ) ;
Les instructions ci-dessus affichent 17.
13.2.5 Exemple
Voici un petit exemple avec quelques calculs sur des entiers multi-précision.
#include<gmp . h>
/∗
P l a c e l a f a c t o r i e l l e de n dans r e s . r e s d o i t e t r e i n i t i a l i s e
∗/
void f a c t o r i e l l e ( long n , mpz t r e s )

{
mpz t temp ;
i f ( n == 0 )
81
{
mpz set ui ( res , 1 ) ;
}
else
{
m p z i n i t ( temp ) ;
f a c t o r i e l l e ( n−1 , temp ) ;
mpz mul si ( r e s , temp , n ) ;
m p z c l e a r ( temp ) ;
}
}
/∗
P l a c e b ˆn dans r e s . r e s d o i t e t r e i n i t i a l i s e
∗/
void p u i s s a n c e ( long b , long n , mpz t r e s )

{
mpz t temp ;
i f ( n == 0 )
{
}
else
{
p u i s s a n c e ( b , n−1 , temp ) ;
mpz mul ui ( r e s , temp , b ) ;
}
}
/∗
A f f i c h e l e s 100 p r e m i e r e s p u i s s a n c e s de 1 0 .
∗/
i nt main ( )
{
mpz t i ;
long i n d ;
mpz init ( i ) ;
for ( i n d = 0 ; i n d <= 100 ; i n d++)
{
p u i s s a n c e ( 1 0 , ind , i ) ;
m p z o u t s t r (NULL, 1 0 , i ) ;
p r i n t f ( ”\n” ) ;
}
mpz clear ( i ) ;
return 0 ;
}
Et voici, pour vous éviter de vous prendre la tête, le makefile.
a l l : testGMP . c
g c c −g −lgmp testGMP . c
82
run : a l l
. / a . out
13.2.6 Pour terminer

Etant donné le nombre de sous-programmes disponibles dans GMP, il serait inutile de les copier/coller ici. Je vous
laisse consulter la documentation [15]. Bon courage.
Exercice 1 - Prise en main

Ecrivez un programme qui affiche la table de multiplication de 1020
Exercice 2 - Fonction puissance

Reprennez la fonction puissance dans l’annexe sur GMP et modifiez-là en utilisant le fait que si n est pair alors,
n
bn = (b2 ) 2
Modifiez la fonction puissance de sorte qu’elle prenne des entiers multiprécision en paramètre.
Exercice 3 - La fonction d’Ackermann

La fonction d’Ackermann φ, est définie comme suit :
– φ(0, n) = n + 1
– φ(m, 0) = φ(m − 1, 1)
– φ(m, n) = φ(m − 1, φ(m, n − 1))
Utilisez GMP pour calculer le plus de valeurs possibles de la suite d’Ackermann.
83
Chapitre 14
Arithmétique
Les bases mathématiques permettant la compréhension des algorithmes asymétriques sont exposées dans ce cours.
Vous trouverez un exposé plus détaillé dans [2]. Notez aussi que ce cours se recoupe avec le programme de spé maths
de terminale S.
Sauf mention explicité du contraire, tous les nombres considérés ici sont des entiers relatifs, c’est-à-dire des nombres
entiers pouvant être positifs, négatifs ou nuls.
14.1 Divisibilité
Définition 14.1.1 a divise b, s’il existe k tel que ak = b
a divise b se note a|b. On dit alors que a est un diviseur de b, et que b est un multiple de a.
Exercice 1
Prouvez, en utilisant la définition de la divisibilité, que
– 3|21
– (−3)|6
Exercice 2
Prouvez les propriétés suivantes :
1. Si a|b et b|a, alors |a| = |b|
2. Si a|b et b|c, alors a|c
3. Si a|b et a|c, alors a|(b + c)
4. Si a|b et a|c, alors a|bc
5. Si a|b, alors ak |bk pour tout entier naturel k.
14.2 Division euclidienne

Définition 14.2.1 Soient a un nombre relatif et b un entier strictement positif, on effectue la division a par b en
déterminant q et r tels que a = qb + r, avec 0 ≤ r < q. q est le quotient, r le reste.
Exercice 3
Effectuez les divisions suivantes :
– 12 par 5
– 11 par 2
– 13 par 13
– 2 par 4
84
– (−6) par 2
– 0 par 3
– (−5) par 2
14.3 PGCD
Définition 14.3.1 Le plus grand commun diviseur de a et b, noté pgcd(a, b) est le plus grand nombre qui divise à la
fois a et b.
Exercice 4
Complétez le tableau suivant :
a b pgcd(a, b)
6 3
3 6
17 13
29 26
0 4
7 7
14.4 Nombres premiers

Définition 14.4.1 Un nombre p ≥ 2 est premier s’il n’a que par 1 et p comme diviseurs positifs.
Par convention, 1 n’est pas premier.
Exercice 5
Les nombres suivants sont-ils premiers ?
– 4
– 7
– 23
– 1
Exercice 6
Prouvez qu’il existe une infinité de nombres premiers.
14.5 Nombres premiers entre eux

Définition 14.5.1 a et b sont premiers entre eux si pgcd(a, b) = 1
Autrement dit, a et b sont premiers entre eux s’ils n’ont aucun autre diviseur commun que 1.
Exercice 7
Les couples de nombres suivants sont-ils premiers entre eux ?
– 3 et 5
– 20 et 32
– 23 et 41
– 18 et 27
– 0 et 4
– 7 et 7
Existe-t-il des nombres premiers avec eux-mêmes ?
85
Exercice 8
Prouvez que deux nombres premiers distincts sont premiers entre eux.
Exercice 9
a b
Soient a et b deux entiers relatifs, p = pgcd(a, b), a′ = et b′ = . Prouvez que a′ et b′ sont premiers entre eux.
p p
14.6 Décomposition en produit de facteurs premiers

Propriété 14.6.1 Tout nombre entier positif x peut s’écrire comme un produit de nombres premiers. C’est-à-dire
sous la forme
x = pe11 pe22 . . . pei i . . . penn
où pour tout i ∈ {1, . . . , n}, pi est le i-ème nombre premier et ei un nombre positif ou nul.
Tout nombre est défini de façon unique par la suite (e1 , e2 , . . . , en , 0, 0, . . .). Par exemple, quel nombre est défini
par la suite (1, 3, 0, 1, 2, 0, 0, . . .) ?
Exercice 10
Décomposez chacun de ces nombres en produit de facteurs premiers.
– 21
– 286
– 51
– 1344
Exercice 11
Donnez les nombres correspondant aux décompositions en facteurs premiers suivantes.
– (0, 0, 1, 1, 0, . . . , 0, . . .)
– (1, 1, 2, 0, . . . , 0, . . .)
– (1, 0, 2, 0, 1, 0, . . . , 0, . . .)
– (0, 0, 1, 0, . . . , 0, . . .)
– (0, . . . , 0, . . .)
14.6.1 Application à la divisibilité

Propriété 14.6.2 Soient
x = pe11 pe22 . . . pei i . . . penn
et
y = pf11 pf22 . . . pfi i . . . pfnn
x|y si et seulement si pour tout i, ei ≤ fi
Exercice 12
Donnez la liste des diviseurs du nombre correspondant à la décomposition en facteurs premiers suivante :
(1, 0, 1, 0, 1, 0, . . . , 0, . . .)
Exercice 13
Soient x = pe11 pe22 . . . pei i . . . penn et y = pf11 pf22 . . . pfi i . . . pfnn . Donnez la décomposition en facteurs premiers de xy.
86
14.6.2 Application au calcul du PGCD
Propriété 14.6.3 Soient
a = pe11 pe22 . . . pei i . . . penn
et
b = pf11 pf22 . . . pfi i . . . pfnn
alors
min(e1 ,f1 ) min(e2 ,f2 ) min(ei ,fi )
pgcd(a, b) = p1 p2 . . . pi . . . pnmin(en ,fn )
Exercice 14
Calculez les PGCDs des couples de nombres dont les décompositions en facteurs premiers sont données :
– (0, 0, 2, 1, 0, . . . , 0, . . .) et (0, 0, 1, 2, 0, . . . , 0, . . .)
– (1, 1, 1, 0, . . . , 0, . . .) et (0, 2, 2, 2, 0, . . . , 0, . . .)
– (1, 0, 1, 0, . . . , 0, . . .) et (0, 1, 0, 1, 0, . . . , 0, . . .)
– (2, 2, 1, 1, 0, . . . , 0, . . .) et (0, 0, 1, 1, 0, . . . , 0, . . .)
Exercice 15
Soient x = pe11 p2e2 . . . pei i . . . penn et y = pf11 pf22 . . . pfi i . . . pfnn . Déterminer une condition nécessaire et suffisante sur les
suites e et f permettant de savoir si x et y sont premiers entre eux.
14.7 Théorème de Bezout

Théorème 14.7.1 Pour tous a, b relatifs, il existe u et v relatifs tels que
au + bv = pgcd(a, b)
Théorème 14.7.2 a et b sont premiers entre eux si et seulement s’il existe u et v relatifs tels que
au + bv = 1
14.7.1 Théorème de Gauss

Théorème 14.7.3 Si a et b sont premiers entre eux, et a|bc, alors a|c
14.8 Algorithme d’Euclide

14.8.1 Algorithme d’Euclide pour le PGCD
Propriété 14.8.1 Pour tous a et b relatifs,
– pgcd(a, 0) = a
– pgcd(a, b) = pgcd(b, a mod b)
Exercice 16
Appliquez l’algorithme d’Euclide aux couples de nombres suivants :
– 3 et 6
– 4 et 0
– 161 et 184
– 21 et 34
87
Exercice 17
On admet que le pgcd(a, b) est la plus petite combinaison linéaire strictement positive de a et b.
1. Montrer que pgcd(a, b)|pgcd(b, a mod b)
2. Montrer que pgcd(b, a mod b)|pgcd(a, b)
3. Montrer que l’algorithme d’Euclide se termine.
4. Soit Fn la suite définie par
– F0 = 0
– F1 = 1
– Fn = Fn−1 + Fn−2 , si n ≥ 2
On appelle Fn le n-ième nombre de Fibonacci. Montrez par récurrence que
1
Fn = √ (φn + ψ n )
5
avec √ √
1+ 5 1− 5
φ= ;ψ = ;
2 2
F est-elle croissante ?
5. Prouvez que pout tout n ≥ 2,
Fn mod Fn−1 = Fn−2
6. Prouvez par récurrence que
pgcd(Fn , Fn−1 ) = 1
7. Prouvez par récurrence que le calcul de
pgcd(Fn , Fn−1 )
nécessite n appels récursifs.
8. Prouvez par récurrence que si Fn ≥ k et Fn−1 ≥ k ′ , alors
pgcd(k, k ′ )
se calcule avec un nombre d’appels récursifs inférieur ou égal à n.

9. Prouvez que si k > k ′ , alors pgcd(k, k ′ ) s’exécute en O(logφ (k))
10. Montrez que l’hypothèse k > k ′ n’était pas restrictive.
14.8.2 Algorithme d’Euclide étendu

Il possible d’enrichir l’algorithme d’Euclide afin qu’il calcule les coefficients u et b de la relation de Bezout. Étant
donnés deux nombres a et b,
– Si b = 0, alors pgcd(a, b) = a, et on a 1.a + 0.b = pgcd(a, b)
– Par récurrence, appliquons la même méthode au couple (b, a mod b), alors on a u et v tels que
u.b + v.(a mod b) = pgcd(b, a mod b)
Soit ⌊ ab ⌋ le quotient de la division de a par b, alors

a
a mod b = a − ⌊ ⌋b
b
Donc
a
u.b + v.(a − ⌊ ⌋b) = pgcd(b, a mod b)
b
Ce qui se réécrit
a
v.a + (u − v⌊ ⌋)b = pgcd(b, a mod b)
b
88
Comme, de plus,
pgcd(a, b) = pgcd(b, a mod b)
alors
a
v.a + (u − v⌊ ⌋)b = pgcd(a, b)
b
Donc, en posant u′ = v et v ′ = u − v⌊ ab ⌋, on a bien
u′ .a + v ′ .b = pgcd(a, b)
Exercice 18
Appliquez l’algorithme d’Euclide étendu aux couples de nombres suivants. Lesquels sont premiers entre eux ?
– 3 et 6
– 4 et 0
– 161 et 184
– 21 et 34
Exercice 19
Ecrivez en C l’algorithme d’Euclide étendu (passez u et v en paramètre par référence) sans GMP.
Exercice 20
Prouvez le théorème de Gauss
14.8.3 Morceaux choisis

Exercice 21 - Divisbilité
Prouvez que si a|b alors soit |a| ≤ |b|, soit b = 0.
Exercice 22 - Unicité de la division

Démontrer que le couple (q, r) résultant de la division de a et b est unique.
Exercice 23 - Divisibilité par 10

Combien y a-t-il de 0 à la fin de (1000!) ?
Exercice 24 - Combien y a-t-il de nombres premiers ?

1. Soit un = p1 p2 . . . pn − 1 le produit des n > 1 plus petits nombres premiers auquel on a retranché 1, pi un des n
plus petits nombres premiers. Effectuez une division eulidienne de un par pi .
2. Prouvez que un n’est divisible par aucun des n plus petits nombres premiers.
3. En déduire qu’il existe une infinité de nombres premiers.
14.8.4 Applications avec GMP

Dans tous les exercices qui suivent, vous n’aurez droit qu’au type mpz t.
Exercice 25 - Algorithme d’Euclide étendu

Programmez l’algorithme d’Euclide étendu en affichant une trace d’exécution montrant les étapes du calcul de u
et v.
89
Exercice 26 - Expérimentation avec la suite de Fibonacci
Ecrivez une fonction retournant le n-ème nombre de Fibonacci en utilisant la relation de récurrence donnée dans
la section “algorithme d’Euclide”. Que remarquez-vous lorsque l’on calcule des valeurs de la suite de Fibonacci avec
de grandes valeurs de n (control-C pour interrompre l’exécution d’un programme :-) ? On considère, pour remédier à
ce petit problème la fonction φ définie comme suit
– φ(a, b, 0) = b
– φ(a, b, n) = φ(a + b, a, n − 1)
Prouvez par récurrence sur n que Fn+k = φ(Fk+1 , Fk , n), puis que Fn = φ(1, 0, n). Utilisez cette relation pour modifier
la fonction calculant le n-ème nombre de Fibonacci. Tester l’algorithme d’Euclide étendu avec des couples (Fn , Fn−1 )
(prenez de grandes valeurs de n).
90
Chapitre 15
Arithmétique modulaire
Les protocoles de chiffrement sont basés sur des opérations dans des espaces quotient, détaillés dans la dernière
partie de ce cours. Les définitions sont simplifiées au minimum nécessaire pour comprendre ce cours, et donc moins
précises que ce que vous pourriez trouver dans des ouvrages spécialisés.
La première section, sur les congruences, expose des points du programme de spé maths de terminale S, rédigés
toutefois de façon plus technique. Les deux sections suivantes abordent des éléments du programme de première année
de fac, ou de maths sup, seuls les points essentiels à la compréhension de la dernière section du cours sont exposées,
j’ai pris la liberté de simplifier quelques définitions. La dernière section expose des méthodes utilisées directement en
cryptographie asymétrique, elles sont aussi enseignées en première année de fac.
15.1 Congruences
Définition 15.1.1
a≡b (mod n)
si
n|(a − b)
On dit alors que a est congru à b modulo n.
Autrement dit, a est b congru à b modulo n si et seulement si a et b ont le même reste de la division par n. Plus
formellement,
Propriété 15.1.1 a ≡ b (mod n) si et seulement si a mod n = b mod n.

En effet, si n|(a − b), alors il existe k tel que kn = a − b. Divisons a et b par n, il existe q, q ′ , r et r′ tels que
a = qn + r et b = q ′ n + r′ , avec 0 ≤ r < n et 0 ≤ r′ < n. Donc kn = a − b équivaut à
kn = qn + r − (q ′ n + r′ )
ssi
kn = (q − q ′ )n + (r − r′ )
ssi
n(k + q ′ − q) = (r − r′ )
Donc
n|(r − r′ )
Or, |r − r′ | < n, donc n ne peut diviser (r − r′ ) que si r − r′ = 0. On a donc r = r′ , comme r = a mod n et r′ = b mod n,
alors a mod n = b mod n.
Réciproquement, supposons a mod n = b mod n. Divisons a et b par n, il existe q, q ′ et r tels que a = qn + r

et b = q ′ n + r, avec 0 ≤ r < n. Donc
a − b = qn + r − (q ′ n + r)
91
ssi
a − b = qn − q ′ n
ssi
a − b = (q − q ′ )n
Donc, n|(a − b).
Propriété 15.1.2 Si a ≡ b (mod n) et a′ ≡ b′ (mod n), alors

1. a + a′ ≡ b + b′ (mod n)
2. aa′ ≡ bb′ (mod n)
3. ak ≡ bk (mod n)
Exercice 1
Pour chacune de ces propriétés,
– donnez un exemple numérique
– donnez une preuve
Exercice 2
Calculez les valeurs suivantes :
733 mod 10; 4.7 mod 9; 14 + 71 mod 83; 44 mod 12;
3.9 − 7.8 mod 11; 247349 mod 7; 21247 mod 17;
3457 − 1 mod 11; 951842 − 4 mod 5
32n+1 + 52n+1 mod 4; 6n + 13n+1 mod 7
15.2 Rappels d’algèbre

15.2.1 Monoı̈des
Définition 15.2.1 Un monoı̈de (E, +, 0) est un ensemble E muni d’une addition + et d’un élément neutre 0 pour
cette addition.
Un élément neutre 0 est tel que ∀e ∈ E, e + 0 = 0 + e = e.
Par exemple, l’ensemble des entiers naturels, noté N (ou (N, +, 0)), est un monoı̈de. En effet,
– il est toujours possible d’additionner deux entiers naturels
– et 0 est un élément neutre pour l’addition.
L’ensemble (B, ×, 1) des booléens, muni du produit est aussi un monoı̈de. Il est en effet toujours possible de multiplier
deux booléens, et on a 0.1 = 0, 1.1 = 1, donc 1 (vrai) est un élément neutre pour le produit booléen.
15.2.2 Groupes
Définition 15.2.2 (G, +, 0) est un groupe si
– (G, +, 0) est un monoı̈de
– pour tout élément x de G, il existe un élément −x appelé ”opposé de x”, tel que
x + (−x) = 0
Autrement dit, un groupe est un monoı̈de dans lequel il existe une soustraction. On remarque que N n’est pas un
groupe mais que l’ensemble des entiers relatifs Z (ou (Z, +, 0)) est bien un groupe. En effet,
– il est toujours possible d’additionner deux entiers relatifs
– 0 est bien un élément neutre pour l’addition.
– pour tout x ∈ Z, −x existe, ce qui n’est pas le cas dans N .
92
15.2.3 Anneaux
Définition 15.2.3 (A, +, ×, 0, 1) est un anneau si
– (A, +, 0) est un groupe
– on peut toujours multiplier deux éléments de A
– il existe un élément neutre 1 pour la multiplication
Par exemple, l’ensemble des entiers relatifs est un anneau, il suffit de prendre 1 comme élément neutre pour la
multiplication. L’ensemble des matrices carrées est un anneau.
15.2.4 Corps
Définition 15.2.4 (C, +, ×, 0, 1) est un corps si
– (G, +, ×, 0, 1) est un anneau
– pour tout élément x de C, sauf 0, il existe un élément x−1 appelé ”inverse de x”, tel que
x × (x−1 ) = 1
Autrement dit, C est un corps s’il est muni d’une division. Par exemple, l’ensemble des entiers relatifs n’est pas un
corps, mais l’ensemble des rationnels en est un. L’ensemble des matrices inversibles est un corps.
Exercice 3
On considère l’ensemble (F , +, ◦, f0 , f1 ) des fonctions linéaires (f (x) = ax + b) muni de l’addition ((f + g)(x) =
f (x) + g(x)) et de la composition ◦ ((f ◦ g)(x) = f (g(x))).
– Est-ce que (F , +, ◦, f0 , f1 ) est un monoı̈de ?
– un groupe ?
– un anneau ?
– un corps ?
– existe-t-il un sous-ensemble de F formant un corps ?
Exercice 4
On considère l’ensemble (P, +, ◦, f0 , f1 ) des polynômes à coefficients réels
n
X
P (x) = ai xi + a0
i=1
muni de l’addition et de la composition

– Est-ce que (P, +, ◦, f0 , f1 ) est un monoı̈de ?
– un groupe ?
– un anneau ?
– un corps ?
– existe-t-il un sous-ensemble de P formant un corps ?
15.2.5 Relations d’équivalence

Définition 15.2.5 Une relation ∼ sur E est une relation d’équivalence si ∼
1. ∼ est réflexive, c’est à dire ∀e ∈ E, e ∼ e
2. ∼ est symétrique, c’est à dire ∀e, e′ ∈ E, e ∼ e′ ⇒ e′ ∼ e
′
3. ∼ est transitive, c’est à dire ∀e, e′ , e′′ , e ∼ e′ et e′ ∼ e′ ⇒ e ∼ e′′
Par exemple, la relation = sur les réels est une relation d’équivalence. Il se trouve que la relation ≡ sur les entiers
relatifs est une relation d’équivalence, preuve en exercice.
93
Exercice 5
Etant donné un entier relatif non nul n. Pour tous a, b entiers relatifs, on pose a ∼ b si a ≡ b (mod n). Prouver
que ∼ est une relation d’équivalence.
15.3 Espaces quotients

15.3.1 Classes d’équivalence
Une relation d’équivalence permet de répartir tous les éléments d’un ensemble dans des ensembles appelés classes
d’équivalence. Deux éléments a et b sont dans la même classe si a ∼ b. Par exemple, si n = 5, on peut répartir tous
les relatifs dans 5 classes d’équivalence selon le reste de leur division par 5. Par exemple,
c = {. . . , −13, −8, −3, 2, 7, 12, 17, . . .}
est une classe d’équivalence, tous ses éléments sont, deux à deux, distants d’un multiple de 5. Pour désigner une classe
d’équivalence, on utilise un élément de cette classe, appelé représentant. En prenant 2 comme représentant, on note
alors [2]5 la classe des équivalents à 2 modulo 5. On aurait pu aussi utiliser un autre élément de c comme représentant,
mais ce n’est pas usuel, on prend en général un représentant compris entre 0 et n − 1.
Définition 15.3.1 Soit n > 0, et k ∈ {0, . . . , n − 1}, alors on note [k]n = {e|e ∼ k}.
15.3.2 Z/nZ
Supposons qu’en calculant c = a + b mod n, on substitue à a et à b des éléments de même classe d’équivalence,
alors le résultat est-il de la même classe que c ? Vérifions : remplaçons a par a′ ∈ [a]n et b par b′ ∈ [b]n . Comme a ∼ a′
et b ∼ b′ , alors il existe k et k ′ tels que a′ = a + kn et b′ = b + k ′ n. Calculons
c′ = a′ + b ′
= a + kn + b + k ′ n
= a + b + (k + k ′ )n
= c + (k + k ′ )n
Donc c ∼ c′ et c′ ∈ [c]n . On déduit qu’il est possible d’étendre l’addition modulaire aux classes d’équivalences. Au lieu
d’additionner un élément de [a]n à un élément de [b]n , nous additionnerons directement ces deux classes d’équivalence.
Comme on remarque la même chose en calculant c = ab mod n (en exercice), nous pouvons définir les calculs modulo
n sur l’ensemble d’ensembles
{[0]n , . . . , [n − 1]n }
Définition 15.3.2 Soit n > 0, alors on note Z/nZ l’espace quotient {[k]n |0 ≤ k ≤ n − 1}
Lorsqu’il n’y a pas d’ambiguı̈té, on se permet d’enlever les crochets et de noter k au lieu de [k]n .
Exercice 6
Montrez qu’en substituant à a et à b des éléments de même classe d’équivalence dans c = ab mod n, on obtient un
élément de même classe d’équivalence que c.
Structure d’anneau
Propriété 15.3.1 Pour tout n > 0, Z/nZ est un monoı̈de.
Preuve en exercice.
Propriété 15.3.2 Pour tout n > 0, Z/nZ est un groupe.

Preuve en exercice.
Propriété 15.3.3 Pour tout n > 0, Z/nZ est un anneau.

Preuve en exercice.
94
15.4 Inverses modulaires
Supposons qu’il existe une fonction de chiffrement f définie comme suit, f (k) = k ∗ 7 mod 9. Calculons f (3) ≡
3 ∗ 7 ≡ 29 ≡ 0 (mod 9). Existe-t-il une fonction f ′ (k) = k ∗ p mod 9, inverse de f , telle que (f ◦ f ′ )(k) = k, en
particulier, existe-t-il p tel que 0 ∗ p mod 9 = 3 ?
On a multiplié [3]9 par [7]9 pour obtenir [0]9 , peut-on “revenir” à [3]9 , c’est-à-dire multiplier [0]9 par l’inverse, noté
[7]−1
9 de [7]9 ? Plus généralement, cela revient à se demander si Z/nZ est un corps. C’est-à-dire, est-ce que la “division”
existe dans Z/nZ. Voici la réponse :
Théorème 15.4.1 Z/nZ est corps si et seulement si n est premier.

Supposons que Z/nZ est un corps, étant donné [k]n (k 6= 0), [k]n admet un inverse. Il existe donc une classe [k ′ ]n
telle que k.k ′ ≡ 1 (mod n). Par définition, n|(k.k ′ − 1), et il existe µ tel que
µn = k.k ′ − 1
ce qui s’ecrit aussi comme une relation de Bezout,
k.k ′ − µn = 1
Or, k ′ et µ n’existent que si k et n sont premiers entre eux. Comme Z/nZ est un corps, alors pour tout k ∈ {1, . . . , n−1},
k est premier avec n, donc aucun d’eux (sauf 1) ne peut diviser n, donc n est premier. La réciproque est basée sur le
même principe.
15.4.1 Eléments inversibles et fonction φ d’Euler

On déduit de la preuve précédente que k est inversible dans Z/nZ si et seulement si k est premier avec n. Donc si
n n’est pas premier, tous ses éléments ne sont pas inversibles.
Définition 15.4.1 Pour tout n > 0, φ(n) est le nombre d’éléments inversibles de Z/nZ.
Prenons par exemple Z/10Z, les éléments inversibles de Z/10Z sont
{1, 3, 7, 9}
Notons qu’il s’agit des éléments premiers avec 10. Donc φ(10) = 4.
Exercice 7
– Z/11Z est-il un corps ?
– Quels sont les éléments inversibles de Z/11Z et leurs inverses ?
– Quelle est la valeur de φ(11) ?
Exercice 8
– Z/14Z est-il un corps ?
– Quels sont les éléments inversibles de Z/14Z et leurs inverses ?
– Quelle est la valeur de φ(14) ?
Notons que si n est premier, tous ses éléments, sauf 0 sont inversibles, nous admettrons donc que
Propriété 15.4.1 Si n est premier, alors φ(n) = n − 1.

Nous aurons besoin du résultat suivant pour RSA, admis sans preuve,
Propriété 15.4.2 Si p et q sont premiers, alors φ(pq) = (p − 1)(q − 1).

Par exemple, dans Z/35Z, il y a (5 − 1)(7 − 1) éléments inversibles, donc φ(35) = 24.
95
15.4.2 Pratique de l’inversion
Comment, étant donné n > 0, et k ∈ Z/nZ, trouver l’inverse de k ? Si n est premier, le petit théorème de fermat
nous le donne :
Théorème 15.4.2 Si n est premier, alors pout tout k non congru à 0 modulo n,
k n−1 ≡ 1 (mod n)
.
Par exemple, si n = 5 et k = 3, alors 34 ≡ 81 ≡ 1 (mod 5), donc 3n−2 ≡ 33 ≡ 27 ≡ 2 (mod 5) est l’inverse
modulo 5 de 3. En effet, 3.2 ≡ 1 (mod 5).
Si on connait φ(n) alors le théorème d’Alembert-Gauss nous permet de trouver l’inverse de k,
Théorème 15.4.3 Pour tous n ≥ 2, k inversible dans Z/nZ,
k φ(n) ≡ 1 (mod n)
.
Par exemple, si n = 10, et k = 3, alors φ(10) = φ(2.5) = 1.4 = 4, on a bien
34 ≡ 92
≡ 81
≡ 1 (mod 10)
Si n = 21 et k = 4, alors φ(21) = φ(3.7) = 2.6 = 12, et on a bien
412 ≡ 166
≡ 2563
≡ 43
≡ 64
≡ 1 (mod 10)
L’inverse modulo pq (p et q premiers) de k (inversible dans Z/pqZ) est donc k φ(n)−1 .
Exercice 9 - Espaces quotient et GMP

Ecrire avec GMP un sous-programme faisant le rapport complet d’un espace quotient de la forme Z/nZ :
– Z/nZ est-il un corps ?
– Quels sont les éléments inversibles de Z/nZ et leurs inverses ?
– Quelle est la valeur de φ(n) ?
96
Chapitre 16
RSA
16.0.3 Principe
Le chiffrement se fait à l’aide de la clé publique, le déchiffrement à l’aide de la clé privée. [2]
Chiffrement
La clé publique est un couple (C, N ) où
– N = P Q est le produit de deux nombres premiers P et Q
– C est un nombre premier avec (P − 1)(Q − 1).
On chiffre un message M en calculant
M′ ≡ MC (mod N )
Si par exemple on a P = 3, Q = 11, alors N = P Q = 33 et (P − 1)(Q − 1) = 2 × 10 = 20. Si par exemple on prend
C = 7, on remarque que 7 est bien premier avec 20, la clé publique est (7, 33). On chiffre le message M = 13 en
calculant M ′ ≡ M C ≡ 137 ≡ 7 (mod 33).
Déchiffrement
Notez qu’il n’est pas trivial de retrouver M à partir de M ′ et de (C, P Q). La clé privée est un couple (C ′ , N ) tel que
pour tout message M ,
′
(M C )C ≡ M (mod N )
Alors on déchiffre M ′ en calculant
′
M ≡ (M ′ )C (mod N )
′ 3
Ici on a C = 3. On constate que M ≡ 7 ≡ 13 (mod 33). La question que l’on est invité à se poser est : comment on
trouve C ′ ?
16.0.4 Résistance aux attaques

D’après le théorème d’Euler, pour tout M premier avec N ,
M φ(N ) ≡ 1 (mod N )
Plus généralement, pour tout k entier relatif,
M kφ(N ) ≡ 1 (mod N )
Ce qui s’écrit aussi

M kφ(N ) M ≡ M (mod N )
97
et de ce fait
M kφ(N )+1 ≡ M (mod N )
Comme ′
M CC ≡ M (mod N )
′
il convient de déterminer C tel que
CC ′ = kφ(N ) + 1
ce qui s’écrit plus simplement comme une relation de Bezout
CC ′ − kφ(N ) = 1
Notez que la connaissance de φ(N ) est indispensable si on souhaite trouver C ′ . Etant donné N = P Q le produit de
nombres premiers P et Q, on a φ(N ) = (P − 1)(Q − 1). Donc pour connaı̂tre φ(N ), il est nécessaire de connaı̂tre la
décomposition de N en produit de facteurs premiers. Donc, retrouver C ′ à partir de C oblige le cryptanalyste à passer
par une factorisation de N , problème connu pour être difficile.
98
Annexe A
Corrigés des programmes
A.1 Fonctions récursives

#include<s t d l i b . h>
int ad d i t i on ( int a , int b)

{
p r i n t f ( ”(%d , %d ) \ n” , a , b ) ;
i f ( a == 0 )
return b ;
i f ( a > 0)
return 1 + a d d i t i o n ( a − 1 , b ) ;
return a d d i t i o n ( a + 1 , b ) − 1 ;
}
int s o u s t r a c t i o n ( int a , int b)

{
p r i n t f ( ”(%d , %d ) \ n” , a , b ) ;
i f ( b == 0 )
return a ;
i f ( b > 0)
return s o u s t r a c t i o n ( a , b − 1 ) − 1 ;
return s o u s t r a c t i o n ( a , b + 1 ) + 1 ;
}
int m u l t i p l i c a t i o n ( int a , int b)

{
p r i n t f ( ”(%d , %d ) \ n” , a , b ) ;
i f ( a == 0 )
return 0 ;
i f ( a > 0)
return b + m u l t i p l i c a t i o n ( a − 1 , b ) ;
return m u l t i p l i c a t i o n ( a + 1 , b ) − b ;
}
int d i v i s i o n ( int a , int b)

{
p r i n t f ( ”(%d , %d ) \ n” , a , b ) ;
i f ( a < 0)
return − d i v i s i o n (−a , b ) ;
i f ( b < 0)
return − d i v i s i o n ( a , −b ) ;
i f (a < b)
return 0 ;
return 1 + d i v i s i o n ( a − b , b ) ;
}
int puissance ( int a , int b)

{
p r i n t f ( ”(%d , %d ) \ n” , a , b ) ;
i f ( b == 0 )
return 1 ;
return a ∗ p u i s s a n c e ( a , b − 1 ) ;
}
99
A.2 Fonctions récursives terminales
long f a c t o r i e l l e R ( long n , long a c c )

{
p r i n t f ( ”(%l d , %l d ) \ n” , n , a c c ) ;
i f ( n == 0 )
return acc ;
return f a c t o r i e l l e R ( n−1 , a c c ∗ n ) ;
}
long f a c t o r i e l l e ( long n )
{
return f a c t o r i e l l e R ( n , 1);
}
i n t main ( )
{
long a = 4 ;
p r i n t f ( ”%l d ! = %l d \n” , a , f ac tori ell e (a ));
getch ( ) ;
return 0 ;
}
100
A.3 Itérateurs et applications
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
typedef s tr u ct
{
unsigned long f i r s t ;
unsigned long s e c o n d ;
} couple ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
typedef s tr u ct
{
unsigned long 11 , 12 , 21 , 22 ;
} quadruplet ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
c o u p l e applyF ( c o u p l e ( ∗ f ) ( c o u p l e ) , i n t n , couple x)
{
i f ( n == 0 )
return x ;
return f ( applyF ( f , n − 1 , x ) ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
c o u p l e applyFT ( c o u p l e ( ∗ f ) ( c o u p l e ) , i n t n , couple x)
{
i f ( n == 0 )
return x ;
return applyF ( f , n−1 , f ( x ) ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long m u l t i p l i e ( unsigned long a , unsigned long b )

{
couple x = {0 , a };
couple f ( couple x)
{
c o u p l e y = { x . f i r s t + x . se c o n d , x . s e c o n d } ;
return y ;
}
return applyFT ( f , b , x ) . f i r s t ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long f a c t o r i e l l e ( unsigned long n )

{
c o u p l e x = {n , 1 } ;
{
c o u p l e y = {x . f i r s t − 1 , x . f i r s t ∗x . second } ;
return y ;
}
return applyFT ( f , n , x ) . s e c o n d ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long p u i s s a n c e ( unsigned long b , unsigned long n )

{
couple x = {1 , b };
{
c o u p l e y = { x . f i r s t ∗ x . se c o n d , x . s e c o n d } ;
return y ;
}
return applyFT ( f , n , x ) . f i r s t ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long f a s t P u i s s a n c e ( unsigned long b , unsigned long n )

{
i f ( n == 0 )
101
return 1 ;
if (n % 2)
return b ∗ f a s t P u i s s a n c e ( b∗b , n / 2 ) ;
return f a s t P u i s s a n c e ( b∗b , n / 2 ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long applyFD ( i n t ( ∗ d e l t a ) ( i n t k ) ,

unsigned long ( ∗ f ) ( c o u p l e ) , i n t n , unsigned long x )
{
couple y ;
i f ( n == 0 )
return x ;
y. first = n;
y . s e c o n d = applyFD ( d e l t a , f , d e l t a ( n ) , x ) ;
return f ( y ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long s l o w P u i s s a n c e I T ( unsigned long b , unsigned long n )

{
unsigned long f ( c o u p l e x )
{
return x . s e c o n d ∗b ;
}
int d e l t a ( int x )
{
return x − 1 ;
}
return applyFD ( d e l t a , f , n , 1 ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long f a c t o r i e l l e I T ( unsigned long n )

{
{
return x . f i r s t ∗ x . second ;
}
{
return x − 1 ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long f a s t P u i s s a n c e I T ( unsigned long b , unsigned long n )

{
{
i f ( x . f i r s t % 2)
return b∗x . s e c o n d ∗x . s e c o n d ;
return x . s e c o n d ∗x . s e c o n d ;
}
{
return x / 2 ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
quadruplet fiboMat ( )
{
quadruplet q = {1 , 1 , 1 , 0};
return q ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
quadruplet i d e n t i t e ( )
{
quadruplet q = {1 , 0 , 0 , 1};
return q ;
}
102
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
q u a d r u p l e t multMat ( q u a d r u p l e t x , q u a d r u p l e t y )
{
q u a d r u p l e t xy ;
xy . 1 1 = x . 1 1 ∗y . 1 1 + x . 1 2 ∗y . 2 1 ;
xy . 2 1 = x . 2 1 ∗y . 1 1 + x . 2 2 ∗y . 2 1 ;
xy . 1 2 = x . 1 1 ∗y . 1 2 + x . 1 2 ∗y . 2 2 ;
xy . 2 2 = x . 2 1 ∗y . 1 2 + x . 2 2 ∗y . 2 2 ;
return xy ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
q u a d r u p l e t applyFDQ( unsigned long ( ∗ d e l t a ) ( unsigned long ) ,

q u a d r u p l e t ( ∗ f ) ( unsigned long , q u a d r u p l e t ) ,
unsigned long n , q u a d r u p l e t x )
{
i f ( n == 0 )
return x ;
return f ( n , applyFDQ( d e l t a , f , d e l t a ( n ) , x ) ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
q u a d r u p l e t matPow( q u a d r u p l e t x , unsigned long n )

{
q u a d r u p l e t f ( unsigned long m, q u a d r u p l e t q )
{
q u a d r u p l e t qPrime = multMat ( q , q ) ;
i f (m % 2 )
return multMat ( x , qPrime ) ;
return qPrime ;
}
unsigned long d e l t a ( unsigned long x )
{
return x / 2 ;
}
return applyFDQ( d e l t a , f , n , i d e n t i t e ( ) ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
c o u p l e multMatVec ( q u a d r u p l e t x , c o u p l e y )
{
c o u p l e xy ;
xy . f i r s t = x . 1 1 ∗y . f i r s t + x . 1 2 ∗ y . s e c o n d ;
xy . s e c o n d = x . 2 1 ∗y . f i r s t + x . 2 2 ∗y . s e c o n d ;
return xy ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
unsigned long f a s t F i b o n a c c i I T ( unsigned long l )

{
quadruplet q = fiboMat ( ) ;
couple c = {1 , 0};
c = multMatVec ( matPow ( q , l ) , c ) ;
return c . s e c o n d ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t main ( )
{
int i ;
f o r ( i = 0 ; i <= 45 ; i ++)
{
p r i n t f ( ” F %d = %l d \n” , i , fastFibonacciIT( i ) ) ;
}
return 0 ;
}
103
A.4 Tours de Hanoı̈
/∗
On p l a c e r a dans l a p r e m ie r e c a se de chaque t a b l e a u l e nombre de d i s q u e s
p l a c e s su r l e s o c l e .
∗/
i n t max2 ( i n t i , i n t j )
{
return (i > j) ? i : j;
}
i n t max3 ( i n t i , i n t j , i n t k )
{
return max2 ( max2 ( i , j ) , k ) ;
}
void a f f i c h e S o c l e s ( i n t ∗∗ s )
{
i n t max = max3( ∗ ∗ s , ∗ ∗ ( s + 1 ) , ∗ ∗ ( s + 2 ) ) ;
int i ;
f o r ( i = max ; i > 0 ; i −−)
{
i f ( ∗ ∗ s >= i )
p r i n t f ( ”%3d ” , ∗ ( ∗ s + i ) ) ;
else
printf (” ” );
i f ( ∗ ∗ ( s + 1 ) >= i )
p r i n t f ( ”%3d ” , ∗ ( ∗ ( s +1) + i ) ) ;
else
printf (” ” );
i f ( ∗ ∗ ( s + 2 ) >= i )
p r i n t f ( ”%3d ” , ∗ ( ∗ ( s +2) + i ) ) ;
p r i n t f ( ” \n” ) ;
}
p r i n t f ( ”−−−−−−−−−−−−\n” ) ;
}
void d e p l a c e D i s q u e ( i n t ∗ s o c l e S o u r c e , i n t ∗ s o c l e D e s t i n a t i o n )
{
∗( s o c l e D e s t i n a t i o n + ∗ s o c l e D e s t i n a t i o n + 1) =
∗( s o c l e S o u r c e + ∗ s o c l e S o u r c e ) ;
( ∗ s o c l e D e s t i n a t i o n )++;
( ∗ s o c l e S o u r c e )−−;
}
void d e p l a c e D i s q u e s ( i n t n , i n t ∗∗ s , i n t sFrom , i n t sVia , i n t sTo )

{
i f (n > 0)
{
d e p l a c e D i s q u e s ( n−1 , s , sFrom , sTo , sV i a ) ;
d e p l a c e D i s q u e ( ∗ ( s + sFrom ) , ∗ ( s + sTo ) ) ;
afficheSocles (s );
d e p l a c e D i s q u e s ( n−1 , s , sVia , sFrom , sTo ) ;
}
}
i n t ∗ c r e e S o c l e ( i n t n b D i sq u e s )
{
i n t ∗ s = m a l l o c ( ( n b D i sq u e s + 1 ) ∗ s i z e o f ( i n t ) ) ;
i f ( s == NULL)
exit (0);
∗s = 0;
return s ;
}
void i n i t S o c l e ( i n t ∗ s , i n t n b D i sq u e s )
{
int i ;
f o r ( i = 1 ; i <= n b D i sq u e s ; i ++)
∗ ( s + i ) = n b D i sq u e s − i + 1 ;
∗ s = n b D i sq u e s ;
}
void c r e e S o c l e s ( i n t ∗∗ s , i n t n b D i sq u e s )
{
104
∗ s = c r e e S o c l e ( n b D i sq u e s ) ;
∗ ( s + 1 ) = c r e e S o c l e ( n b D i sq u e s ) ;
∗ ( s + 2 ) = c r e e S o c l e ( n b D i sq u e s ) ;
i n i t S o c l e ( ∗ s , n b D i sq u e s ) ;
}
i n t main ( )
{
int∗ s [ 3 ] ;
i n t n b D i sq u e s = 3 ;
c r e e S o c l e s ( s , n b D i sq u e s ) ;
afficheSocles (s );
d e p l a c e D i s q u e s ( n b D i sq u e s , s , 0 , 1 , 2 ) ;
f r e e (∗ s ) ;
f re e (∗( s + 1 ) ) ;
f re e (∗( s + 2 ) ) ;
return 1 ;
}
105
A.5 Suite de Fibonacci
#d ef i n e N 45
unsigned long f i b o ( unsigned long l )

{
i f ( l == 0 )
return 0 ;
i f ( l == 1 )
return 1 ;
return f i b o ( l − 1 ) + f i b o ( l − 2 ) ;
}
void p h i ( unsigned long ∗ l 1 , unsigned long ∗ l 2 )

{
unsigned long temp ;
temp = ∗ l 1 ;
∗ l 1 += ∗ l 2 ;
∗ l 2 = temp ;
}
void applyF ( void ( ∗ f ) ( unsigned long ∗ , unsigned long ∗ ) ,

i n t n , unsigned long ∗ l 1 , unsigned long ∗ l 2 )
{
i f (n > 0)
{
f ( l1 , l2 ) ;
applyF ( f , n−1 , l 1 , l 2 ) ;
}
}
unsigned long f a s t F i b o ( unsigned long l )

{
unsigned long l 1 = 1 , l 2 = 0 ;
applyF ( phi , l , &l 1 , &l 2 ) ;
return l 2 ;
}
i n t main ( )
{
unsigned long l;
for ( l = 0 ; l <= N ; l ++)
p r i n t f ( ”%l u = %l u \n” , l , fibo ( l )) ;
for ( l = 0 ; l <= N ; l ++)
p r i n t f ( ”%l u = %l u \n” , l , fastFibo ( l ) ) ;
return 0 ;
}
106
A.6 Pgcd
unsigned long pgcd ( unsigned long a , unsigned long b )

{
i f ( b == 0 )
return a ;
return pgcd ( b , a % b ) ;
}
unsigned long f i b o n a c c i ( unsigned long l )

{
unsigned long moinsUn , moinsDeux ;
i f ( l == 0 | | l == 1 )
return l ;
moinsUn = 1 ;
moinsDeux = 0 ;
while ( l > 1 )
{
moinsUn ˆ= moinsDeux ;
moinsDeux ˆ= moinsUn ;
moinsUn ˆ= moinsDeux ;
moinsUn += moinsDeux ;
l −−;
}
return moinsUn ;
}
i n t main ( )
{
unsigned long f 1 , f 2 , i ;
f2 = fibonacci (0);
f o r ( i = 0 ; i <= 40 ; i ++)
{
f1 = f2 ;
f 2 = f i b o n a c c i ( i +1);
p r i n t f ( ” pgcd(%l u , %l u ) = %l u \n” , f 1 , f 2 , pgcd ( f 1 , f2 ));
}
return 0 ;
}
107
A.7 Pavage avec des L
typedef s tr u ct
{
int l i g n e ;
int colonne ;
} coordonnees ;
typedef s tr u ct
{
char ∗ t a b ;
int n ;
coordonnees c a s e I n t e r d i t e ;
}grille ;
int p u i ss ( int b , int n)

{
i f ( n == 0 )
return 1 ;
return b ∗ p u i s s ( b , n − 1 ) ;
}
void e r r e u r M e m o i r e ( )
{
p r i n t f ( ” Pas de memoire \n” ) ;
exit (1);
}
char ∗ r e t o u r n e A d r e s s e C a s e ( g r i l l e g , c o o r d o n n e e s c )
{
int m i l i e u ;
i f ( g . n == 0 )
return g . t a b ;
milieu = puiss (2 , g . n − 1 );
i f ( c . l i g n e >= m i l i e u )
{
g . t a b += 2∗ m i l i e u ∗ m i l i e u ;
c . l i g n e −=m i l i e u ;
}
i f ( c . c o l o n n e >= m i l i e u )
{
g . t a b += m i l i e u ∗ m i l i e u ;
c . c o l o n n e−=m i l i e u ;
}
g . n −= 1 ;
return r e t o u r n e A d r e s s e C a s e ( g , c ) ;
}
char r e t o u r n e V a l e u r C a s e ( g r i l l e g , c o o r d o n n e e s c )
{
return ∗ r e t o u r n e A d r e s s e C a s e ( g , c ) ;
}
void a f f e c t e V a l e u r C a s e ( g r i l l e g , c o o r d o n n e e s c , char v a l e u r )
{
∗ retourneAdresseCase(g , c ) = valeur ;
}
grille g r i l l e C r e e ( int n , int l i g n e I n t e r d i t e , int c ol on n e I n t e r d i t e ,

char v a l e u r s , char v a l e u r I n t e r d i t e )
{
grille g;
int l ar ge u r = p u i ss (2 , n ) ;
coordonnees c ;
g . t a b = ( char ∗ ) m a l l o c ( l a r g e u r ∗ l a r g e u r ) ;
i f ( g . t a b == NULL)
erreurMemoire ( ) ;
g.n = n;
g . caseInterdite . ligne = ligneInterdite ;
g . ca se I n te rd it e . colonne = colon neInterdite ;
f o r ( c . l i g n e = 0 ; c . l i g n e < l a r g e u r ; c . l i g n e ++)
f o r ( c . c o l o n n e = 0 ; c . c o l o n n e < l a r g e u r ; c . c o l o n n e++)
affecteValeurCase(g , c , valeurs ) ;
affecteValeurCase(g , g . caseInterdite , valeurInterdite ) ;
return g ;
}
108
void g r i l l e A f f i c h e ( g r i l l e g )
{
int l ar ge u r = p u i ss (2 , g . n ) ;
coordonnees c ;
f o r ( c . l i g n e = 0 ; c . l i g n e < l a r g e u r ; c . l i g n e ++)
{
f o r ( c . c o l o n n e = 0 ; c . c o l o n n e < l a r g e u r ; c . c o l o n n e++)
p r i n t f ( ”%c ” , r e t o u r n e V a l e u r C a s e ( g , c ) ) ;
p r i n t f ( ” \n” ) ;
}
}
void g r i l l e P a v a g e ( g r i l l e g , char c )
{
int l ar ge u r ;
char v a l e u r I n t e r d i t e ;
int nbPieces ;
g r i l l e hd , hg , bd , bg ;
i f ( g . n != 0 )
{
l a r g e u r = p u i s s ( 2 , g . n −1);
hg . t a b = g . t a b ;
hd . t a b = hg . t a b + l a r g e u r ∗ l a r g e u r ;
bg . t a b = hd . t a b + l a r g e u r ∗ l a r g e u r ;
bd . t a b = bg . t a b + l a r g e u r ∗ l a r g e u r ;
hg . n = g . n − 1 ;
hd . n = g . n − 1 ;
bg . n = g . n − 1 ;
bd . n = g . n − 1 ;
hg . c a s e I n t e r d i t e . l i g n e = l a r g e u r − 1 ;
hg . c a s e I n t e r d i t e . c o l o n n e = l a r g e u r − 1 ;
hd . c a s e I n t e r d i t e . l i g n e = l a r g e u r − 1 ;
hd . c a s e I n t e r d i t e . c o l o n n e = 0 ;
bg . c a s e I n t e r d i t e . l i g n e = 0 ;
bg . c a s e I n t e r d i t e . c o l o n n e = l a r g e u r − 1 ;
bd . c a s e I n t e r d i t e . l i g n e = 0 ;
bd . c a s e I n t e r d i t e . c o l o n n e = 0 ;
i f (g . caseInterdite . ligne < largeur )
i f ( g . c as e In t er d ite . colonne < largeur )
hg . c a s e I n t e r d i t e = g . c a s e I n t e r d i t e ;
else
{
hd . c a s e I n t e r d i t e . l i g n e = g . c a s e I n t e r d i t e . l i g n e ;
hd . c a s e I n t e r d i t e . c o l o n n e = g . c a s e I n t e r d i t e . c o l o n n e − l a r g e u r ;
}
else
i f ( g . c as e In t er d ite . colonne < largeur )
{
bg . c a s e I n t e r d i t e . l i g n e = g . c a s e I n t e r d i t e . l i g n e − l a r g e u r ;
bg . c a s e I n t e r d i t e . c o l o n n e = g . c a s e I n t e r d i t e . c o l o n n e − l a r g e u r ;
}
else
{
bd . c a s e I n t e r d i t e . l i g n e = g . c a s e I n t e r d i t e . l i g n e − l a r g e u r ;
bd . c a s e I n t e r d i t e . c o l o n n e = g . c a s e I n t e r d i t e . c o l o n n e − l a r g e u r ;
}
v a l e u r I n t e r d i t e = retourneValeurCase ( g , g . c a s e I n t e r d i t e ) ;
a f f e c t e V a l e u r C a s e ( hd , hd . c a s e I n t e r d i t e , c + 1 ) ;
a f f e c t e V a l e u r C a s e ( hg , hg . c a s e I n t e r d i t e , c + 1 ) ;
a f f e c t e V a l e u r C a s e ( bg , bg . c a s e I n t e r d i t e , c + 1 ) ;
a f f e c t e V a l e u r C a s e ( bd , bd . c a s e I n t e r d i t e , c + 1 ) ;
affecteValeurCase (g , g . c ase In te rd ite , vale u rIn t erd it e ) ;
g r i l l e P a v a g e ( hd , c + 1 ) ;
nbPieces = ( large ur ∗ large ur − 1)/3;
g r i l l e P a v a g e ( hg , c+n b P i e c e s + 1 ) ;
g r i l l e P a v a g e ( bg , c+2∗ n b P i e c e s + 1 ) ;
g r i l l e P a v a g e ( bd , c+3∗ n b P i e c e s + 1 ) ;
}
}
void g r i l l e D e t r u i t ( g r i l l e g )
{
f r e e ( g . tab ) ;
}
i n t main ( )
{
g r i l l e g = g r i l l e C r e e ( 4 , 5 , 1 2 , −1, ’ ! ’ ) ;
grillePavage (g , ’ ! ’ );
grilleAffiche (g );
109
grilleDetruit (g );
return 0 ;
}
110
A.8 Complexes
#include<math . h>
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a p a r t i e reelle
∗/
double reComplexe ( c o m p l e x e c )
{
return c . r e ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a p a r t i e i m a g i n a i r e
∗/
double imComplexe( c o m p l e x e c )
{
return c . im ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e module
∗/
double modComplexe ( c o m p l e x e c )
{
return c . mod ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l ’ argument
∗/
double argComplexe ( c o m p l e x e c )
{
return c . a r g ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e c so u s forme e x p o n e n t i e l l e
∗/
void printExpComplexe ( c o m p l e x e c )
{
p r i n t f ( ” %.10 l f e ˆ ( % . 1 0 l f i ) ” , c . mod , c . a r g ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Affiche l ’ a f f i x e de c
∗/
void p r i n t A f f C o m p l e x e ( c o m p l e x e c )
{
p r i n t f ( ” ( % . 1 0 l f + %.10 l f i ) ” , c . r e , c . im ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Cree un complexe a p a r t i r de son a f f i x e
∗/
111
c o m p l e x e makeAffComplexe ( double r e , double im )
{
c o m p l e x e c = { r e , im , s q r t ( r e ∗ r e + im∗im ) , 0 . 0 } ;
i f ( c . mod != 0 . 0 )
{
c . a r g = a c o s ( c . r e / c . mod) ∗ ( ( c . im >= 0 ) ? 1 : − 1 ) ;
}
return c ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Cree un complexe a p a r t i r de sa forme e x p o n e n t i e l l e
∗/
c o m p l e x e makeExpComplexe( double mod , double a r g )

{
c o m p l e x e c = { 0 . 0 , 0 . 0 , mod , a r g } ;
c . a r g += M PI ;
long l = c . a r g / ( 2 . ∗ M PI ) ;
c . a r g −= l ∗ 2 . ∗ M PI ;
c . a r g −= M PI ;
i f (mod != 0 . 0 )
{
c . r e = c . mod ∗ c o s ( c . a r g ) ;
c . im = c . mod ∗ s i n ( c . a r g ) ;
}
return c ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
pComplexe copyComplexe ( c o m p l e x e c )
{
pComplexe p = ( pComplexe ) m a l l o c ( s i z e o f ( c o m p l e x e ) ) ;
i f ( p == NULL)
exit (0);
p−>r e = c . r e ;
p−>im = c . im ;
p−>mod = c . mod ;
p−>a r g = c . a r g ;
return p ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e c o nju g u e de c
∗/
c o m p l e x e c o n j u g u e Co m ple xe ( c o m p l e x e c )
{
return makeAffComplexe ( c . r e , −c . im ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
S o u s t r a i t c1 e t c2
∗/
c o m p l e x e subComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 )
{
return makeAffComplexe ( c 1 . r e − c 2 . r e , c 1 . im − c 2 . im ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ad d it io nne c1 e t c2
∗/
c o m p l e x e addComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 )
{
return makeAffComplexe ( c 1 . r e + c 2 . r e , c 1 . im + c 2 . im ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
112
M u l t i p l i e c1 e t c2
∗/
c o m p l e x e multComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 )
{
return makeAffComplexe ( c 1 . r e ∗ c 2 . r e − c 1 . im ∗ c 2 . im ,
c 1 . r e ∗ c 2 . im + c 1 . im ∗ c 2 . r e ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Multiplie c par l e reel d
∗/
c o m p l e x e multReelComplexe ( double d , c o m p l e x e c )
{
return makeExpComplexe( d ∗ c . mod , c . a r g ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D i v i s e c2 par c1
∗/
c o m p l e x e divComplexe ( c o m p l e x e c1 , c o m p l e x e c 2 )
{
return makeExpComplexe( c 1 . mod / c 2 . mod , c 1 . a r g − c 2 . a r g ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Eleve c a l a puissane n
∗/
c o m p l e x e p u i ssCo m p l e x e ( c o m p l e x e c , unsigned long n )

{
return makeExpComplexe( pow ( c . mod , n ) , n∗ c . a r g ) ;
}
113
A.9 Listes chaı̂nées
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void e r r o r ( )
{
printf (” error ” ) ;
exit (0);
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
int l i n k e d Li st Ge t S i z e ( l i n k e d L i s t ∗ l )
{
return l −>s i z e ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
linkedList ∗ linkedListCreate ()
{
linkedList ∗ l ;
l = ( l i n k e d L i s t ∗) malloc ( s i zeo f ( l i n k e d L i s t ) ) ;
i f ( l == NULL)
error ( ) ;
l −> f i r s t = NULL ;
l −>l a s t = NULL;
l −>s i z e = 0 ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
l i n k ∗ l i n k e d L i s t C r e a t e L i n k ( void∗ x )
{
l i n k ∗ l k = ( l i n k ∗) malloc ( s i zeo f ( l i n k ) ) ;
i f ( l k == NULL) e r r o r ( ) ;
l k −>d a t a = x ;
l k −>n e x t = NULL ;
return l k ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t A p p e n d L i n k ( l i n k e d L i s t ∗ l , link ∗ lk )
{
i f ( l −>l a s t == NULL)
{
l −> f i r s t = l k ;
l −>l a s t = l −> f i r s t ;
}
else
{
l −>l a s t −>n e x t = l k ;
l −>l a s t = l k ;
}
l k −>n e x t = NULL ;
l −>s i z e ++;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t A p p e n d ( l i n k e d L i s t ∗ l , void∗ x )
{
link ∗ lk = linkedListCreateLink(x ) ;
linkedListAppendLink ( l , l k ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t P u s h L i n k ( l i n k e d L i s t ∗ l , link ∗ lk )
114
{
if ( l −> f i r s t == NULL)
{
l −> f i r s t = l k ;
l −>l a s t = l −> f i r s t ;
}
else
{
l k −>n e x t = l −> f i r s t ;
l −> f i r s t = l k ;
}
l −>s i z e ++;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t P u s h ( l i n k e d L i s t ∗ l , void∗ x )
{
link ∗ lk = linkedListCreateLink(x ) ;
linkedListPushLink ( l , lk ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
link ∗ linkedListGetFirst( linkedList ∗ l )

{
return l −> f i r s t ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
link ∗ linkedListUnlinkFirst( linkedList ∗ l )

{
link ∗ f = linkedListGetFirst( l );
i f ( f != NULL)
{
l −> f i r s t = l −>f i r s t −>n e x t ;
i f ( l −>l a s t == f )
l −>s i z e −−;
}
return f ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t C o n c a t ( l i n k e d L i s t ∗ b e g i n , l i n k e d L i s t ∗ end )
{
i f ( b e g i n −>s i z e != 0 )
b e g i n −>l a s t −>n e x t = end−> f i r s t ;
else
b e g i n −> f i r s t = end−> f i r s t ;
i f ( end−>s i z e != 0 )
b e g i n −>l a s t = end−>l a s t ;
end−> f i r s t = NULL;
end−>l a s t = NULL ;
b e g i n −>s i z e += end−>s i z e ;
end−>s i z e = 0 ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
l i n k e d L i s t ∗ l i n k e d L i s t M a p ( l i n k e d L i s t ∗ l , void∗ ( ∗ f ) ( void ∗ ) )
{
linkedList ∗ lBis = linkedListCreate ( ) ;
link ∗ lk = linkedListGetFirst( l ) ;
while ( l k !=NULL)
{
l i n k e d L i s t A p p e n d ( l B i s , f ( l k −>d a t a ) ) ;
l k = l k −>n e x t ;
}
return l B i s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t A p p l y ( l i n k e d L i s t ∗ l , void ( ∗ f ) ( void ∗ ) )

{
115
link ∗ lk = linkedListGetFirst( l ) ;
while ( l k !=NULL)
{
f ( l k −>d a t a ) ;
l k = l k −>n e x t ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k D e s t r o y ( l i n k ∗ l , void ( ∗ f r ) ( void ∗ ) )

{
i f ( l != NULL)
{
l i n k D e s t r o y ( l −>next , f r ) ;
f r ( l −>d a t a ) ;
free ( l );
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void l i n k e d L i s t D e s t r o y ( l i n k e d L i s t ∗ l , void ( ∗ f r ) ( void ∗ ) )

{
l i n k D e s t r o y ( l −>f i r s t , f r ) ;
free ( l );
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
void d e s t r o y I nt ( void ∗ i )
{
f r e e (( i n t ∗) i ) ;
}
void p r i nt I nt ( void ∗ i )
{
p r i n t f (”%d −> ” , ∗ ( ( i n t ∗ ) i ) ) ;
}
void ∗ copyInt ( void ∗ i )

{
void ∗ v = malloc ( s i z e o f ( i n t ) ) ;
i f ( v == NULL)
error ( ) ;
∗(( i n t ∗) v ) = ∗(( i n t ∗) i ) ;
return v ;
}
i n t main ( )
{
int i = 1;
int ∗ k ;
link e dL ist∗ l = linkedListCreate () ;
linkedList∗ lBis ;
f o r ( i = 0 ; i < 100 ; i ++)
{
k = ( i n t ∗) malloc ( s i z e o f ( i n t ) ) ;
∗k = i ;
linkedListAppend ( l , k ) ;
}
// l i n k e d L i s t A p p l y ( l , p r i n t I n t ) ;
l B i s = linkedListMap ( l , copyInt ) ;
// l i n k e d L i s t A p p l y ( l B i s , p r i n t I n t ) ;
linkedListConcat ( l , lBis );
linkedListApply ( l , printInt );
linkedListDestroy ( l , destroyInt );
linkedListDes tr oy ( lBis , d e s t r o y I nt ) ;
return 1;
}
∗/
116
A.10 Tri fusion
void s p l i t ( l i n k e d L i s t ∗ s o u r c e , l i n k e d L i s t ∗ d e s t 1 , l in k ed Li st ∗ dest2 )
{
li n k ∗ l = l i n k e d Li stUnl ink Fi rst ( source ) ;
i f ( l != NULL)
{
linkedListAppendLink ( dest1 , l ) ;
s p l i t ( source , dest2 , dest1 ) ;
}
}
void merge ( l i n k e d L i s t ∗ s o u r c e 1 , l i n k e d L i s t ∗ s o u r c e 2 , l i n k e d L i s t ∗ dest ,

i n t ( ∗ i n f ) ( void ∗ , void ∗ ) )
{
li n k ∗ l1 , ∗ l2 ;
l1 = l i n k e d Li stGetFirst( source1 ) ;
l2 = l i n k e d Li stGetFirst( source2 ) ;
i f ( l 1 != NULL | | l 2 != NULL)
{
i f ( l 2 == NULL | |
( l 1 != NULL && i n f ( l 1 −>data , l 2 −>d a t a ) )
)
{
l i n k e d Li stUn li nkF irst( source1 ) ;
linkedListAppendLink ( dest , l 1 ) ;
}
else
{
l i n k e d Li stUn li nkF irst( source2 ) ;
linkedListAppendLink ( dest , l 2 ) ;
}
merge ( s o u r c e 1 , s o u r c e 2 , d e s t , i n f ) ;
}
}
void doNothing ( void∗ v )

{
}
void t r i F u s i o n ( l i n k e d L i s t ∗ l , i n t ( ∗ i n f ) ( void ∗ , void ∗ ) )

{
li n k e d L i s t ∗ l1 , ∗ l2 ;
i f ( l i n k e d Li st Ge t S i z e ( l ) > 1)
{
l1 = linkedListCreate ( ) ;
l2 = linkedListCreate ( ) ;
s p l i t ( l , l1 , l2 ) ;
triFusion ( l1 , i n f ) ;
triFusion ( l2 , i n f ) ;
merge ( l 1 , l 2 , l , i n f ) ;
l i n k e d L i s t D e s t r o y ( l 1 , doNothing ) ;
l i n k e d L i s t D e s t r o y ( l 2 , doNothing ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t e s t I n f ( void∗ i , void∗ j )
{
return ( ∗ ( i n t ∗ ) i <= ∗ ( i n t ∗ ) j ) ? 1 : 0;
}
{
f r e e ( ( int ∗) i ) ;
}
i n t main ( )
{
int i = 1;
int∗ k ;
linkedList ∗ l = linkedListCreate ( ) ;
link ∗ lk ;
f o r ( i = 100 ; i > 0 ; i −−)
{
117
k = ( int ∗) malloc ( s i zeo f ( int ) ) ;
∗k = i ;
}
lk = linkedListGetFirst( l ) ;
while ( l k !=NULL)
{
p r i n t f ( ”%d ” , ∗ ( ( i n t ∗ ) ( l k −>d a t a ) ) ) ;
l k = l k −>n e x t ;
}
p r i n t f ( ” \n” ) ;
triFusion ( l , estInf );
lk = linkedListGetFirst( l ) ;
while ( l k !=NULL)
{
p r i n t f ( ”%d ” , ∗ ( ( i n t ∗ ) ( l k −>d a t a ) ) ) ;
l k = l k −>n e x t ;
}
p r i n t f ( ” \n” ) ;
linkedListDestroy ( l , destroyInt ) ;
return 0 ;
}
118
A.11 Tri par insertion
l i n k ∗ i n s e r t ( l i n k ∗ l i s t , l i n k ∗ item , i n t ( ∗ e s t I n f ) ( void ∗ , void ∗ ) )

{
i f ( l i s t == NULL)
{
item−>n e x t = NULL;
return i t e m ;
}
i f ( e s t I n f ( item−>data , l i s t −>d a t a ) )
{
item−>n e x t = l i s t ;
return i t e m ;
}
l i s t −>n e x t = i n s e r t ( l i s t −>next , item , e s t I n f ) ;
return l i s t ;
}
l i n k ∗ t r i I n s e r t i o n ( l i n k ∗ l i s t , i n t ( ∗ e s t I n f ) ( void ∗ , void ∗ ) )
{
i f ( l i s t == NULL)
return NULL;
return i n s e r t ( t r i I n s e r t i o n ( l i s t −>next , e s t I n f ) , l i s t , e s t I n f ) ;
}
void l i n k e d L i s t S o r t ( l i n k e d L i s t ∗ l , i n t ( ∗ e s t I n f ) ( void ∗ , void ∗ ) )

{
l −> f i r s t = t r i I n s e r t i o n ( l −> f i r s t , e s t I n f ) ;
void s e t L a s t ( l i n k ∗ l l )
{
i f ( l l == NULL)
else
i f ( l l −>n e x t == NULL)
l −>l a s t = l l ;
else
s e t L a s t ( l l −>n e x t ) ;
}
s e t L a s t ( l −> f i r s t ) ;
}
i n t e s t I n f ( void∗ i , void∗ j )
{
return ( ∗ ( i n t ∗ ) i <= ∗ ( i n t ∗ ) j ) ? 1 : 0;
}
{
f r e e ( ( int ∗) i ) ;
}
i n t main ( )
{
int i = 1;
int∗ k ;
f o r ( i = 100 ; i > 0 ; i −−)
{
k = ( int ∗) malloc ( s i zeo f ( int ) ) ;
∗k = i ;
}
void p r i n t I n t ( void∗ i )
{
p r i n t f ( ”%d ” , ∗ ( ( i n t ∗ ) i ) ) ;
}
linkedListApply ( l , p ri n tIn t ) ;
p r i n t f ( ” \n” ) ;
linkedListSort ( l , estInf ) ;
linkedListApply ( l , p ri n tIn t ) ;
p r i n t f ( ” \n” ) ;
linkedListDestroy ( l , destroyInt ) ;
return 0 ;
}
119
A.12 Transformée de Fourier
#include<math . h>
#include ” f o u r i e r . h”
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e s r a c i n e s n−eme de c , O( n)
∗/
l i n k e d L i s t ∗ r a c i n e s C o m p l e x e ( c o m p l e x e c , unsigned long n )
{
pComplexe p ;
unsigned long i ;
f o r ( i = 0 ; i < n ; i ++)
{
p = ( pComplexe) m a l l o c ( s i z e o f ( c o m p l e x e ) ) ;
i f ( p == NULL)
exit (1);
∗p = makeExpComplexe( pow ( c . mod , 1 . / n ) , ( c . a r g /n ) + ( i ) ∗ 2 ∗ M PI/n ) ;
linkedListAppend ( l , p ) ;
}
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e s r a c i n e s n−eme de 1 , O( n)
∗/
l i n k e d L i s t ∗ u n i t e R a c i n e s C o m p l e x e ( unsigned long n )
{
return r a c i n e s C o m p l e x e ( makeAffComplexe ( 1 . 0 , 0 . 0 ) , n ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Donne l ’ image de x par polynome . Les c o e f f i c i e n t s du polynome s o n t
r a ng e s par o r d r e de d e g r e c r o i s s a n t . O( n ) .
∗/
c o m p l e x e h o r n e r ( l i n k ∗ polynome , c o m p l e x e x )
{
i f ( polynome == NULL)
return makeAffComplexe ( 0 . 0 , 0 . 0 ) ;
return addComplexe ( ∗ ( pComplexe ) polynome−>data ,
multComplexe ( x ,
h o r n e r ( polynome−>next ,
x)));
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e t r u i t complexe p o i n t e par p .
∗/
void d e a l l o c a t e C o m p l e x e ( void∗ p )
{
f r e e ( ( pComplexe) p ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a t r a n s f o r m e e d i s c r e t e de Fo u r ie r du v e c t e u r l ,
v e r s i o n i t e r a t i v e en O( nˆ2)
∗/
l i n k e d L i s t ∗ t r a n s f o r m e e F o u r i e r I t ( l i n k e d L i s t ∗ polynome )
{
l i n k e d L i s t ∗ FT = l i n k e d L i s t C r e a t e ( ) ;
120
l i n k e d L i s t ∗ W n = u n i t e R a c i n e s C o m p l e x e ( l i n k e d L i s t G e t S i z e ( polynome ) ) ;
void∗ e v a l u a t e ( void∗ w)
{
i f ( p == NULL)
exit (0);
∗p = h o r n e r ( l i n k e d L i s t G e t F i r s t ( polynome ) ,
∗ ( pComplexe )w ) ;
return p ;
}
FT = l i n k e d L i s t M a p ( W n , e v a l u a t e ) ;
l i n k e d L i s t D e s t r o y (W n , d e a l l o c a t e C o m p l e x e ) ;
return FT ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ne f a i t rien . . .
∗/
void doNothing ( void∗ w)

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
v e r s i o n r e c u r s i v e en O( n . l o g n )
∗/
l i n k e d L i s t ∗ FFT( l i n k e d L i s t ∗ polynome )
{
// c r e a t i o n d e s l i s t e s
l i n k e d L i s t ∗ FT = l i n k e d L i s t C r e a t e ( ) ; // r e s u l t a t
l i n k e d L i s t ∗ odd = l i n k e d L i s t C r e a t e ( ) ; // c o e f f i c i e n t s d ’ i n d i c e p a i r
l i n k e d L i s t ∗ e v e n = l i n k e d L i s t C r e a t e ( ) ; // c o e f f i c i e n t s d ’ i n d i c e im p a ir
l i n k e d L i s t ∗ a 0 = l i n k e d L i s t C r e a t e ( ) ; // TF de odd
l i n k e d L i s t ∗ a 1 = l i n k e d L i s t C r e a t e ( ) ; // TF de even
l i n k ∗ l ; // pour p a r c o u r i r FT
c o m p l e x e w = makeAffComplexe ( 1 . 0 , 0 . 0 ) ;
c o m p l e x e c = makeExpComplexe ( 1 . 0 , 2∗ M PI/ l i n k e d L i s t G e t S i z e ( polynome ) ) ;
int isEven = 1 ;
// c a s de b a se
i f ( l i n k e d L i s t G e t S i z e ( polynome ) == 1 )
{
l i n k e d L i s t A p p e n d (FT,
copyComplexe ( ∗ ( pComplexe )
( l i n k e d L i s t G e t F i r s t ( polynome)−>d a t a ) ) ) ;
return FT ;
}
// a u t r e s c a s
void s p l i t ( void∗ c o e f f )
{
i f ( isEven )
l i n k e d L i s t A p p e n d ( even , c o e f f ) ;
else
l i n k e d L i s t A p p e n d ( odd , c o e f f ) ;
isEven = ! isEven ;
}
// s e p a r a t i o n de polynome
l i n k e d L i s t A p p l y ( polynome , s p l i t ) ;
// a p p e l s r e c u r s i f s
a 0 = FFT( e v e n ) ;
a 1 = FFT( odd ) ;
void e v e n V a l u e s ( void∗ v )
{
l i n k e d L i s t A p p e n d (FT, copyComplexe ( ∗ ( pComplexe ) v ) ) ;
}
// a j o u t dans FT d e s v a l e u r s de a ˆ [ 0 ]
linkedListApply ( a 0 , evenValues ) ;
l = l i n k e d L i s t G e t F i r s t (FT ) ;
void o d d V a l u e s ( void∗ v )
{
pComplexe f t = ( pComplexe ) ( l −>d a t a ) ;
∗ f t = addComplexe ( ∗ f t , multComplexe (w, ∗ ( pComplexe ) v ) ) ;
w = multComplexe ( c , w ) ;
l = l −>n e x t ;
}
121
// a j o u t dans FT d e s w nˆp ∗ a ˆ [ 1 ] p
l i n k e d L i s t A p p l y ( a 1 , oddValues ) ;
// l i b e r a t i o n de l a memoire
l i n k e d L i s t D e s t r o y ( odd , doNothing ) ;
l i n k e d L i s t D e s t r o y ( even , doNothing ) ;
l i n k e d L i s t D e s t r o y ( a 0 , deallocateComplexe ) ;
return FT ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
v e r s i o n r e c u r s i v e en O( n . l o g n )
∗/
l i n k e d L i s t ∗ i n v e r se F F T ( l i n k e d L i s t ∗ polynome )
{
l i n k e d L i s t ∗ odd = l i n k e d L i s t C r e a t e ( ) ;
l i n k e d L i s t ∗ even = l i n k e d L i s t C r e a t e ( ) ;
linkedList ∗ a 0 = linkedListCreate ( ) ;
linkedList ∗ a 1 = linkedListCreate ( ) ;
link ∗ l ;
c o m p l e x e w = makeAffComplexe ( 1 . 0 , 0 . 0 ) ;
c o m p l e x e c = makeExpComplexe ( 1 . 0 , −2.∗M PI/ l i n k e d L i s t G e t S i z e ( polynome ) ) ;
int isEven = 1 ;
i f ( l i n k e d L i s t G e t S i z e ( polynome ) == 1 )
{
l i n k e d L i s t A p p e n d (FT,
copyComplexe ( ∗ ( pComplexe )
( l i n k e d L i s t G e t F i r s t ( polynome)−>d a t a ) ) ) ;
return FT ;
}
void s p l i t ( void∗ c o e f f )
{
i f ( isEven )
l i n k e d L i s t A p p e n d ( even , c o e f f ) ;
else
l i n k e d L i s t A p p e n d ( odd , c o e f f ) ;
isEven = ! isEven ;
}
l i n k e d L i s t A p p l y ( polynome , s p l i t ) ;
a 0 = i n v e r se F F T ( e v e n ) ;
a 1 = i n v e r se F F T ( odd ) ;
void e v e n V a l u e s ( void∗ v )
{
l i n k e d L i s t A p p e n d (FT, copyComplexe ( ∗ ( pComplexe ) v ) ) ;
}
l = l i n k e d L i s t G e t F i r s t (FT ) ;
void o d d V a l u e s ( void∗ v )
{
pComplexe f t = ( pComplexe ) ( l −>d a t a ) ;
c o m p l e x e v a l u e = multComplexe (w, ∗ ( pComplexe ) v ) ;
v a l u e = multReelComplexe ( 1 . / 2 . , addComplexe ( ∗ f t , v a l u e ) ) ;
∗ f t = value ;
w = multComplexe ( c , w ) ;
l = l −>n e x t ;
}
void doNothing ( void∗ w) { }
l i n k e d L i s t D e s t r o y ( odd , doNothing ) ;
l i n k e d L i s t D e s t r o y ( even , doNothing ) ;
{
}
return FT ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
122
du v e c t e u r l , v e r s i o n i t e r a t i v e en O( nˆ2)
∗/
l i n k e d L i s t ∗ t r a n s f o r m e e I n v e r s e F o u r i e r I t ( l i n k e d L i s t ∗ polynome )
{
i n t n = l i n k e d L i s t G e t S i z e ( polynome ) ;
l i n k e d L i s t ∗ W n = uniteRacinesComplexe(n ) ;
void c o n j u g u e ( void∗ w)
{
∗ ( pComplexe)w = c o n j u g u e Co mpl exe ( ∗ ( pComplexe )w ) ;
}
l i n k e d L i st A p p l y (W n, conjugue ) ;
void∗ e v a l u a t e ( void∗ w)
{
i f ( p == NULL)
exit (0);
∗p = h o r n e r ( l i n k e d L i s t G e t F i r s t ( polynome ) ,
∗ ( pComplexe )w ) ;
return p ;
}
FT = l i n k e d L i s t M a p ( W n , e v a l u a t e ) ;
void d i v i s e ( void∗ w)
{
∗ ( pComplexe)w = multReelComplexe ( 1 . / n , ∗ ( pComplexe )w ) ;
}
l i n k e d L i s t A p p l y (FT, d i v i s e ) ;
{
}
l i n k e d L i s t D e s t r o y (W n , d e a l l o c a t e C o m p l e x e ) ;
return FT ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
l i n k e d L i s t ∗ si m p l e Li st ( int n)
{
i f ( n == 0 )
return l i n k e d L i s t C r e a t e ( ) ;
linkedList ∗ l = simpleList (n − 1) ;
l i n k e d L i s t A p p e n d ( l , copyComplexe ( makeAffComplexe ( n , 0.0)));
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
i n t main ( )
{
i n t k = 512;
v o i d p r int C ( v o i d ∗ v )
{
p r int AffC o m p l e x e ( ∗ ( ( pComplexe) v ) ) ;
p r i n t f (”\ n ” ) ;
}
p r i n t f (” l i s t e \n ” ) ;
linkedListApply ( simpleList (k ) ,
p r int C ) ;
p r i n t f (”FFT de l i s t e \n ” ) ;
l i n k e d L i s t A p p l y (FFT( s i m p l e L i s t ( k ) ) ,
p r int C ) ;
p r i n t f (”FFT−1 o FFT de l i s t e \n ” ) ;
l i n k e d L i s t A p p l y ( inverseFFT (FFT( s i m p l e L i s t ( k ) ) ) ,
p r int C ) ;
return 0;
}
∗/
123
A.13 Polynômes
#include<math . h>
#include ” polynomes . h”
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne un polynome v i d e .
∗/
l i n k e d L i s t ∗ makePolynome ( )
{
return l i n k e d L i s t C r e a t e ( ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A l l o u e dynamiquement un emplacement pour une v a r i a b l e de t y p e
double , y a f f e c t e d e t retourne c e t t e adresse .
∗/
double∗ makeDouble( double d )

{
double∗ p = ( double ∗ ) m a l l o c ( s i z e o f ( double ) ) ;
i f ( p == NULL)
exit (0);
∗p = ( double ) d ;
return p ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A l l o u e dynamiquement un emplacement pour une v a r i a b l e de t y p e
double , y a f f e c t e d e t retourne c e t t e adresse .
∗/
void∗ makeDoubleWithVoid( void∗ v )

{
return makeDouble ( ∗ ( double ∗ ) v ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e s a l l o u e une v a r i a b l e de t y p e d o u b l e .
∗/
void d e s t r o y D o u b l e ( void∗ v )
{
f r e e ( ( double ∗ ) v ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne une c o p i e de l , c o p i e a u s s i les coefficients .
∗/
l i n k e d L i s t ∗ copyPolynome ( l i n k e d L i s t ∗ l )
{
return l i n k e d L i s t M a p ( l , makeDoubleWithVoid ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e t r u i t l e polynome l e t s e s c o e f f i c i e n t s .
∗/
void d e st r o y P o l y n o m e ( l i n k e d L i s t ∗ l )
{
l i n k e d L i st D e st r o y ( l , destroyDouble ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
124
/∗
A f f i c h e l e monome c o e f f ∗ x ˆ d e g r e proprement , f i r s t P r i n t e d
e s t v r a i s i e t se u l e m e nt s i ce monome e s t l e p r e m ie r a f f i c h e
dans l e polynome .
∗/
i n t printMonome ( double c o e f f , i n t d e g r e , i n t f i r s t P r i n t e d )
{
i f ( c o e f f != 0 . 0 )
{
i f ( f i r s t P r i n t e d && c o e f f > 0 . 0 )
printf (” + ” );
i f ( c o e f f <0.0)
printf (” − ” );
p r i n t f ( ” %4.2 l f ” , ( c o e f f >0)? c o e f f :− c o e f f ) ;
i f ( degre > 0)
p r i n t f ( ”x” ) ;
i f ( degre > 1)
p r i n t f ( ”ˆ” ) ;
i f ( degre > 1)
p r i n t f ( ”%d” , d e g r e ) ;
return 1 ;
}
return 0 ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e polynome l e p l u s proprement p o s s i b l e .
∗/
void p r i n t P o l y n o m e ( l i n k e d L i s t ∗ polynome )
{
int degre = 0 , f i r s t P r i n t e d = 0;
void f ( void∗ c o e f f )
{
i f ( printMonome ( ∗ ( double ∗ ) c o e f f , d e g r e , firstPrinted ))
firstPrinted = 1;
d e g r e ++;
}
l i n k e d L i s t A p p l y ( polynome , f ) ;
p r i n t f ( ” \n” ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Supprime l e s O non s i g n i f i c a t i f s Ã l a f i n du polynÃ´me .
∗/
void s k i p Z e r o s P o l y n o m e ( l i n k e d L i s t ∗ l )
{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e d e g r e de l .
∗/
int degreePolynome( l i n k e d L i s t ∗ l )
{
int n ;
skipZerosPolynome( l ) ;
n = linkedListGetSize ( l );
i f ( n != 1 )
return n ;
return ( ∗ ( double ∗ ) l i n k e d L i s t G e t F i r s t ( l )−>d a t a != 0 ) − 1 ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ajo u t e un monome de c o e f f i c i e n t c o e f f a l a f i n du polynome , faisant
a i n s i c r o u t r e son d e g r e de 1 .
∗/
void appendCoeffPolynome ( l i n k e d L i s t ∗ polynome , double c o e f f )

{
125
double∗ p = m a l l o c ( s i z e o f ( double ) ) ;
i f ( p == NULL)
exit (0);
∗p = c o e f f ;
l i n k e d L i s t A p p e n d ( polynome , p ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Cree e t r e t o u r n e l e polynome de d e g r e n−1 dont l e s
c o e f f i c i e n t s s o n t p a s s e s dans l e t a b l e a u d .
∗/
l i n k e d L i s t ∗ makeArrayPolynome( double∗ d , i n t n )
{
l i n k e d L i s t ∗ l = makePolynome ( ) ;
int i ;
f o r ( i = 0 ; i < n ; i ++)
appendCoeffPolynome ( l , ∗ ( d + i ) ) ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e polynome nu l .
∗/
l i n k e d L i s t ∗ z e r o P o l y n o me ( )
{
appendCoeffPolynome ( l , 0 . 0 ) ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e polynome u n i t e .
∗/
l i n k e d L i s t ∗ u n i t P o l y n o me ( )
{
appendCoeffPolynome ( l , 1 . 0 ) ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l e polynome
0 + X + 2Xˆ2 + 3Xˆ3 + . . . + iXˆ i + . . . + nXˆn
∗/
l i n k e d L i s t ∗ simpleListPolynome ( int n)
{
linkedList ∗ l ;
i f ( n == 0 )
return z e r o P o l y n o m e ( ) ;
l = simpleListPolynome ( n − 1 ) ;
appendCoeffPolynome ( l , n ) ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ajo u t e l a c o n s t a n t e d au polynome l .
∗/
void addRealPolynome( l i n k e d L i s t ∗ l , double d )

{
li n k ∗ lnk = l i n k e d L i s tG e t Fir s t ( l ) ;
i f ( l n k != NULL)
∗ ( double ∗ ) l n k−>d a t a += d ;
else
appendCoeffPolynome ( l , d ) ;
}
126
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Multiplie l e polynome l par l e reel d .
∗/
void multRealPolynome ( l i n k e d L i s t ∗ l , double d )

{
void m u l t i p l y D o u b l e ( void∗ v )
{
∗ ( double ∗ ) v ∗= d ;
}
linkedListApply ( l , multiplyDouble ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Multiplie l e polynome l par Xˆn
∗/
void multXNPolynome ( l i n k e d L i s t ∗ l , i n t n )
{
i f (n > 0)
{
l i n k e d L i s t P u s h ( l , makeDouble ( 0 . 0 ) ) ;
multXNPolynome ( l , n − 1 ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Multiplie l e polynome l par c o e f f ∗Xˆ exp
∗/
void multMonomePolynome ( l i n k e d L i s t ∗ l , double c o e f f , i n t exp )

{
multRealPolynome ( l , c o e f f ) ;
multXNPolynome ( l , exp ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ad d it io nne deux Ã deux t o u s l e s m a i l l o n s d e s deux l i s t e s la
e t l b . Concatene l e r e s u l t a t a l a l i s t e r e s u l t .
∗/
void a d d M a i l l o n s ( l i n k ∗ l a , l i n k ∗ l b , l i n k e d L i s t ∗ r e s u l t )
{
i f ( l a != NULL && l b != NULL)
{
appendCoeffPolynome ( r e s u l t , ∗ ( double ∗ ) l a −>d a t a
+ ∗ ( double ∗ ) l b −>d a t a ) ;
a d d M a i l l o n s ( l a −>next , l b −>next , r e s u l t ) ;
}
else
{
i f ( l a != NULL)
{
appendCoeffPolynome ( r e s u l t , ∗ ( double ∗ ) l a −>d a t a ) ;
a d d M a i l l o n s ( l a −>next , NULL, r e s u l t ) ;
}
i f ( l b != NULL)
{
appendCoeffPolynome ( r e s u l t , ∗ ( double ∗ ) l b−>d a t a ) ;
a d d M a i l l o n s (NULL, l b −>next , r e s u l t ) ;
}
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A d d i t i o n e l e s deux polynomes a e t b , r e t o u r n e c e t t e somme.
∗/
l i n k e d L i s t ∗ addPolynome ( l i n k e d L i s t ∗ a , linkedList ∗ b)
{
l i n k e d L i s t ∗ r e s u l t = makePolynome ( ) ;
127
addMaillons ( l i n k e d L i s t G e t F i r s t ( a ) ,
linke dListGetFirst(b) ,
result );
return r e s u l t ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
M u l t i p l i e a e t b avec l a recurrence
( a 0 + a 1X + . . . + a nXˆn)Q(X)
= a 0 ∗ Q(X) + X ∗ ( a 1 + a 2 X. . . + a n Xˆ(n−1)) ∗ Q(X)
∗/
l i n k e d L i s t ∗ slowMultPolynome ( l i n k e d L i s t ∗ a , l i n k e d L i s t ∗ b )
{
l i n k e d L i s t ∗ temp1 = NULL;
l i n k e d L i s t ∗ r e s = zeroPolynome ( ) ;
int n = 0;
void a u x F u n c t i o n ( void∗ v )
{
l i n k e d L i s t ∗ temp2 = copyPolynome ( b ) ;
multMonomePolynome ( temp2 , ∗ ( double ∗ ) v , n ) ;
temp1 = addPolynome ( r e s , temp2 ) ;
d e st r o y P o l y n o m e ( r e s ) ;
d e st r o y P o l y n o m e ( temp2 ) ;
r e s = temp1 ;
n++;
}
l i n k e d L i s t A p p l y ( a , auxFunction ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Fo nc t io n a u x i l i a i r e pour l e sous−programme c i −d e s s o u s .
∗/
void m u l t M a i l l o n s ( l i n k ∗ l a , l i n k ∗ l b , l i n k e d L i s t ∗ r e s u l t )
{
pComplexe p ;
i f ( l a != NULL)
{
p = copyComplexe (
multComplexe (
∗ ( pComplexe ) l a −>data ,
∗ ( pComplexe ) l b−>d a t a ) ) ;
linkedListAppend ( r e su l t , p ) ;
m u l t M a i l l o n s ( l a −>next , l b−>next , r e s u l t ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
M u l t i p l i e e n t r e eux t o u s l e s c o e f f i c i e n t s ( c o m p l e x e s ) d e s monomes de
meme d e g r e , par exemple :
(1 + 2X + 4Xˆ2) e t (3 + X − 2Xˆ2) donnent
(1 ∗ 3) + (2 ∗ 1)X + (4 ∗ −2)Xˆ2
a e t b s o n t n e c e s s a i r e m e n t de meme d e g r e .
∗/
l i n k e d L i s t ∗ multMonomesPolynome ( l i n k e d L i s t ∗ a , linkedList ∗ b)
{
multMaillons ( l i n k e d L i s t G e t F i r st ( a ) ,
linke dListGetFirst(b) ,
l );
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
C o n v e r t i t un d o u b l e en p o i n t e u r su r complexe .
∗/
void∗ complexOfDouble ( void∗ v )

{
return copyComplexe ( makeAffComplexe ( ∗ ( double ∗ ) v , 0.0));
128
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
C o n v e r t i t un complexe en d o u b l e , supprime
l a p a r t i e imaginaire .
∗/
void∗ doubleOfComplexe ( void∗ v )

{
return makeDouble ( reComplexe ( ∗ ( pComplexe ) v ) ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e t r u i t un nombre complexe .
∗/
void d e st r o y Co m p l e x e ( void∗ v )
{
f r e e ( ( pComplexe) v ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a p r e m ie r p u i s a n c e de 2 s u p e r i e u r e ou e g a l a x .
∗/
i n t puiss2UpperThan ( i n t x )
{
int k = 2;
while ( k < x )
k ∗= 2 ;
return k ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Ajo u t e d e s z e r o s non s i g n i f i c a t i f s a l a f i n de l de s o r t e
que sa t a i l l e d e v ie nne k .
∗/
void r e s i z e L i s t ( l i n k e d L i s t ∗ l , i n t k )
{
while ( l i n k e d L i s t G e t S i z e ( l ) < k )
linkedListAppend ( l ,
copyComplexe ( makeAffComplexe ( 0 . 0 , 0.0)));
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
M o d ifie l e s t a i l l e s d e s deux l i s t e s de s o r t e
qu ’ on p u i s s e l e u r a p p l i q u e r une FFT
∗/
void c a l i b r a t e L i s t s ( l i n k e d L i s t ∗ l 1 , l i n k e d L i s t ∗ l 2 )
{
int k ;
int length = l i n k e d Li st Ge t S i z e ( l 1 ) +
linkedListGetSize ( l2 ) − 1;
k = puiss2UpperThan ( l e n g t h ) ;
r e s i z e L i s t ( l1 , k ) ;
r e s i z e L i s t ( l2 , k ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
M u l t i p l e a e t b en p a s s a n t par une t r a n s f o r m e e de f o u r i e r .
∗/
l i n k e d L i s t ∗ multPolynome ( l i n k e d L i s t ∗ a , l i n k e d L i s t ∗ b )
{
l i n k e d L i s t ∗ ca , ∗ cb , ∗ f f t a , ∗ f f t b , ∗ prodab , ∗ resComplexe , ∗ r e s ;
c a = l i n k e d L i s t M a p ( a , complexOfDouble ) ;
cb = l i n k e d L i s t M a p ( a , complexOfDouble ) ;
129
c a l i b r a t e L i s t s ( ca , cb ) ;
f f t a = FFT( c a ) ;
f f t b = FFT( cb ) ;
prodab = multMonomesPolynome ( f f t a , f f t b ) ;
r e sCo m p l e x e = i n v e r se F F T ( prodab ) ;
r e s = l i n k e d L i s t M a p ( resComplexe , doubleOfComplexe ) ;
l i n k e d L i s t D e s t r o y ( ca , d e st r o y Co m p l e x e ) ;
l i n k e d L i s t D e s t r o y ( cb , d e st r o y Co m p l e x e ) ;
l i n k e d L i s t D e s t r o y ( f f t a , d e st r o y Co m p l e x e ) ;
l i n k e d L i s t D e s t r o y ( f f t b , d e st r o y Co m p l e x e ) ;
l i n k e d L i s t D e s t r o y ( prodab , d e st r o y Co m p l e x e ) ;
l i n k e d L i s t D e s t r o y ( resComplexe , d e st r o y Co m p l e x e ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
double h o r n e r L i n k ( l i n k ∗ l n k , double x )
{
i f ( l n k == NULL)
return 0 . 0 ;
return ∗ ( double ∗ ) l n k−>d a t a +
x∗ h o r n e r L i n k ( l n k−>next , x ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
double e v a l u a t e P o l y n o m e ( l i n k e d L i s t ∗ l , double x )
{
return h o r n e r L i n k ( l i n k e d L i s t G e t F i r s t ( l ) , x ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t main ( )
{
l i n k e d L i s t ∗ l = simpleListPolynome ( 1 0 0 0 0 ) ;
// makeArrayPolynome ( d , 5 ) ;
l i n k e d L i s t ∗m, ∗n , ∗p ;
p r i n t f ( ” m u l t i p l i c a t i o n \n” ) ;
m = slowMultPolynome ( l , l ) ;
p r i n t f ( ” done\n” ) ;
// printPolynome (m) ;
p r i n t f ( ” m u l t i p l i c a t i o n \n” ) ;
n = multPolynome ( l , l ) ;
p r i n t f ( ” done\n” ) ;
// printPolynome (m) ;
multRealPolynome ( n , −1);
p = addPolynome (m, n ) ;
p r i n t f ( ” t e s t : % l f \n” , e v a l u a t e P o l y n o m e ( p , 1.0));
d e st r o y P o l y n o m e ( l ) ;
d e st r o y P o l y n o m e (m ) ;
d e st r o y P o l y n o m e ( n ) ;
return 0 ;
}
130
A.14 Tas binomiaux
Voici une implémentation des tas binomiaux, j’ai commencé par écrire quelques fonctions de gestion de listes chaı̂nées,
et j’ai crée deux classes pour représenter respectivement les arbres binomiaux et les tas binomiaux.
/∗ ∗
Implements a v e r y s i m p l e l i n k e d l i s t , each l i n k p o i n t s t o item
o f t y p e T and r e f e r e n c e s t h e n e x t l i n k . O( 1 ) o p e r a t i o n s a r e
g e t t i n g t h e f i r s t l i n k ’ s d a t a or t h e second ’ s l i n k r e f e r e n c e ,
or d e l e t i n g t h e f i r s t e l e m e nt . Each f u n c t i o n s m o d ifying t h e
l i n k i n g returns a pointer to the f i r s t l i n k of the l i s t .
∗/
public c l a s s L i n k e d L i s t <T>
{
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te T d a t a ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te L i n k e d L i s t <T> n e x t ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
C r e a t e s a one e l e m e nt list .
∗/
public L i n k e d L i s t (T d a t a )
{
this . data = data ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
C r e a t e s a one l i n k l i s t and appends t h e second
paramter t o t h i s l i s t .
∗/
public L i n k e d L i s t (T data , L i n k e d L i s t <T> n e x t )

{
this ( data ) ;
this . next = next ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Modifies the data .
∗/
public void s e t D a t a (T d a t a )
{
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Appends a l i s t to the first l i n k of the current
list .
∗/
public void s e t N e x t ( L i n k e d L i s t <T> n e x t )

{
this . next = next ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
R e t r iv e s the data o f the first link .
∗/
public T g e t D a t a ( )
{
return d a t a ;
}
131
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Returns t h e second item o f t h e l i s t , doesn ’ t change
the l i n k i n g
∗/
public L i n k e d L i s t <T> g e t N e x t ( )
{
return n e x t ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
D e l e t e from t h i s l i s t t h e l i n k which t h e a d r e s s i s l ,
returns the l i s t whithout l .
∗/
public L i n k e d L i s t <T> d e l e t e L i n k ( L i n k e d L i s t <T> l )

{
i f ( t h i s == l )
return g e t N e x t ( ) ;
setNext ( getNext ( ) . d e l e t e L i n k ( l ) ) ;
return t h i s ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Returns a S t r i n g r e p r e s e n t a t i o n of the list .
∗/
public S t r i n g t o S t r i n g ( )
{
return ” −> ” + d a t a +
( ( n e x t != n u l l ) ? n e x t . t o S t r i n g ( ) : ”X” ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te s t a t i c <K> L i n k e d L i s t <K> r e v e r s e A c c ( L i n k e d L i s t <K> l i n k ,

L i n k e d L i s t <K> a c c )
{
i f ( l i n k == n u l l )
return a c c ;
L i n k e d L i s t <K> n e x t = l i n k . g e t N e x t ( ) ;
l i n k . setNext ( acc ) ;
return r e v e r s e A c c ( next , l i n k ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Adds t h e l i n k l i n f r o n t o f t h i s l i s t , returns
the l i s t thus created .
∗/
public L i n k e d L i s t <T> addFront ( L i n k e d L i s t <T> l )

{
l . setNext ( this ) ;
return l ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Adds t h e item o i n f r o n t o f t h i s l i s t , returns
t h e new l i s t .
∗/
public L i n k e d L i s t <T> addFront (T o )

{
return addFront (new L i n k e d L i s t <T>(o ) ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
R e v e r se t h e o r d e r o f t h e it e m s o f t h e l i s t . Returns t h e
132
new l i s t .
∗/
public L i n k e d L i s t <T> r e v e r s e ( )
{
return r e v e r s e A c c ( th i s , n u l l ) ;
}
c l a s s Bi n o m i a l Tr e e<T extends Comparable<T>>

implements Comparable<Bi n o m i a l Tr e e<T>>
{
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te i n t o r d e r ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te T d a t a ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te L i n k e d L i s t <Bi n o m i a l Tr e e<T>> s o n s ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public Bi n o m i a l Tr e e (T d a t a )
{
order = 0;
sons = null ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public Bi n o m i a l Tr e e <T> f u s i o n ( Bi n o m i a l Tr e e<T> o t h e r )

{
i f ( g e t D a t a ( ) . compareTo ( o t h e r . g e t D a t a ( ) ) > 0 )
return o t h e r . f u s i o n ( t h i s ) ;
i f ( o r d e r != o t h e r . g e t O r d e r ( ) )
System . o u t . p r i n t l n ( ” I n v a l i d a r g u m e n t s” ) ;
s o n s = ( s o n s == n u l l ) ?
new L i n k e d L i s t <Bi n o m i a l Tr e e<T>>( o t h e r ) :
s o n s . addFront ( o t h e r ) ;
o r d e r ++;
return t h i s ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public i n t g e t O r d e r ( )
{
return o r d e r ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public T g e t D a t a ( )
{
return d a t a ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public BinomialHeap<T> e x t r a c t S o n s ( )
{
return new BinomialHeap<T>(( s o n s == n u l l ) ?
null :
sons . r e v e r s e ( )
);
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
public i n t compareTo ( Bi n o m i a l Tr e e <T> o t h e r )

{
i f ( order < other . getOrder ( ) )
return −1;
i f ( o r d e r == o t h e r . g e t O r d e r ( ) )
133
return 0 ;
return 1 ;
}
}
/∗ ∗
Implements a p r i o r i t y queue which a l l o w s t h e f o l l o w i n g o p e r a t i o n s ,
each one i n a i n O( l o g n ) time .
− i n s e r t i n g an item
− g e t t i n g t h e minimum k e y item
− d e l e t i n g t h e minimum k e y item
− merging two q u e u e s
I t has been implemented by a l e x a n d r e−m e sl e . com f o r j a v a 1 . 5
∗/
public c l a s s BinomialHeap<T extends Comparable<T>>

{
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te L i n k e d L i s t <Bi n o m i a l Tr e e<T>> b i n o m i a l T r e e s ;
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
C r e a t e s an empty queue .
∗/
public BinomialHeap ( )
{
binomialTrees = null ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
C r e a t e s a one item queue .
∗/
public BinomialHeap (T d a t a )
{
b i n o m i a l T r e e s = new L i n k e d L i s t <Bi n o m i a l Tr e e <T>>
(new Bi n o m i a l Tr e e <T>( d a t a ) ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
BinomialHeap ( L i n k e d L i s t <Bi n o m i a l Tr e e <T>> l )

{
binomialTrees = l ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Returns t r u s i f and o n l y i f t h e queue doesn ’ t c o n t a i n
any item .
∗/
public boolean isEmpty ( )

{
return b i n o m i a l T r e e s == n u l l ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
p r i v a te s t a t i c <K extends Comparable<K>> L i n k e d L i s t <Bi n o m i a l Tr e e <K>>

f i n d M i n L i n k ( L i n k e d L i s t <Bi n o m i a l Tr e e <K>> l i n k ,
L i n k e d L i s t <Bi n o m i a l Tr e e <K>> a c c )
{
i f ( l i n k == n u l l )
return a c c ;
K linkData = l i n k . getData ( ) . getData ( ) ;
K accData = a c c . g e t D a t a ( ) . g e t D a t a ( ) ;
i f ( l i n k D a t a . compareTo ( accData ) < 1 )
return f i n d M i n L i n k ( l i n k . g e t N e x t ( ) , l i n k ) ;
return f i n d M i n L i n k ( l i n k . g e t N e x t ( ) , a c c ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
134
/∗ ∗
Returns t h e item wich has t h e minimum k e y .
∗/
public T getMin ( )
{
L i n k e d L i s t <Bi n o m i a l Tr e e<T>> minNode = f i n d M i n L i n k ( b i n o m i a l T r e e s ,
binomialTrees ) ;
i f ( minNode == n u l l )
return n u l l ;
return minNode . g e t D a t a ( ) . g e t D a t a ( ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
D e l e t e s t h e minimum k e y item .
∗/
public void d e l e t e M i n ( )
{
L i n k e d L i s t <Bi n o m i a l Tr e e<T>> minLink =
findMinLink ( binomialTrees , b i n o m i a l Tr e es ) ;
b i n o m i a l T r e e s = b i n o m i a l T r e e s . d e l e t e L i n k ( minLink ) ;
BinomialHeap<T> s o n s = minLink . g e t D a t a ( ) . e x t r a c t S o n s ( ) ;
f u si o n ( sons ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
D e l e t e s t h e minimum k e y item .
∗/
public void i n s e r t (T c )
{
f u s i o n (new BinomialHeap<T>(c ) ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗ ∗
Adds t o t h e c u r r e n t queue a l l t h e item o f t h e queue b .
Use i t o n l y i f b doesn ’ t have t o used a g a in .
∗/
public void f u s i o n ( BinomialHeap<T> b )

{
binomialTrees =
c l e a n ( merge ( b i n o m i a l T r e e s , b . b i n o m i a l T r e e s ) ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/

merge ( L i n k e d L i s t <Bi n o m i a l Tr e e <K>> l 1 ,
L i n k e d L i s t <Bi n o m i a l Tr e e <K>> l 2 )
{
i f ( l 1 == n u l l )
return l 2 ;
i f ( l 2 == n u l l )
return l 1 ;
i f ( l 1 . g e t D a t a ( ) . compareTo ( l 2 . g e t D a t a ( ) ) <= 0 )
{
l 1 . s e t N e x t ( merge ( l 1 . g e t N e x t ( ) , l 2 ) ) ;
return l 1 ;
}
else
return merge ( l 2 , l 1 ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/

c l e a n ( L i n k e d L i s t <Bi n o m i a l Tr e e <K>> l )
{
i f ( l == n u l l )
return n u l l ;
i f ( l . g e t N e x t ( ) == n u l l )
return l ;
135
Bi n o m i a l Tr e e<K> f i r s t = l . g e t D a t a ( ) ;
Bi n o m i a l Tr e e<K> s e c o n d = l . g e t N e x t ( ) . g e t D a t a ( ) ;
i f ( f i r s t . g e t O r d e r ( ) != s e c o n d . g e t O r d e r ( ) )
{
l . setNext ( c l e a n ( l . getNext ( ) ) ) ;
return l ;
}
i f ( l . g e t N e x t ( ) . g e t N e x t ( ) == n u l l )
return new L i n k e d L i s t <Bi n o m i a l Tr e e<K>>
( f i r s t . f u si o n ( second ) ,
l . getNext ( ) . getNext ( ) ) ;
Bi n o m i a l Tr e e<K> t h i r d = l . g e t N e x t ( ) . g e t N e x t ( ) . g e t D a t a ( ) ;
i f ( f i r s t . g e t O r d e r ( ) == t h i r d . g e t O r d e r ( ) )
{
l . setNext ( c l e a n ( l . getNext ( ) ) ) ;
return l ;
}
else
return new L i n k e d L i s t <Bi n o m i a l Tr e e<K>>
( f i r s t . f u si o n ( second ) ,
l . getNext ( ) . getNext ( ) ) ;
}
/∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗/
/∗
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
{
BinomialHeap<I n t e g e r > h = new BinomialHeap<I n t e g e r > ();
f o r ( i n t i = 1 ; i < 3000 ; i ++)
h . i n s e r t (new I n t e g e r ( ( i ∗ i ∗ i ∗ i ∗ i ∗ i ∗ i ) % 1 2 7 ) ) ;
w h i l e ( ! h . isEmpty ( ) )
{
System . o u t . p r i n t ( h . getMin ( ) + ” −> ” ) ;
h . deleteMin ( ) ;
}
}
∗/
136
A.15 AVL
#include ” a v l . h”
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Noeud de l ’ABR.
∗/
typedef s tr u ct nd
{
/∗
k e y e s t l a c l e du noeud c o u r a nt .
∗/
i n t key ;
/∗
p o i n t e u r v e r s l ’ e l e m e nt de c l e k e y
∗/
void∗ d a t a ;
/∗
h a u t e u r du sous−a r b r e :
0 s i ce noeud e s t une f e u i l l e .
∗/
int height ;
/∗
P o int e u r v e r s l e sous−a r b r e d r o i t .
∗/
s tr u ct nd ∗ l e f t ;
/∗
P o int e u r v e r s l e sous−a r b r e gauche .
∗/
s tr u ct nd ∗ r i g h t ;
} node ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a h a u t e u r de l ’ a r b r e de r a c i n e l ,
−1 s i l e s t v i d e .
∗/
i n t g e t H e i g h t ( node ∗ l )
{
i f ( l == NULL)
return −1;
return l −>h e i g h t ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne l a p l u s grande d e s deux v a l e u r s i et j .
∗/
i n t max ( i n t i , i n t j )
{
if ( i < j )
return j ;
return i ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Met a j o u r l a h a u t e u r de l a r a c i n e l en f o n c t i o n d e s
h a u t e u r s d e s r a c i n e s d e s deux sous−a r b r e s .
∗/
void s e t H e i g h t ( node∗ l )
{
i f ( l != NULL)
{
l −>h e i g h t = 1 + max( g e t H e i g h t ( l −> l e f t ) , g e t H e i g h t ( l −>r i g h t ) ) ;
}
137
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Cree un noeud c o nt e na nt l a donnee data ,
a ya nt pour sous−a r b r e gauche l e t
pour sous−a r b r e d r o i t r .
∗/
node∗ n o d e Cr e a t e ( i n t ( ∗ getKey ) ( void ∗ ) , node∗ l , void∗ data , node∗ r )

{
node∗ n = ( node ∗ ) m a l l o c ( s i z e o f ( node ) ) ;
i f ( n == NULL)
error ( ) ;
n−>d a t a = d a t a ;
n−> l e f t = l ;
n−>r i g h t = r ;
n−>key = getKey ( d a t a ) ;
setHeight (n ) ;
return n ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Retourne un a v l v i d e
∗/
a v l ∗ a v l C r e a t e ( i n t ( ∗ getKey ) ( void ∗ ) , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
a v l ∗ a = ( a v l ∗) malloc ( s i zeo f ( a v l ) ) ;
if (! a)
error ( ) ;
a−>getKey = getKey ;
a−>f r e e D a t a = f r e e D a t a ;
a−>r o o t = NULL;
return a ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
F a i t de f r e e D a t a l a f o n c t i o n de d e s t r u c t i o n d e s donnees .
∗/
void a v l S e t F r e e F u n c t i o n ( a v l ∗ a , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
a−>f r e e D a t a = f r e e D a t a ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Affiche toutes l e s c l e s du sous−a r b r e de r a c i n e n dans
l ’ ordre c r o i s s a n t .
∗/
void n o d e P r i n t K e y s ( node ∗ n )
{
i f (n)
{
printf (”(” );
n o d e P r i n t K e y s ( n−> l e f t ) ;
p r i n t f ( ” , %d , ” , n−>key ) ;
n o d e P r i n t K e y s ( n−>r i g h t ) ;
printf (”)” );
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e pour t o u s l e s noeuds du sous−a r b r e de r a c i n e n
l a d i f f e r e n c e e n t r e l e s h a u t e u r s du sous−a r b r e d r o i t e t
gauche .
∗/
void n o d e P r i n t L e v e l s ( node∗ n )
{
i f (n)
138
{
printf (”(” );
n o d e P r i n t L e v e l s ( n−> l e f t ) ;
p r i n t f ( ” , %d , ” , g e t H e i g h t ( n−> l e f t )− g e t H e i g h t ( n−>r i g h t ) ) ;
n o d e P r i n t L e v e l s ( n−>r i g h t ) ;
printf (”)” );
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n d r o i t e de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e R i g h t ( node ∗ x )
{
node∗ y = x−> l e f t ;
node∗ b = y−>r i g h t ;
y−>r i g h t = x ;
x−> l e f t = b ;
setHeight (x ) ;
setHeight (y ) ;
return y ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n gauche de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e L e f t ( node ∗ x )
{
node∗ y = x−>r i g h t ;
node∗ b = y−> l e f t ;
y−> l e f t = x ;
x−>r i g h t = b ;
setHeight (x ) ;
setHeight (y ) ;
return y ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n gauche−d r o i t e de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e L e f t R i g h t ( node ∗ x )
{
x−> l e f t = r o t a t e L e f t ( x−> l e f t ) ;
return r o t a t e R i g h t ( x ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
E f f e c t u e une r o t a t i o n d r o i t e −gauche de l ’ a r b r e de r a c i n e x ,
∗/
node∗ r o t a t e R i g h t L e f t ( node ∗ x )
{
x−>r i g h t = r o t a t e R i g h t ( x−>r i g h t ) ;
return r o t a t e L e f t ( x ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
R e e q u i l i b r e l ’ a r b r e de r a c i n e x , r e t o u r n e l a r a c i n e de
l ’ a r b r e a p r e s r e e q u i l i b r a g e . On p a r t du p r i n c i p e
que l e s h a u t e u r s d e s sous−a r b r e s d r o i t e t gauche d i f f e r e n t
de au p l u s 1 .
∗/
node∗ b a l a n c e ( node∗ x )
139
{
if ( x != NULL)
{
setHeight (x ) ;
i f ( g e t H e i g h t ( x−> l e f t ) + 2 == g e t H e i g h t ( x−>r i g h t ) )
{
i f ( g e t H e i g h t ( x−> l e f t ) + 1 == g e t H e i g h t ( x−>r i g h t −>r i g h t ) )
return r o t a t e L e f t ( x ) ;
else
return r o t a t e R i g h t L e f t ( x ) ;
}
i f ( g e t H e i g h t ( x−> l e f t ) == g e t H e i g h t ( x−>r i g h t ) + 2 )
{
i f ( g e t H e i g h t ( x−>l e f t −> l e f t ) == g e t H e i g h t ( x−>r i g h t ) + 1 )
return r o t a t e R i g h t ( x ) ;
else
return r o t a t e L e f t R i g h t ( x ) ;
}
}
return x ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
I n s e r e l a donnee v dans l ’ a r b r e de r a c i n e n
e t r e e q u i l i b r e l ’ a r b r e , r e t o u r n e l a r a c i n e de
l ’ arbre apres inse rtion et re e q u i l i b r a g e .
∗/
node∗ n o d e I n s e r t ( i n t ( ∗ key ) ( void ∗ ) , node∗ n , void∗ v )

{
i f ( n == NULL)
return n o d e Cr e a t e ( key , NULL, v , NULL ) ;
i f ( key ( v ) == n−>key )
return n ;
i f ( key ( v ) < n−>key )
n−> l e f t = n o d e I n s e r t ( key , n−>l e f t , v ) ;
else
n−>r i g h t = n o d e I n s e r t ( key , n−>r i g h t , v ) ;
return b a l a n c e ( n ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
I n s e r e l a donnee v dans l ’ a r b r e a , O( l o g n ) .
∗/
void a v l I n s e r t ( a v l ∗ a , void∗ v )
{
a−>r o o t = n o d e I n s e r t ( a−>getKey , ( node ∗ ) a−>r o o t , v ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Affiche les c l e s de l ’AVL a dans l ’ o r d r e c r o i s s a n t , O(n )
∗/
void a v l P r i n t K e y s ( a v l ∗ a )
{
n o d e P r i n t K e y s ( ( node ∗ ) a−>r o o t ) ;
p r i n t f ( ” \n” ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
A f f i c h e pour chaque noeud l a d i f f e r e n c e e n t r e l e s hauteurs
d e s sous−a r b r e s d r o i t e t gauche de l ’AVL.
∗/
void a v l P r i n t L e v e l s ( a v l ∗ a )
{
n o d e P r i n t L e v e l s ( ( node ∗ ) a−>r o o t ) ;
p r i n t f ( ” \n” ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
140
/∗
Retourne l a donnee de c l e k s i elle s e t r o u v e dans l e sous−a r b r e
de r a c i n e n , NULL sino n .
∗/
void∗ f i n d N o d e ( node∗ n , i n t k )
{
i f ( n == NULL)
return NULL;
i f ( n−>key == k )
return n−>d a t a ;
i f ( k < n−>key )
return f i n d N o d e ( n−>l e f t , k ) ;
else
return f i n d N o d e ( n−>r i g h t , k ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
NULL sinon , O( l o g n)
∗/
void∗ a v l F i n d ( a v l ∗ a , i n t x )
{
return f i n d N o d e ( ( node ∗ ) a−>r o o t , x ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
F a i t p o i n t e r ∗max v e r s l e noeud de c l e maximale dans
l e sous−a r b r e de r a c i n e n , d e t a c h e l e noeud ∗max de l ’ a r b r e
∗/
node∗ removeMax ( node∗ n , node ∗∗ max )

{
i f ( n == NULL)
{
∗max = NULL ;
return NULL ;
}
i f ( n−>r i g h t == NULL)
{
∗max = n ;
return NULL ;
}
n−>r i g h t = removeMax ( n−>r i g h t , max ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
F a i t p o i n t e r ∗min v e r s l e noeud de c l e minimale dans
l e sous−a r b r e de r a c i n e n , d e t a c h e l e noeud ∗min de l ’ a r b r e
∗/
node∗ removeMin ( node∗ n , node ∗∗ min )

{
i f ( n == NULL)
{
∗ min = NULL ;
return NULL ;
}
i f ( n−> l e f t == NULL)
{
∗ min = n ;
return NULL ;
}
n−> l e f t = removeMin ( n−>l e f t , min ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Supprime l e noeud de c l e k du sous−a r b r e de r a c i n e n ,
141
a p p l i q u e l a f o n c t i o n de d e s t r u c t i o n a l a donnee de ce noeud ,
e t r e t o u r n e l a r a c i n e de l ’ a r b r e a p r e s l a s u p p r e s s i o n .
∗/
node∗ removeNode ( node ∗ n , i n t k , void ( ∗ f r e e D a t a ) ( void ∗ ) )

{
node∗ p ;
i f ( n == NULL)
return NULL;
i f ( k == n−>key )
{
p = NULL ;
n−> l e f t = removeMax ( n−>l e f t , &p ) ;
i f ( p == NULL)
n−>r i g h t = removeMin ( n−>r i g h t , &p ) ;
i f ( p != NULL)
{
p−> l e f t = n−> l e f t ;
p−>r i g h t = n−>r i g h t ;
}
f r e e D a t a ( n−>d a t a ) ;
free (n ) ;
return b a l a n c e ( p ) ;
}
i f ( k < n−>key )
n−> l e f t = removeNode ( n−>l e f t , k , f r e e D a t a ) ;
else
n−>r i g h t = removeNode ( n−>r i g h t , k , f r e e D a t a ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
void avlRemove ( a v l ∗ a , i n t k )
{
a−>r o o t = removeNode ( ( node ∗ ) a−>r o o t , k , a−>f r e e D a t a ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
P l a c e dans l a l i s t e c h a i n e e l t o u t e s l e s donnees
du sous−a r b r e de r a c i n e n dans l ’ o r d r e c r o i s s a n t .
∗/
void n o d e To L i st ( node∗ n , l i n k e d L i s t ∗ l )
{
i f ( n != NULL)
{
n o d e To L i st ( n−>l e f t , l ) ;
l i n k e d L i s t A p p e n d ( l , n−>d a t a ) ;
n o d e To L i st ( n−>r i g h t , l ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
l i nk e dL i s t ∗ avlToList ( avl ∗ a )
{
n o d e To L i st ( ( node ∗ ) a−>r o o t , l ) ;
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
D e t r u i t t o u s l e s noeuds du sous−a r b r e de r a c i n e n ,
a p p l i q u e l a f o n c t i o n de d e s t r u c t i o n f r a t o u t e s l e s
donnees du sous−a r b r e .
∗/
142
void n o d e D e st r o y ( node∗ n , void ( ∗ f r ) ( void ∗ ) )
{
i f ( n != NULL)
{
n o d e D e st r o y ( n−>l e f t , f r ) ;
n o d e D e st r o y ( n−>r i g h t , f r ) ;
f r ( n−>d a t a ) ;
free (n ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
∗/
void a v l D e s t r o y ( a v l ∗ a )
{
n o d e D e st r o y ( ( node ∗ ) a−>r o o t , a−>f r e e D a t a ) ;
free (a );
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Pour t e s t e r les algorithmes
∗/
{
f r e e ( ( int ∗) i ) ;
}
i n t g e t I n t K e y ( void∗ i )
{
return ∗ ( ( i n t ∗ ) i ) ;
}
void doNothing ( )
{
i n t main ( )
{
int i ;
int∗ d ;
linkedList ∗ l ;
l i n k ∗ m;
a v l ∗ a = a v l Cr e a t e ( getIntKey , d e s t r o y I n t ) ;
f o r ( i = 0 ; i < 40 ; i ++)
{
d = ( int ∗) malloc ( s i zeo f ( int ) ) ;
∗d = i ;
avlInsert (a , d ) ;
}
f o r ( i = 0 ; i < 40 ; i +=5)
avlRemove ( a , i ) ;
l = avlToList ( a ) ;
f o r (m = l i n k e d L i s t G e t F i r s t ( l ) ; m != NULL ; m = m−>n e x t )
p r i n t f ( ”%d −> ” , ∗ ( i n t ∗ ) (m−>d a t a ) ) ;
p r i n t f ( ” \n” ) ;
l i n k e d L i s t D e s t r o y ( l , doNothing ) ;
avlSetFreeFunction( a , de stroyInt ) ;
avlDestroy (a ) ;
return 0 ;
}
143
A.16 Knapsack par recherche exhaustive
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
I n s t a n c e d ’ un p r o b l e m e de knapSack
∗/
typedef s tr u ct
{
/∗
nombre t o t a l d ’ o b j e t s
∗/
long n b I t e m s ;
/∗
t a b l e a u de nombreObjets e l e m e n t s c o nt e na nt l e p o i d s de
chaque e l e m e nt
∗/
long ∗ w e i g h t s ;
/∗
t a b l e a u de nombreObjets e l e m e n t s c o nt e na nt l a v a l e u r de
chaque e l e m e nt
∗/
long ∗ v a l u e s ;
/∗
Poids maximum qu ’ i l est p o s s i b l e de p l a c e r dans l e sa c Ã dos .
∗/
long maxWeight ;
} knapSack ;
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
knapSack∗ knapSackMake ( long nbItems , long maxWeight )

{
knapSack∗ k = ( knapSack ∗ ) m a l l o c ( s i z e o f ( knapSack ) ) ;
k−>n b I t e m s = n b I t e m s ;
k−>maxWeight = maxWeight ;
k−>w e i g h t s = ( long ∗ ) m a l l o c ( s i z e o f ( long ) ∗ n b I t e m s ) ;
i f ( k−>w e i g h t s == NULL)
exit (0);
k−>v a l u e s = ( long ∗ ) m a l l o c ( s i z e o f ( long ) ∗ n b I t e m s ) ;
i f ( k−>v a l u e s == NULL)
exit (0);
return k ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void k n a p S a c k S e t I t e m ( knapSack∗ k , long i n d e x , long v a l u e , long w e i g h t )

{
∗ ( k−>w e i g h t s + i n d e x ) = w e i g h t ;
∗ ( k−>v a l u e s + i n d e x ) = v a l u e ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
long knapSackValue ( knapSack∗ i n s t a n c e , l i n k e d L i s t ∗ s o l u t i o n )

{
long r e s = 0 ;
void i n c r V a l u e ( void∗ i )
{
r e s += ∗ ( i n s t a n c e −>v a l u e s + ∗ ( ( long ∗ ) i ) ) ;
}
linkedListApply ( solution , incrValue ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
long knapSackWeight ( knapSack∗ i n s t a n c e , linkedList ∗ solution )

{
long r e s = 0 ;
144
void i n c r V a l u e ( void∗ i )
{
r e s += ∗ ( i n s t a n c e −>w e i g h t s + ∗ ( ( long ∗ ) i ) ) ;
}
linkedListApply ( solution , incrValue ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t k n a p S a c k I s F e a s i b l e ( knapSack∗ i n s t a n c e , l i n k e d L i s t ∗ s o l u t i o n )
{
return knapSackWeight ( i n s t a n c e , s o l u t i o n )
<= i n s t a n c e −>maxWeight ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void k n a p S a c k P r i n t I n s t a n c e ( knapSack∗ k )
{
long l = 0 ;
while ( l < k−>n b I t e m s )
{
p r i n t f ( ” ( i = %3l d , v = %3l d , w = %3 l d ) \ n” , l ,
∗ ( k−>v a l u e s + l ) , ∗ ( k−>w e i g h t s + l ) ) ;
l ++;
}
p r i n t f ( ”max w e i g h t = %l d \n” , k−>maxWeight ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void k n a p S a c k D e st r o y ( knapSack∗ k )
{
f r e e ( k−>v a l u e s ) ;
f r e e ( k−>w e i g h t s ) ;
free (k );
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void∗ l i n k e d L i s t C o p y ( void∗ l )
{
void∗ i d ( void∗ i )
{
return i ;
}
return l i n k e d L i s t M a p ( ( l i n k e d L i s t ∗ ) l , id ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void k n a p S a c k P r i n t S o l u t i o n ( l i n k e d L i s t ∗ l )
{
void p r i n t I n d e x ( void∗ i )
{
p r i n t f ( ”%l d ” , ∗ ( ( long ∗ ) i ) ) ;
}
linkedListApply ( l , printIndex ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
l i n k e d L i s t ∗ k n a p S a c k L i s t I n i t ( long n )
{
linkedList ∗ l ;
i f ( n <= 0 )
l = linkedListCreate ( ) ;
else
{
l = knapSackListInit (n − 1);
long ∗ p = m a l l o c ( s i z e o f ( long ) ) ;
i f ( p == NULL)
exit (0);
∗p = n −1;
linkedListAppend ( l , p ) ;
}
return l ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
145
void k n a p S a c k P r i n t P a r t i e s ( l i n k e d L i s t ∗ l )
{
void k n a p S a c k P r i n t V o i d S o l u t i o n ( void∗ l )
{
printf (” [ ” );
k n a p S a c k P r in tSo lu ti on ( ( l i n k e d L i s t ∗) l ) ;
p r i n t f ( ” ] \ n” ) ;
}
linkedListApply ( l , knapSackPrintVoidSolution ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void doNothing ( void∗ v )

{
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void d e s t r o y I n t ( void∗ v )
{
f r e e ( ( int ∗) v ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void k n a p S a c k D e s t r o y P a r t i e s ( l i n k e d L i s t ∗ l )
{
void d e s t r o y P a r t i e ( void∗ p )
{
l i n k e d L i s t D e s t r o y ( ( l i n k e d L i s t ∗ ) p , doNothing ) ;
}
linkedListDestroy ( l , destroyPartie );
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
linkedList ∗ parties ( linkedList ∗ l )

{
linkedList ∗ res = linkedListCreate ( ) ;
l i n k e d L i s t ∗ p a r t i e sW i t h o u t X , ∗ p a r t i e sW i t h X ;
i f ( l i n k e d L i s t G e t S i z e ( l ) == 0 )
{
linkedListAppend ( res , l i n k e d L i st Cr e a t e ( ) ) ;
}
else
{
link ∗ x = linkedListUnlinkFirst( l );
partiesWithoutX = p a r t i e s ( l ) ;
p a r t i e sW i t h X = l i n k e d L i s t M a p ( p a r t i e sW i t h o u t X , l i n k e d L i s t C o p y ) ;
void appendX ( void∗ d a t a )
{
l i n k e d L i s t A p p e n d ( ( l i n k e d L i s t ∗ ) data , x−>d a t a ) ;
}
l i n k e d L i s t A p p l y ( p a r t i e sW i t h X , appendX ) ;
linkedListAppendLink ( l , x ) ;
l i n k e d L i st Co n c a t ( res , partiesWithoutX ) ;
l i n k e d L i s t C o n c a t ( r e s , p a r t i e sW i t h X ) ;
l i n k e d L i s t D e s t r o y ( p a r t i e sW i t h X , doNothing ) ;
l i n k e d L i s t D e s t r o y ( p a r t i e sW i t h o u t X , doNothing ) ;
}
p r i n t f ( ”−> 2ˆ%d\n” , l i n k e d L i s t G e t S i z e ( l ) ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
l i n k e d L i s t ∗ k n a p S a c k B r u t e F o r c e S o l v e ( knapSack∗ k )
{
l i n k e d L i s t ∗ i n d e x e s = k n a p S a c k L i s t I n i t ( k−>n b I t e m s ) ;
linkedList ∗ a ll So l ut i on s = par ties ( indexes ) ;
l i n k e d L i s t ∗ b e s t S o l u t i o n S e e n = NULL;
linkedListGetFirst( allSolutions ) ;
p r i n t f ( ”−> s u b s e t s g e n e r a t e d . \ n Tr y i n g t o f i n d t h e b e s t s o l u t i o n \n” ) ;
void f i n d B e s t ( void∗ v )
{
l i n k e d L i s t ∗ l = ( l i n k e d L i s t ∗) v ;
i f ( knapSackIsFeasible (k , l )
&& ( b e s t S o l u t i o n S e e n == NULL | |
knapSackValue ( k , l ) > knapSackValue ( k , b e s t S o l u t i o n S e e n ) ) )
146
bestSolutionSeen = l ;
}
linkedListApply ( al l So lu ti ons , findBest ) ;
p r i n t f ( ” −> Done . \ n D e s t r o y i n g t h e s u b s e t s \n” ) ;
void∗ c o p y I n t ( void∗ i )
{
void∗ v = m a l l o c ( s i z e o f ( long ) ) ;
i f ( v == NULL)
exit (0);
∗ ( ( long ∗ ) v ) = ∗ ( ( long ∗ ) i ) ;
return v ;
}
b e st S o l u t i o nSeen = linkedListMap ( bestSolutionSeen , copyInt ) ;
void d e s t r o y T h e L i n k e d L i s t ( void∗ v )
{
l i n k e d L i s t D e s t r o y ( ( l i n k e d L i s t ∗) v , d e s t r o y I n t ) ;
}
l i n k e d Li st De st r oy ( a l l S o l u t i o n s , destroyTheLinkedList ) ;
p r i n t f ( ” −> Done . \ nThanks f o r y o u r p a t i e n c e . \ n” ) ;
return b e s t S o l u t i o n S e e n ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t main ( )
{
long t = 2 1 ;
knapSack∗ k = knapSackMake ( t , 4 0 ) ;
linkedList ∗ s ;
long l ;
f o r ( l = 0 ; l < k−>n b I t e m s ; l ++)
k n a p S a c k S e t I t e m ( k , l , ( l ∗ l ∗ l )%10 + 1 , ( l ∗ l ∗ l ∗ l )%10 + 1 ) ;
knapSackPrintInstance ( k ) ;
s = knapSackBruteForceSolve( k ) ;
knapSackPrintSolution ( s ) ;
p r i n t f ( ” \n” ) ;
l i n k e d L i s t D e s t r o y ( s , doNothing ) ;
k n a p S a c k D e st r o y ( k ) ;
return 0 ;
}
147
A.17 Prise en main de GLPK
i n t main ( )
{
LPX∗ l p = l p x c r e a t e p r o b ( ) ;
double c o e f f s [ 1 0 ] ;
i n t c o l s [ 1 0 ] , rows [ 1 0 ] ;
int k = 1;
l p x s e t o b j d i r ( l p , LPX MAX ) ;
l p x a d d c o l s ( lp , 3 ) ;
l p x s e t o b j c o e f ( lp , 1 , 4 ) ;
l p x s e t c o l b n d s ( l p , 1 , LPX LO , 0 . 0 , 0 . 0 ) ;
l p x ad d rows ( lp , 3 ) ;
l p x s e t r o w b n d s ( l p , 1 , LPX UP , 0 . 0 , 1 2 . ) ;
l p x s e t r o w b n d s ( l p , 2 , LPX UP , 0 . 0 , 3 . ) ;
l p x s e t r o w b n d s ( l p , 3 , LPX UP , 0 . 0 , 6 . ) ;
c o e f f s [ k ] = 3 . ; rows [ k ] = 1 ; c o l s [ k ] = 1 ; k++;
c o e f f s [ k ] = 0 . 6 ; rows [ k ] = 2 ; c o l s [ k ] = 1 ; k++;
c o e f f s [ k ] = 3 ; rows [ k ] = 2 ; c o l s [ k ] = 2 ; k++;
c o e f f s [ k ] = 2 . 8 ; rows [ k ] = 2 ; c o l s [ k ] = 3 ; k++;
c o e f f s [ k ] = 0 . 0 8 ; rows [ k ] = 3 ; c o l s [ k ] = 2 ; k++;
l p x l o a d m a t r i x ( l p , 9 , rows , c o l s , c o e f f s ) ;
p r i n t f ( ” f o n c t i o n o b e c t i f = %l f \n” , l p x g e t o b j v a l ( l p ) ) ;
f o r ( k = 1 ; k <= 3 ; k++)
p r i n t f ( ” x %d = % l f \n” , k , l p x g e t c o l p r i m ( l p , k ) ) ;
return 0 ;
}
148
A.18 Le plus beau métier du monde
#d ef i n e N 10
double sommeTab ( double∗ t , i n t n )

{
i f ( n == 0 )
return 0 . ;
return ∗ t + sommeTab ( t +1 , n − 1 ) ;
}
void q u e s t i o n 1 ( double ∗ n o t e s P a r t i e l , double∗ notesCC1 , double∗ notesCC2 )

{
double c o e f f s [ 4 ] ;
i n t rows [ 4 ] , c o l s [ 4 ] ;
LPX∗ l p ;
int k = 1;
lp = lpx create prob ( ) ;
l p x a d d c o l s ( lp , 3 ) ;
l p x s e t o b j c o e f ( l p , 1 , sommeTab ( n o t e s P a r t i e l , N) /N ) ;
l p x s e t o b j c o e f ( l p , 2 , sommeTab ( notesCC1 , N) /N ) ;
f o r ( k = 1 ; k <= 3 ; k++)
l p x s e t c o l b n d s ( l p , k , LPX DB , 0 . 0 , 1 . 0 ) ;
l p x s e t r o w b n d s ( l p , 1 , LPX UP , 0 . 0 , 1 . 0 ) ;
f o r ( k = 1 ; k <= 3 ; k++)
{
rows [ k ] = 1 ; c o l s [ k ]= k ; c o e f f s [ k ] = 1 . 0 ;
}
l px g et o bj v al ( lp ) ;
f o r ( k = 1 ; k <= 3 ; k++)
p r i n t f ( ” c o e f f %d i s %l f \n” , k , l p x g e t c o l p r i m ( l p , k ) ) ;
}

{
double c o e f f s [ 4 ] ;
i n t rows [ 4 ] , c o l s [ 4 ] ;
LPX∗ l p ;
int k = 1;
l p x a d d c o l s ( lp , 3 ) ;
l p x s e t o b j c o e f ( l p , 1 , sommeTab ( n o t e s P a r t i e l , N) /N ) ;
l p x s e t c o l b n d s ( l p , 1 , LPX DB , 0 . 5 , 1 . 0 ) ;
f o r ( k = 2 ; k <= 3 ; k++)
l p x s e t c o l b n d s ( l p , k , LPX DB , 0 . 1 , 1 . 0 ) ;
l p x s e t r o w b n d s ( l p , 1 , LPX UP , 0 . 0 , 1 . 0 ) ;
f o r ( k = 1 ; k <= 3 ; k++)
{
rows [ k ] = 1 ; c o l s [ k ]= k ; c o e f f s [ k ] = 1 . 0 ;
}
f o r ( k = 1 ; k <= 3 ; k++)
p r i n t f ( ” c o e f f %d i s %l f \n” , k , l p x g e t c o l p r i m ( l p , k ) ) ;
}

{
double c o e f f s [ 4 ∗ ( N+1) + 1 ] ;
i n t rows [ 4 ∗ ( N+1) + 1 ] , c o l s [ 4 ∗ ( N+1) + 1 ] ;
LPX∗ l p ;
int eleveIndex , c oe f f I n d e x = 1 , i ;
l p x a d d c o l s ( lp , 4 ) ;
l p x s e t o b j c o e f ( lp , 1 , 1 . ) ;
149
l p x s e t c o l b n d s ( l p , 1 , LPX FR , 0 . 0 , 0 . 0 ) ;
l p x s e t c o l b n d s ( l p , 2 , LPX DB , 0 . 5 , 1 . ) ;
l p x a d d r o w s ( l p , N+ 1 ) ;
f o r ( e l e v e I n d e x = 0 ; e l e v e I n d e x < N ; e l e v e I n d e x ++)
{
rows [ c o e f f I n d e x ]= e l e v e I n d e x + 1 ;
c o l s [ c oe f f I n d e x ]=1;
coeffs [ coeffIndex ] = 1.0 ;
c o e f f I n d e x ++;
c o e f f s [ c o e f f I n d e x ] = −∗( n o t e s P a r t i e l + e l e v e I n d e x ) ;
c o e f f s [ c o e f f I n d e x ] = −∗( notesCC1 + e l e v e I n d e x ) ;
c o e f f s [ c o e f f I n d e x ] = −∗( notesCC2 + e l e v e I n d e x ) ;
l p x s e t r o w b n d s ( l p , e l e v e I n d e x + 1 , LPX UP , 0 . 0 , 0.0);
}
f o r ( i = 2 ; i <= 4 ; i ++)
{
rows [ c o e f f I n d e x ] = N+1 ;
cols [ coeffIndex ] = i ;
coeffs [ coeffIndex ] = 1.0 ;
}
l p x s e t r o w b n d s ( l p , N+1 , LPX DB , 0 . 0 , 1 . 0 ) ;
l p x l o a d m a t r i x ( l p , c o e f f I n d e x − 1 , rows , c o l s , c o e f f s );
f o r ( i = 2 ; i <= 4 ; i ++)
p r i n t f ( ” c o e f f %d i s %l f \n” , i −1 , l p x g e t c o l p r i m ( l p , i ));
l p x p r i n t p r o b ( lp , ” q u e sti on 3 . lpx ” ) ;
}
i n t main ( )
{
double n o t e s P a r t i e l [N ] = { 1 0 , 1 3 , 2 , 4.5 , 9 , 12 , 16 , 8 , 5 , 12};
double notesCC1 [ N] = {11 , 16 , 11 , 8, 10 , 11 , 11 , 6 , 4 , 13};
double notesCC2 [ N] = { 9 , 18 , 7, 8, 11 , 3 , 13 , 10 , 7 , 19 };
p r i n t f ( ”QUESTION 1\n−−−−−−−−−−\n” ) ;
q u e s t i o n 1 ( n o t e s P a r t i e l , notesCC1 , notesCC2 );
return 0 ;
}
150
A.19 Prise en main de GMP
#include<gmp . h>
/∗
A f f i c h e l a t a b l e de m u l t i p l i c a t i o n de n , de 1 a t o .
n doit etre i n i t i a l i s e .
∗/
void a f f i c h e T a b l e M u l t i p l i c a t i o n ( mpz t n , long t o )

{
mpz t r e s ;
i f ( to > 0)
{
a f f i c h e T a b l e M u l t i p l i c a t i o n (n , to − 1 ) ;
mpz init ( res ) ;
mpz mul ui ( res , n , to ) ;
m p z o u t s t r (NULL, 1 0 , r e s ) ;
p r i n t f ( ” \n” ) ;
}
}
/∗
P l a c e b ˆn dans r e s . r e s d o i t e t r e initialise
∗/
void p u i s s a n c e ( mpz t b , mpz t n , mpz t r e s )

{
mpz t temp ;
i f ( ! mpz cmp ui ( n , 0 ) )
{
}
else
{
i f ( mpz divisible ui p (n , 2))
{
mpz t q ;
mpz t deux ;
mpz mul ( temp , b , b ) ;
mpz init (q ) ;
m p z i n i t s e t u i ( deux , 2 ) ;
m p z c d i v q ( q , n , deux ) ;
p u i s s a n c e ( temp , q , r e s ) ;
mpz clear (q ) ;
m p z c l e a r ( deux ) ;
}
else
{
mpz t nMoinsUn ;
m p z i n i t ( nMoinsUn ) ;
m p z s u b u i ( nMoinsUn , n , 1 ) ;
p u i s s a n c e ( b , nMoinsUn , temp ) ;
mpz mul ( r e s , temp , b ) ;
m p z c l e a r ( nMoinsUn ) ;
}
}
}
/∗
Fo nc t io n d ’ Ackermann. r e s d o i t e t r e i n i t i a l i s e .
A t t e n t i o n ! Ne d o i t e t r e u t i l i s e qu ’ a v e c d e s p e t i t e s valeurs !
∗/
void ackermann ( mpz t m, mpz t n , mpz t r e s )

{
i f ( ! mpz cmp ui (m, 0 ) )
{
mpz add ui ( res , n , 1 ) ;
}
else
{
mpz t mMoinsUn ;
m p z i n i t ( mMoinsUn ) ;
m p z s u b u i ( mMoinsUn , m, 1 ) ;
i f ( ! mpz cmp ui ( n , 0 ) )
{
151
mpz t un ;
m p z i n i t s e t u i ( un , 1 ) ;
ackermann ( mMoinsUn , un , res ) ;
m p z c l e a r ( un ) ;
}
else
{
mpz t nMoinsUn ;
mpz t a p p e l R e c u r s i f ;
mpz init ( appelRecursif ) ;
ackermann (m, nMoinsUn , a p p e l R e c u r s i f ) ;
ackermann ( mMoinsUn , a p p e l R e c u r s i f , r e s ) ;
mpz clear ( appelRecursif ) ;
}
m p z c l e a r ( mMoinsUn ) ;
}
}
/∗
A f f i c h e t o u t e s l e s images par l a f o n c t i o n d ’ Ackermann d e s c o u p l e s
{ ( i , j ) | 0 <= i <= m, 0 <= j <= n}
∗/
void a f f i c h e A c k e r m a n n ( long m, long n )

{
mpz t i ;
mpz t j ;
mpz t a ;
mpz init ( i ) ;
mpz init ( j ) ;
mpz init (a ) ;
mpz set ui ( i , 0) ;
while ( mpz cmp ui ( i , m) <= 0 )
{
mpz set ui ( j , 0) ;
while ( mpz cmp ui ( j , n ) <= 0 )
{
p r i n t f ( ” ackermann ( ” ) ;
m p z o u t s t r (NULL, 1 0 , i ) ;
printf (” , ” );
m p z o u t s t r (NULL, 1 0 , j ) ;
p r i n t f ( ”)=” ) ;
ackermann ( i , j , a ) ;
m p z o u t s t r (NULL, 1 0 , a ) ;
p r i n t f ( ” \n” ) ;
mpz add ui ( j , j , 1 ) ;
}
mpz add ui ( i , i , 1 ) ;
}
}
i n t main ( )
{
mpz t v ;
mpz t d i x ;
mpz t v i n g t ;
mpz init (v ) ;
m p z i n i t s e t u i ( dix , 1 0 ) ;
m p z i n i t s e t u i ( vingt , 2 0 ) ;
p u i ssan c e ( dix , vingt , v ) ;
afficheTableMultiplication (v , 10);
afficheAckermann(4 , 1 5 ) ;
return 0 ;
}
152
A.20 Algorithme d’Euclide étendu
#include<gmp . h>
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
C a l c u l e u e t v t e l s que au + bv = pgcd , ou pgcd e s t l e pgcd de a e t b .
Toutes l e s v a r i a b l e s d o i v e n t e t r e i n i t i a l i s e e s .
∗/
void b e z o u t ( mpz t a , mpz t b , mpz t u , mpz t v , mpz t pgcd )

{
i f ( ! mpz cmp ui ( b , 0 ) )
{
m p z se t ( pgcd , a ) ;
mpz set ui (u , 1 ) ;
mpz set ui (v , 0) ;
p r i n t f ( ”1 ∗ ” ) ;
m p z o u t s t r (NULL, 1 0 , a ) ;
printf (” + 0 ∗ 0 = ” );
m p z o u t s t r (NULL, 1 0 , a ) ;
}
else
{
mpz t q u o t i e n t ;
mpz t r e s t e ;
mpz t uRec ;
mpz t vRec ;
mpz t v F o i s Q u o t i e n t ;
mpz init ( quotient ) ;
mpz init ( res te ) ;
m p z i n i t ( uRec ) ;
m p z i n i t ( vRec ) ;
mpz init ( vFoisQuotient ) ;
mpz tdiv qr ( quotient , reste , a , b ) ;
m p z o u t s t r (NULL, 1 0 , a ) ;
printf (” = ” );
m p z o u t s t r (NULL, 1 0 , q u o t i e n t ) ;
printf (” ∗ ” );
m p z o u t s t r (NULL, 1 0 , b ) ;
printf (” + ” );
m p z o u t s t r (NULL, 1 0 , r e s t e ) ;
p r i n t f ( ” \n” ) ;
b e z o u t ( b , r e s t e , uRec , vRec , pgcd ) ;
m p z o u t s t r (NULL, 1 0 , uRec ) ;
printf (” ∗ ( ” );
m p z o u t s t r (NULL, 1 0 , b ) ;
printf (” ) + ” );
m p z o u t s t r (NULL, 1 0 , vRec ) ;
printf (” ∗ ( ” );
m p z o u t s t r (NULL, 1 0 , a ) ;
printf (” − ” );
m p z o u t s t r (NULL, 1 0 , q u o t i e n t ) ;
printf (” ∗ ” );
m p z o u t s t r (NULL, 1 0 , b ) ;
printf (”) = ” );
m p z o u t s t r (NULL, 1 0 , pgcd ) ;
p r i n t f ( ” \n” ) ;
m p z se t ( u , vRec ) ;
mpz mul ( v F o i s Q u o t i e n t , vRec , q u o t i e n t ) ;
mpz sub ( v , uRec , v F o i s Q u o t i e n t ) ;
m p z o u t s t r (NULL, 1 0 , u ) ;
printf (” ∗ ” );
m p z o u t s t r (NULL, 1 0 , a ) ;
printf (” + ” );
m p z o u t s t r (NULL, 1 0 , v ) ;
printf (” ∗ ” );
m p z o u t s t r (NULL, 1 0 , b ) ;
printf (” = ” );
m p z o u t s t r (NULL, 1 0 , pgcd ) ;
mpz clear ( quotient ) ;
mpz clear ( re st e ) ;
m p z c l e a r ( uRec ) ;
m p z c l e a r ( vRec ) ;
mpz clear ( vFoisQuotient ) ;
}
p r i n t f ( ” \n” ) ;
}
153
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
Im p l e m e nt a t io n de l a f o n c t i o n p h i d e f i n i e dans l e s u j e t
p h i ( a , b , 0) = b e t p h i ( a , b , n ) = p h i ( a + b , b , n−1).
Tous l e s p a r a m e t r e s d o i v e n t e t r e i n i t i a l i s e s .
∗/
void p h i ( mpz t a , mpz t b , mpz t n , mpz t r e s )

{
i f ( ! mpz cmp ui ( n , 0 ) )
{
m p z se t ( r e s , b ) ;
}
else
{
mpz t aPlusB ;
mpz t nMoinsUn ;
m p z i n i t ( aPlusB ) ;
mpz add ( aPlusB , a , b ) ;
p h i ( aPlusB , a , nMoinsUn , r e s ) ;
m p z c l e a r ( aPlusB ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
P l a c e dans r e s l e n−eme nombes de F i b o n a c c i .
Tous l e s p a r a m e t r e s d o i v e n t e t r e i n i t i a l i s e s .
∗/
void f i b o ( mpz t n , mpz t r e s )

{
mpz t z e r o ;
mpz t un ;
m p z i n i t s e t u i ( zero , 0 ) ;
m p z i n i t s e t u i ( un , 1 ) ;
p h i ( un , z e r o , n , r e s ) ;
mpz clear ( zero ) ;
m p z c l e a r ( un ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t main ( )
{
mpz t u ;
mpz t v ;
mpz t p ;
mpz t c e n t ;
mpz t centUn ;
mpz t F c e n t ;
mpz t FcentUn ;
mpz init (u ) ;
mpz init (v ) ;
mpz init (p ) ;
m p z i n i t s e t u i ( cent , 1 0 0 ) ;
m p z i n i t s e t u i ( centUn , 1 0 1 ) ;
m p z i n i t ( Fcent ) ;
m p z i n i t ( FcentUn ) ;
f i b o ( cent , Fcent ) ;
f i b o ( centUn , FcentUn ) ;
b e z o u t ( FcentUn , Fcent , u , v , p ) ;
mpz clear (u ) ;
mpz clear (v ) ;
mpz clear (p ) ;
mpz clear ( cent ) ;
m p z c l e a r ( centUn ) ;
m p z c l e ar ( Fcent ) ;
m p z c l e a r ( FcentUn ) ;
return 0 ;
}
154
A.21 Espaces Quotients
#include<gmp . h>
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
/∗
C a l c u l e u e t v t e l s que au + bv = pgcd , ou pgcd e s t l e pgcd de a e t b .
Toutes l e s v a r i a b l e s d o i v e n t e t r e i n i t i a l i s e e s .
∗/
void b e z o u t ( mpz t a , mpz t b , mpz t u , mpz t v , mpz t pgcd )

{
i f ( ! mpz cmp ui ( b , 0 ) )
{
m p z se t ( pgcd , a ) ;
mpz set ui (u , 1 ) ;
mpz set ui (v , 0) ;
}
else
{
mpz t q u o t i e n t ;
mpz t r e s t e ;
mpz t uRec ;
mpz t vRec ;
mpz t v F o i s Q u o t i e n t ;
mpz init ( quotient ) ;
mpz init ( res te ) ;
m p z i n i t ( uRec ) ;
m p z i n i t ( vRec ) ;
mpz init ( vFoisQuotient ) ;
mpz tdiv qr ( quotient , reste , a , b ) ;
b e z o u t ( b , r e s t e , uRec , vRec , pgcd ) ;
m p z se t ( u , vRec ) ;
mpz mul ( v F o i s Q u o t i e n t , vRec , q u o t i e n t ) ;
mpz sub ( v , uRec , v F o i s Q u o t i e n t ) ;
mpz clear ( quotient ) ;
mpz clear ( re st e ) ;
m p z c l e a r ( uRec ) ;
m p z c l e a r ( vRec ) ;
mpz clear ( vFoisQuotient ) ;
}
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t t r o u v e I n v e r s e ( mpz t v a l e u r , mpz t module , mpz t i n v e r s e )

{
mpz t u , v , pgcd ;
int r e s = 1;
mpz init (u ) ;
mpz init (v ) ;
m p z i n i t ( pgcd ) ;
b e z o u t ( v a l e u r , module , u , v , pgcd ) ;
i f ( ! mpz cmp ui ( pgcd , 1 ) )
m p z se t ( i n v e r s e , u ) ;
else
res = 0;
mpz clear (u ) ;
mpz clear (v ) ;
m p z c l e a r ( pgcd ) ;
return r e s ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
void e t u d i e E s p a c e Q u o t i e n t ( mpz t n )
{
mpz t i , phi , i n v e r s e I ;
mpz init ( i ) ;
mpz init ( phi ) ;
mpz init ( invers eI ) ;
mpz set ui ( i , 0) ;
m p z s e t u i ( phi , 0 ) ;
p r i n t f ( ”Z/ ” ) ;
m p z o u t s t r (NULL, 1 0 , n ) ;
p r i n t f ( ”Z : ” ) ;
while ( mpz cmp ( i , n ) )
{
p r i n t f ( ” \n” ) ;
155
m p z o u t s t r (NULL, 1 0 , i ) ;
i f ( trouveInverse ( i , n , inverseI ))
{
p r i n t f ( ” a pour i n v e r s e ” ) ;
m p z a d d u i ( phi , phi , 1 ) ;
mpz mod ( i n v e r s e I , i n v e r s e I , n ) ;
m p z o u t s t r (NULL, 1 0 , i n v e r s e I ) ;
}
else
p r i n t f ( ” ( non i n v e r s i b l e ) ” ) ;
mpz add ui ( i , i , 1 ) ;
}
p r i n t f ( ” \nOn a p h i ( ” ) ;
m p z o u t s t r (NULL, 1 0 , n ) ;
printf (”) = ” );
m p z o u t s t r (NULL, 1 0 , p h i ) ;
p r i n t f ( ” \n” ) ;
m p z a d d u i ( phi , phi , 1 ) ;
i f ( ! mpz cmp ( n , p h i ) )
p r i n t f ( ” Cet e n se m b l e e s t un c o r p s \n” ) ;
else
p r i n t f ( ” Cet e n se m b l e n e s t p a s un c o r p s \n” ) ;
}
/∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−∗/
i n t main ( )
{
mpz t t e s t ;
mpz init ( t es t ) ;
mpz init set ui ( test , 20);
etudieEspaceQuotient( t e s t ) ;
mpz clear ( te s t ) ;
return 0 ;
}
156
Annexe B
Rappels mathématiques
B.1 Sommations
Parmi les outils mathématiques permettant d’évaluer la complexité d’un algorithme se trouvent les sommations.
Commençons par rappeler quelques propriétés :
Xn
1. 1=n−p+1
i=p
n
X n−1
X n
X
2. ui = ( ui ) + un = up + ui
i=p i=p i=p+1
Xn n
X
3. (a.ui ) = a ui
i=p i=p
Xn Xn n
X Xn
4. (ai + b) = ai + b=( ai ) + (n − p + 1)b
i=p i=p i=p i=p
Xn Xn Xn
5. (ai + bi ) = ai + bi
i=p i=p i=p
n
X n+1
X n−1
X
6. ui = ui−1 = ui+1
i=p i=p+1 i=p−1
Xn Xm m X
X n
7. uij = uij
i=1 j=1 j=1 i=1
P
Bien que le soit prioritaire sur le + mais pas sur le ×, il usuel pour éviter toute confusion de rajouter des parenthèses,
même inutiles. Parmi les sommes que vous devez maı̂triser parfaitement figurent les deux suivantes :
n
X n(n + 1)
1. i= (série arithmétique)
i=1
2
n
X rn+1 − 1
2. ri = (série géométrique)
i=0
r−1
On se ramène souvent à ce type de formule en algorithmique.
B.1.1 Exercices
Calculer les sommes suivantes :
Xn
1. 2i + 1
i=1
157
n
X
2. (i + 1)2
i=1
n X
X i
3. ( j)
i=1 j=1
n X
X n
4. ( j)
i=1 j=i
n
X
5. i
i=p
n
X
6. ri
i=p
B.2 Ensembles
B.2.1 Définition
Définition B.2.1 Un ensemble est un regroupement en un tout d’objets. Etant donné un ensemble E, les objets
regroupés dans E sont appelés éléments de E.
On définit un ensemble notament en énumérant ses éléments et en les séparant par des virgules. Par exemple E =
{1, 2, 3, 4} définit un ensemble E contenant les éléments 1, 2, 3 et 4. Si e est un élément de E, on dit alors qu’il
appartient à E, noté e ∈ E.
Définition à l’aide d’un prédicat

On définit aussi un ensemble par une condition d’appartenance. Par exemple, E = {e|(e ∈ N ) ∧ (e ≤ 5)} définit
l’ensemble des éléments e vérifiant (e ∈ N ) ∧ (e ≤ 5), à savoir {0, 1, 2, 3, 4, 5}. Plus formellement,
Définition B.2.2 Soient P (x) un prédicat et E = {x|P (x)}, alors
x ∈ E ⇐⇒ P (x)
E = {x|P (x)} est alors l’ensemble E des éléments x vérifiant P (x).
Ensemble vide
F est le prédicat constant prenant toujours la valeur ”faux”.
Définition B.2.3 On note ∅ l’ensemble vide défini comme suit
∅ = {i|F }
∅ est l’ensemble auquel n’appartient aucun élément. L’ensemble vide peut être défini par tout prédicat constant étant
toujours faux. Par exemple,
∅ = {i|(i ∈ N ) ∧ (i = i + 1)}
B.2.2 Opérations ensemblistes

On définit sur les ensembles les opérations suivantes :
Définition B.2.4 L’union de deux ensembles A et B, notée ∪, est définie par A ∪ B = {x|(x ∈ A) ∨ (x ∈ B)}.
158
Un élément appartient à A ∪ B s’il appartient à A, ou s’il appartient à B. Par exemple,
{1, 3, 7, 8} ∪ {2, 4, 6, 8, 10} = {1, 2, 3, 4, 6, 7, 8, 10}
Définition B.2.5 L’intersection de deux ensembles A et B, notée ∩, est définie par A ∩ B = {x|(x ∈ A) ∧ (x ∈ B)}.
Un élément appartient à A ∩ B s’il appartient à A, et s’il appartient à B. Par exemple,
{1, 3, 4, 6, 7, 9, 10} ∩ {2, 4, 6, 8, 10, 12} = {4, 10}
Définition B.2.6 La différence de deux ensembles A et B, notée \ ou −, est définie par A \ B = {x|(x ∈ A) ∧ (x 6∈
B)}.
Un élément appartient à A \ B (ou A − B) s’il appartient à A, mais pas à B. Par exemple,
{1, 2, 3, 4, 6, 7, 8} \ {1, 2, 3} = {4, 6, 7, 8}
On note l’union de n ensembles E1 ∪ E2 ∪ . . . ∪ En de la façon suivante :

n
[
Ei
i=1
De même n
\
E1 ∩ E2 ∩ . . . ∩ En = Ei
i=1
B.2.3 Cardinal
Un ensemble est infini s’il contient un nombre infini d’éléments, sinon, on dit qu’il est fini.
Définition B.2.7 Le cardinal d’un ensemble fini E, noté |E| est le nombre d’éléments qu’il contient.
Par exemple, |∅| = 0, |{1, 2, 4}| = 3. Seul l’ensemble vide est de cardinal 0, un ensemble de cardinal 1 est appelé un
singleton, un ensemble de cardinal 2 est appelé une paire.
Propriété B.2.1 Le cardinal d’un ensemble a les propriétés suivantes :

– |A ∩ B| ≤ |A|
– |A ∩ B| ≤ |B|
– |A ∪ B| ≥ |A|
– A \ B ≤ |A|
– |A ∪ B| ≥ |B|
– |A ∪ B| ≤ |A| + |B|
– |A ∪ B| + |A ∩ B| = |A| + |B|
– Si A ∩ B = ∅, |A ∪ B| = |A| + |B|
– |P(E)| = 2|E|
B.2.4 n-uplets
Un n-uplet est un regroupement ordonné de n éléments non nécessairement distincts. On note X = (x1 , . . . , xn ) le
n-uplet composé des éléments x1 , . . . , xn , on les appelle composantes des E. Par exemple, (4, 8) est un 2-uplet, dit
aussi couple, et ((3, 2), (6, 12), (0, 3)) est un triplet composé des trois couples (3, 2), (6, 12) et (0, 3).
159
Produit cartésien
Définition B.2.8 Le produit cartésien de n ensembles E1 , . . . , En , noté E1 × . . . × En est l’ensemble de tous les
n-uplets (x1 , . . . , xn ) tels que ∀i ∈ {1, . . . , n}, xi ∈ Ei .
Par exemple,
{1, 2} × {a, b, c} = {(1, a), (2, a), (1, b), (2, b), (1, c), (2, c)}
Formellement,
E1 × . . . × En = {(x1 , . . . , xn )|∀i ∈ {1, . . . , n}, xi ∈ Ei }
B.2.5 Parties
Inclusion
Définition B.2.9 A est contenu dans B, noté A ⊂ B si et seulement si ∀e ∈ A, e ∈ B,
En d’autres termes si tout élément de A est aussi un élément de B. On dit aussi que A est un sous-ensemble de B,
que A est inclus dans B, ou encore que A est une partie de B.
Parties de E
Définition B.2.10 L’ensemble P(E) des parties de E, est défini par
P(E) = {e|e ⊂ E}
P(E) est donc l’ensemble de tous les ensembles inclus dans E. Par exemple, P({1, 2, 3}) = {{1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, ∅, {1, 2, 3
on remarque que P(E) est un ensemble d’ensembles. Prennez note du fait que ∅ est un sous-ensemble de tous les en-
sembles, y compris de lui-même, et que le seul ensemble contenu dans ∅ est ∅. A votre avis, que vaut P(∅) ? Cette
question vous amènera à distinuer ∅ de {∅}, qui est l’ensemble qui contient l’ensemble vide.
Exercice
Calculer P(∅), P({1, 2}), P({∅}).
Autre exercice
Soit f la fonction qui a un ensemble d’ensembles F et un élément x associe f (F, x) = {e ∪ {x}|e ∈ F }. Montrer que
P(E) = f (P(E − {x}), x) ∪ P(E − {x}). En déduire un algorithme récursif calculant P(E).
B.2.6 Définition
Définition B.2.11 Une relation f entre deux ensembles A et B est un sous-ensemble de A × B.
Etant donné deux éléments x ∈ A et y ∈ B, si (x, y) ∈ f , alors on dit que f associe y à x. L’ensemble des éléments
qui sont associés à x est {y|(x, y) ∈ f }.
Définition B.2.12 Une relation f entre deux ensembles A et B est une application si ∀a ∈ A, |{b|(a, b) ∈ f }| = 1
Plus explicitement, f est une application si à tout élément de A est associé exactement un élément de B. On dit alors
que f est une application de A dans B, ce qui se note f : A −→ B. On dit par abus de langage que A est l’ensemble
de départ et B l’ensemble d’arrivée. Pour tout a ∈ A, on note f (a) l’élément de B qui lui est associé. On dit que f (a)
est l’image de a par f et a un antécédent de f (a) par f .
Etant donné un ensemble E, il existe une application, appelée identité, et notée id, telle que tout élément à pour
image lui-même. Autrement dit : id : E −→ E, x 7→ x. La succession de symboles a 7→ b signifie que b est l’image de
a, donc x 7→ x signifie que x a pour image lui-même.
160
B.2.7 Composition
Etant donnés f : A −→ B et g : B −→ C, on définit l’application composée de g et f , notée g ◦ f , dite ”g rond f ”, et
définie par g ◦ f : A −→ C, x 7→ g(f (x)). Autrement dit, g ◦ f est une application de A dans C, qui à tout élément x
de A, associe l’élément g(f (x)) de C.
B.2.8 Classification des applications

Soit f : A −→ B,
Définition B.2.13 f est injective si
∀a ∈ A, ∀a′ ∈ A, f (a) = f (a′ ) ⇒ a = a′
f est injective si deux éléments distincts ne peuvent pas avoir la même image.
Définition B.2.14 f est surjective si

∀b ∈ B, ∃a ∈ A, f (a) = b
f est surjective si tout élément de l’ensemble d’arrivée a un antécedent.
Définition B.2.15 f est bijective si elle est à la fois injective et surjective.

f est bijective si tous les éléments de A et de B sont reliés deux à deux.
Propriété B.2.2 Soient A et B deux ensembles et f : A −→ B,

– Si f est injective, alors |A| ≤ |B|
– Si f est surjective, alors |A| ≥ |B|
– Si f est bijective, alors |A| = |B|
Cette propriété est très importante ! En dénombrement, lorsque le cardinal d’un ensemble est difficile à déterminer, on
passe par une bijection vers un autre ensemble dont il est davantage aisé de calculer le cardinal.
B.2.9 Application réciproque

Soit f : A −→ B une application bijective.
Théorème B.2.1 Il existe une unique fonction f −1 , appelée application réciproque de f, telle que pour tous x ∈ A,
y ∈ B tels que f (x) = y, on ait f −1 (y) = x.
On remarque que f ◦ f −1 = f −1 ◦ f = id.
B.3 Raisonnements par récurrence

B.3.1 Principe
Ce type de raisonnement ne s’applique que dans des propriétés faisant intervenir des nombres entiers. Par exemple,
“Quel que soit n ≥ 0, n2 − n est pair”. Pour prouver qu’une propriété est vérifiée quelle que soit la valeur de n, on
effectue une preuve par récurrence en procédant en deux temps :
– l’initialisation, On prouve que pour n = 0 (ou 1, ça dépend des cas), la propriété est vérifiée.
– l’hérédité, on prouve que si la propriété est vérifiée au rang n, alors elle l’est au rang n + 1.
161
B.3.2 Exemple
Montrons par récurrence sur n que “Quel que soit n ≥ 0, n2 − n est pair” :
– initialisation : , 02 − 0 est pair, c’est évident.
– hérédité : , supposons que n2 − n est pair, vérifions si (n + 1)2 − (n + 1) est pair lui aussi. Calculons
(n + 1)2 − (n + 1) = n2 + 2n + 1 − n − 1 = (n2 − n) + 2n
Comme (n2 −n) et 2n sont tous deux pairs, et que la somme de deux nombres pairs est paire, alors (n+1)2 −(n+1)
est pair.
Demandons-nous si 22 − 2 est pair, on sait d’après l’initialisation que 02 − 0 est pair. Posons n = 0, comme la propriété
est vérifiée au rang n, elle est, d’après l’hérédité, nécessairement vérifiée au rang n + 1, donc 12 − 1 est pair. Posons
n = 1, comme 12 − 1 est pair, la propriété est vérifiée au rang n, elle est, d’après l’hérédité, nécessairement vérifiée au
rang n + 1, donc 22 − 2 est pair. On peut généraliser ce raisonnement à n’importe quelle valeur de n.
B.3.3 Exercices
Exercice 10
Prouver par récurrence les propriétés suivantes :
1. Quel que soit n ≥ 0, n2 + n + 1 est impaire.
2. Soit (u) une suite définie par u0 = −2, un+1 = (1/2)un + 3, alors un < 6
8
3. Soit (u) une suite définie par u0 = −2, un+1 = (1/2)un + 3, alors un = 6 − (2n )
4. Soit (u) une suite définie par u0 = 2, un+1 = 2un − n, alors un = 2n + n + 1
n
X n(n + 1)
5. Pour tout n > 0, i=
i=1
2
n
X 1 − q n+1
6. Pour tout n ≥ 0, q 6= 1, qi =
i=0
1−q
n
X n(n + 1)(2n + 1)
7. Pour tout n > 0, i2 =
i=1
6
Dérivée de fonctions puissance n

On rappelle que (f g)′ = f ′ g + f g ′ et que f n est définie par (f n )(x) = [f (x)]n . Prouvez par récurrence que ∀n ∈ IN∗
(f n )′ = nf ′ (f n−1 )
Formule de Leibniz
On note f (n) la dérivée n-ième de f . Prouvez par récurrence la formule de Leibniz : ∀n ∈ IN∗
n
X
(f g)n = Cni f (i) g (n−i)
i=0
Dérivée de fonctions composées

On rappelle que f ◦g est défini par (f ◦g)(x) = f (g(x)) et que (f ◦g)′ = g ′ (f ′ ◦g). Etant donné un ensemble {f1 , . . . , fn }
de n fonctions, on note
ni=1 [fi ] = f1 ◦ . . . ◦ fn
la composition de ces fonctions. Démontrez par récurrence que
n
Y
( ni=1 [fi ])′ = [fi′ ◦ ( nj=i+1 [fj ])]
i=1
162
B.4 Analyse combinatoire
B.4.1 Factorielles
Pour tout n ≥ 0, le nombre n!, appelé ”factorielle n”, est défini par récurrence à l’aide des relations suivantes :
– 0! = 1
– n! = n × (n − 1)!
Y n
On a donc n! = i avec le cas particulier 0! = 1.
i=1
B.4.2 Arrangements
Définition B.4.1 Soient n et p tels que 0 ≤ p ≤ n, on note Apn , et on lit ”A n p” le nombre
n!
(n − p)!
B.4.3 Combinaisons
Définition B.4.2 Soient n et p tels que 0 ≤ p ≤ n, on note Cnp , et on lit ”C n p” le nombre
n!
p!(n − p)!
Propriété B.4.1 Les égalités suivantes sont vérifiées pour tous k et n tels que 0 ≤ k ≤ n,
1
– Cni = Ain
p!
– Cn0 = 1
– Cn1 = n
– Cnp = Cnn−p
p−1
– pCnp = nCn−1
p p−1 p
– Cn = Cn−1 + Cn−1
Xn
– Cni = 2n
i=0
n
X
– (a + b)n = Cni ai bn−i
i=0
n−1
X
– Cip−1 = Cnp
i=p−1
B.4.4 Triangle de Pascal

Le triangle de Pascal est un tableau triangulaire de taille infinie dont les lignes sont indicées par n et les colonnes par
p, les indices commençant à 0. Les seules case du trianles renseignées sont celles dont les indices vérifient 0 ≤ p ≤ n.
Les valeurs se trouvant à la ligne d’indice n et la colonne d’indice p du triangle de Pascal est Cnp , on a ainsi
(n, p) p= 0 1 2 3 4 5 6 ...
n= 0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1
6 1 6 15 20 15 6 1
... ... ... ... ... ... ... ... ...
163
Vous remarquez que la propriété Cn0 = 1 traduit le fait que la première colonne ne comporte que des 1. Comme chaque
ligne est symétrique alors Cnp = Cnn−p . Pour chaque ligne, le premier élément est 1, donc la symétrie fait que le dernier
p−1 p
est 1 aussi. La propriété Cnp = Cn−1 + Cn−1 traduit le fait que chaque élément Cnp ne se trouvant pas dans la première
p
colonne ou sur la diagonale est la somme de celui qui est au dessus Cn−1 et de celui qui est juste à gauche de ce dernier
p−1
Cn−1 . Si on somme les éléments sur chaque ligne, on obtient des puissances successives de 2 :
X n
(n, p) p= 0 1 2 3 4 5 6 ... Cnp
p=0
n= 0 1 20
1 1 1 21
2 1 2 1 22
3 1 3 3 1 23
4 1 4 6 4 1 24
5 1 5 10 10 5 1 25
6 1 6 15 20 15 6 1 26
... ... ... ... ... ... ... ... ... ...
n
X
Cette propriété se traduit Cni = 2n . L’identité remarquable (a + b)n s’écrit à l’aide des coefficients su triangle de
i=0
Pascal. Par exemple,
(a + b)3 = a3 + 3a2 b + 3ab2 + b3
Vous remarquez que le développement de (a+b)3 s’ecrit avec un polynome à deux variable dont la somme des exposants
de chaque terme est 3, chaque terme est donc de la forme ai b3−i . Les coefficients devant chaque termes sont issus de
la ligne d’indice 3 du triangle de Pascal, à savoir (1, 3, 3, 1), autrement dit (C30 , C31 , C32 , C33 ). Donc
3
X
(a + b)3 = C3i ai bn−i
i=0
On a plus généralement que
n
X
(a + b)n = Cni ai bn−i
i=0
Par exemple,
(a + b)4 = a4 + 4a3 b + 6a2 b2 + 4ab3 + b4

Le soin de le démontrer par récurrence vous est laissé.
B.4.5 Liens avec les ensembles

Le nombre de façons d’ordonner n éléments distincts est donnée par n! (la preuve vous est laissé en exercice).
Propriété B.4.2 Le nombre de sous-ensembles à k éléments d’un ensemble E à n éléments, à savoir |{x|(x ⊂
E) ∧ (|x| = k)}| est donné par Cnk .
On le démontre par récurrence sur n,
– si n = 0, le seul ensemble à 0 éléments est ∅, son seul sous-ensemble est ∅, donc
|{x|(x ⊂ ∅) ∧ (|x| = 0)}| = |{∅}| = 1 = C00
– Supposons que pour tout ensemble E ′ à n − 1 ≥ 0 éléments, et tout k ′ ∈ {0, . . . , n − 1},
′
|{x|(x ⊂ E ′ ) ∧ (|x| = k ′ )}| = Cn−1
k
Considérons un ensemble E à n ≥ 1 éléments et une valeur k ∈ {0, . . . , n}, montrons que le cardinal de
P = {x|(x ⊂ E) ∧ (|x| = k)}
est Cnk
164
– Si k ∈ {1, . . . , n−1}, choisissons un élément arbitraire e ∈ E, cet élément existe nécessairement car |E| = n ≥ 1.
On décompose {x|(x ⊂ E) ∧ (|x| = k)} en deux ensembles P1 et P2 . P1 est l’ensemble des sous-ensembles de
E à k éléments qui contiennent e, défini par
P1 = {x|(x ⊂ E) ∧ (|x| = k) ∧ (e ∈ x)}

P ′ est celui des sous-ensembles à k éléments qui ne contiennent pas e,
P2 = {x|(x ⊂ E) ∧ (|x| = k) ∧ (e 6∈ x)}

On remarque que P1 ∪ P2 = P et que P1 ∩ P2 = ∅, donc |P | = |P1 | + |P2 |. Comme P2 est l’ensemble des
sous-ensembles à k éléments de E − {e}, on le redéfinit de la sorte :
P2 = {x|(x ⊂ E − {e}) ∧ (|x| = k)}

k
Comme |E − {e}| = n − 1 et k ∈ {1, . . . , n − 1}, alors par hypothèse de récurrence, |P2 | = Cn−1 . Par ailleurs,
′ ′
chaque élement x de P1 se décompose de la sorte : x = x ∪ {e} où x est un ensemble à (k − 1) éléments ne
contenant pas e. Donc
P1 = {x′ ∪ {e}|(x′ ⊂ E − {e}) ∧ (|x′ | = k − 1)}

Il a donc autant d’élément dans P1 que de sous-ensembles à k−1 éléments de E−{e}. Comme |E−{e}| = n−1 et
k−1 k k−1
(k −1) ∈ {0, . . . , n−2}, alors par hypothèse de récurrence, on a |P1 | = Cn−1 . De ce fait |P | = Cn−1 +Cn−1 = Cnk .
– Dans le cas où k = 0 et n ≥ 1, on remarque que
P = {x|(x ⊂ E) ∧ (|x| = 0)} = {∅}

et que par conséquent |P | = |{∅}| = 1 = Cn0
– Il nous reste à traiter le cas où k = n et n ≥ 1, on remarque que
P = {x|(x ⊂ E) ∧ (|x| = |E|)} = {E}

et que par conséquent |P | = |{E}| = 1 = Cnn .
On a bien
{x|(x ⊂ E) ∧ (|x| = k)} = Cnk

Pour tout k ∈ {0, . . . , n}.
Etant donné un ensemble E à n éléments, dénombrons les parties de E, ce qui revient à calculer |P(E)|. Pour ce faire,
on décompose P(E) en n + 1 sous-ensembles Pk (E), k ∈ {0, . . . , n}, définis comme suit
Pk (E) = {e|(e ⊂ E) ∧ (|e| = k)}

n
[
On remarque que pour tout e ⊂ E, e ∈ P|e| (E), donc P(E) ⊂ Pk (E). Réciproquement, pour tout k ∈ {0, . . . , n},
k=0
n
[
tout élément de Pk (E) est, par définition, une partie de E, donc Pk (E) ⊂ P(E). On déduit de cette double
k=0
inclusion que
n
[
P(E) = Pk (E)
k=0
Deux ensembles Pk (E) et Pk′ (E) tels que k 6= k ′ sont nécessairements disjoints(si ça vous semble pas évident, cherchez
un contre-exemple et vous comprendrez pourquoi...). Donc
n
[ n
X
| Pk (E)| = |Pk (E)|
k=0 k=0
165
Si cette propriété ne vous parle pas, démontrez-la par récurrence en utilisant le fait que si A ∩ B = ∅, alors |A ∩ B| =
Xn Xn
|A| + |B|. Nous avons démontré que ∀k ∈ {0, . . . , n}, |Pk (E)| = Cnk . Donc |Pk (E)| = Cnk = 2n . Le nombre
k=0 k=0
de parties d’un ensemble à n éléments est donc 2n . Il vous est possible, de vérifier ce résultat par récurrence, le
raisonnement est analogue à celui employé pour prouver que |{x|(x ⊂ E) ∧ (|x| = k)}| = Cnk , mais en plus facile.
B.5 Exercices récapitulatifs

B.5.1 Echauffement
Démontrer avec la méthode la plus appropriée les propositions suivantes :
– Cn0 = 1
– Cn1 = n
– Cnp = Cnn−p
p−1
– pCnp = nCn−1
p−1 p
– Cnp = Cn−1 + Cn−1
Xn
– Cni = 2n
i=0
n
X
– (a + b)n = Cni ai bn−i
i=0
n−1
X
– Cip−1 = Cnp
i=p−1
B.5.2 Formule de Poincaré

Le but de cet exercice est de prouver la formule de Poincaré :
n
[ n
X X \
| Ei | = (−1)i+1 ( |Ei |)
i=1 i=1 e∈Iin i∈e
En notant Ikn l’ensemble des sous-ensembles de {1, . . . , n} à k éléments, formellement : Ikn = {e ⊂ {1, . . . , n} tel que |e| =
k}
1. Réecrivez la formule de Poincaré avec n = 1
3. Soient A = {1, 3, 5, 6} et B = {1, 2, 3, 4}. Calculez |A ∪ B| en utilisant la propriété |A ∪ B| = |A| + |B| − |A ∩ B|.
5. Soit C = {6, 7, 8}, utilisez la formule de Poincaré pour calculer |A ∪ B ∪ C|.
6. On considère n+1 ensembles {E1 , . . . En+1 }. Supposons la formule de Poincaré vérifiée vérifiée au rang n. Donnez
alors une relation entre
n+1
[
| Ei |
i=1
et
n
X X \
(−1)i+1 ( |Ei |)
i=1 e∈Iin i∈e
7. Utilisez les résultats des questions précédentes pour prouver par récurrence la formule de Poincaré.
166
B.5.3 La moulinette à méninges
Soient A et B deux ensembles finis de cardinaux respectifs m et n.
1. Combien existe-t-il de relations entre A et B ? (Bijection avec les parties de l’ensemble A × B)
2. Combien existe-t-il d’applications de A dans B ? (Raisonnez par récurrence)
3. Combien existe-t-il d’applications bijectives de A dans B ? (une bijection)
4. Combien existe-t-il de k-uplets d’éléments de A ? (démerdez-vous)
5. Combien existe-t-il de k-uplets d’éléments distincts de A ?
6. Combien existe-t-il d’applications injectives de A dans B ? (raisonnez par récurrence)
7. Combien existe-t-il de façon de partitionner un ensemble E de cardinal n en 3 sous-ensembles ? C’est-à-dire de
déterminer 3 ensembles A, B et C tels que A ∪ B ∪ C = E, A ∩ B = ∅, A ∩ C = ∅ et B ∩ C = ∅. (bijection)
8. Une application est croissante au sens large si ∀x, y ∈ A, x < y =⇒ f (x) ≤ f (y). Combien existe-t-il d’applications
croissantes au sens large de A dans B (supposés ordonnés) ? (une bijection)
9. Une application est croissante au sens strict si ∀x, y ∈ A, x < y =⇒ f (x) < f (y). Combien existe-t-il d’applica-
tions croissantes au sens large de A dans B ? (plus difficile, bijection...)
10. Combien existe-t-il de façon de partitionner un ensemble E de cardinal n > 3 en 3 sous-ensembles non-vides ?
(bijections + poincaré)
11. Soit f : A −→ A, un point fixe de f est un élément x de A tel que f (x) = x. Combien existe-t-il de bijection
sans point fixe ? (vraiment difficile, utilisez la formule de Poincaré puis le binôme de Newton)
167
Bibliographie
[1] Simon Singh. The code book : the evolution of secrecy from Mary, Queen of Scots, to quantum cryptography. 1999.
[2] Thomas Cormen, Charles Leiserson, and Ronald Rivest. Introduction to algorithms. Dunod, 1992.
[3] Chrétienne P. Beauquier D., Berstel J. Eléments d’algorithmique. Masson, 1992.
[4] http://webpages.ull.es/users/jriera/Docencia/AVL/AVLtreeapplet.htm.
[5] Vasek Chvatal. Linear Programming. Freeman, 1983.
[6] http://www.gnu.org/software/glpk/.
[7] http://www.lmbe.seu.edu.cn/CRAN/doc/packages/glpk.pdf.
[8] Johnson D Garey M. Computers and Intractability. 1979.
[9] Hackademy Journal.
[12] http://www.gnupg.org/(fr)/documentation/guides.html.
[13] http://www.gnupg.org/gph/en/manual.pdf.
[14] http://gmplib.org/.
[15] http://gmplib.org/#DOC.
168

0229 Formation Algorithmie Cryptographie PDF

Transféré par

Droits d'auteur :

Formats disponibles

0229 Formation Algorithmie Cryptographie PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

0229 Formation Algorithmie Cryptographie PDF

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique

1 Complexité des algorithmes 6

A Corrigés des programmes 99

B Rappels mathématiques 157

Complexité des algorithmes

1.1 Borne asymptotique supérieure

Définition 1.1.1 un ∈ O(vn ) si ∃N ∈ IN, ∃k ∈ IR, ∀n ≥ N, un ≤ k.vn

1.2 Mesure de temps d’exécution

1.2.1 Algorithmes en temps constant, O(1)

1.2.3 Algorithmes de complexité logarithmique, O(logn)

1.2.4 Algorithmes de complexité quadratique O(n2 )

1.2.5 Algorithmes de complexité O(n.logn)

1.2.6 Algorithmes de complexité exponentielle O(k n ), k > 1

1.2.7 Algorithmes de complexité polynomiale O(nk ), k fixé

Exercice 3 - Tri par sélection

Exercice 4 - Hauteur minimale d’un arbre binaire

2.1 Invariants de boucle

On choisit comme invariant de boucle la propriété a = bq + r.

2.2.2 Fin de l’exemple

2.2.3 Un autre exemple

Exercice 2 - Plus grand élément

Exercice 3 - Tri par insertion

Démontrer la terminaison et la validité de triInsertion.

Exercice 4 - Tri à bulle

A l’itération i de l’algorithme, la boucle imbriquée effectue n − (i + 1) + 1 = n − i itérations. On détermine donc

Exercice 6 - Tris quadratiques

2. Quelle est la complexité de mystery ?

Exercice 8 - Tranche minimale

Nous souhaitons mettre au point un algorithme de recherhe de la tranche minimale.

3.1 Sous-programmes récursifs

Observons bien la procédure countdown :

avec le cas particulier 0! = 1. On observe que

n! = [1 × . . . × (n − 1)] × n = [(n − 1)!] × n

Exercice 1 - Opérations arithmétiques entières

1. Quelle relation arithmétique utilise-t-il ?

Exercice 2 - La fonction mystery

1. Que fait cette fonction ?

3.2 Sous-programmes récursifs terminaux

Prouvons par récurrence sur n que puissanceT (a, b, n) = abn .

Exercice 3 - Récursion terminale

Exercice 5 - Applications des itérateurs

Exercice 6 - Itérateurs et aspirine

Exercice 7 - Itérateurs et nombres de Fibonacci

ajoute(4, listeV ide())

ajoute(3, ajoute(4, listeV ide()))

Cette fonction retourne la somme des éléments de l.

Exercice 8 - Prise en main

3.4 Exemple de calcul de complexité d’un algorithme récursif

3.4.2 Résolution exacte

3.4.3 Vérification par récurrence

Exercice 11 - Suite de Fibonacci

Exercice 13 - Pavage avec des L

3.4.5 L’heure du code

Exercice 14 - Echauffement : représentation des complexes

Exercice 15 - Une bibliothèque de listes chaı̂nées

link ∗ linkedListGetFirst( linkedList ∗ l );

link ∗ linkedListUnlinkFirst( linkedList ∗ l ) ;

void l i n k e d L i s t A p p l y ( l i n k e d L i s t ∗ l , void ( ∗ f ) ( void ∗ ) ) ;

void l i n k e d L i s t D e s t r o y ( l i n k e d L i s t ∗ , void ( ∗ f r ) ( void ∗ ) ) ;