Algorithmique et Programmation - Lycée Carnotgondor-carnot.fr/oooo/Info/Diap-INFO-SUP-Cours-ALGO-PROG-Algo.pdf · Algorithmique Algorithmique et Programmation Germain Gondor LYCÉE

Algorithmique

Algorithmique et Programmation

Germain Gondor

LYCÉE CARNOT (DIJON), 2016 - 2017

Informatique pour tous (MPSI & PCSI) ALGO-PROG-Algo Algorithmique Année 2016 - 2017 1 / 79

Sommaire1 Introduction à l’algorithmique

Structure de l’informatiquePoser proprement le problèmePremière approche méthodologiqueDonnées et constantesVariablesOpérateursExpressionsInstructionsFonctions

2 Analyse des algorithmesProblématiqueCas de l’industrieTester n’est pas prouverConjecture de SyracuseTerminaison d’un algorithmeProblème de correctionInvariant de boucleCas des algorithmes récursifsComplexité en temps et en mémoireOpérations élémentairesClasses de complexitéMéthodes de calcul de la compléxité


Introduction à l’algorithmique

Sommaire

1 Introduction à l’algorithmiqueIntroductionPseudo-langage algorithmiquePrincipes de bonne programmation

2 Analyse des algorithmes


Introduction à l’algorithmique Introduction

Sommaire

1 Introduction à l’algorithmiqueIntroduction

Structure de l’informatiquePoser proprement le problèmePremière approche méthodologique

Pseudo-langage algorithmiquePrincipes de bonne programmation




Structure de l’informatique

L’informatique est structurée par quatre concepts :• l’algorithme : méthode opérationnelle permettant de résoudre un

problème,• la machine : système physique doté de fonctionnalités,• le langage : moyen de communication entre l’informaticien et la

machine,• l’information : données symboliques susceptibles d’être traitées

par une machine.On se propose ici d’acquérir une méthodologie permettant de mettresur le papier la résolution d’un problème bien posé. Pour cela, nousutiliserons un ensemble d’instructions dont l’application permet de ré-soudre le problème en un nombre fini d’opérations.



Exemple 1 : permutation de deux voitures

PROBLÈME: permuter deux voitures sur un parking de trois placesnumérotées P1, P2 et P3, sans gêner la circulation. La voiture A est surl’emplacement P2, la voiture B est sur l’emplacement P3.

Avant permutation Après permutation



Un premier algorithme naïf peut être le suivant :1 déplacer la voiture B de l’emplacement P3 à P1

2 déplacer la voiture A de l’emplacement P2 à P3

3 déplacer la voiture B de l’emplacement P1 à P2



Avant permutation

⇒Avant permutation

Avant permutation⇒

Avant permutation




Avant permutation


Avant permutation




Avant permutation

Avant permutation

⇒Avant permutation




Avant permutation


Avant permutation



Plusieurs imprévus peuvent se présenter :• l’emplacement P1 est-il initialement libre?• les voitures A et B sont-elles en état de marche?• y-a-t-il de la circulation pendant l’échange des emplacements?• l’emplacement P3 est-il pris pendant l’échange?

Cela est dû à un problème en partie mal posé. Précisons les choses.



• Données :Parking de trois emplacements, numérotés P1, P2 et P3.Deux voitures en état de marche : A sur P3, et B sur P2.

• Hypothèses générales : Un seul conducteur réalise lapermutation.Celui-ci a son permis de conduire et les clés des deux voitures.Lorsqu’une voiture est en mouvement, aucune autre voiture nevient sur le parking.Une éventuelle autre voiture ne reste qu’un temps fini sur unemplacement.

• Résultats : La voiture B est sur l’emplacement P2.La voiture A est sur l’emplacement P3.



L’algorithme est alors le suivant :

1 aller au volant de la voiture B (emplacement P3)2 répéter attendre jusqu’à emplacement P1 libre3 déplacer la voiture B de l’emplacement P3 à P1

4 aller au volant de la voiture A (emplacement P2)5 répéter attendre jusqu’à emplacement P3 libre6 déplacer la voiture A de l’emplacement P2 à P3

7 aller au volant de la voiture B (emplacement P1)8 répéter attendre jusqu’à emplacement P2 libre9 déplacer la voiture B de l’emplacement P1 à P2



Exemple 2 : résolution d’une équation

PROBLÈME: résoudre l’équation a.x = b.

L’algorithme peut être le suivant :

Algorithm 1

1: si a <> 0 alors2: la solution est x = b/a3: sinon4: Il n’y a pas de solution5: fin si



Là encore, l’énoncé du problème n’est pas satisfaisant :• quels sont les domaines de définition de x , a, b ?• les variables sont elles réelles, complexes, des vecteurs, des

matrices?• qui est l’inconnue?



Reformulons le problème :

Soient a ∈ R∗ et b ∈ R donnés. Trouver x tel que a.x = b.

L’algorithme est alors le suivant :

Algorithm 2

entrée: (a,b) ∈ R∗ × Rrésultat: x=b/a

1: x=b/a2: renvoi: x



Première approche méthodologique

Un bon algorithme doit :• être clair• fournir un résultat satisfaisant• être adapté au public visé

Pour cela, il est nécessaire de :• poser correctement le problème• rechercher une méthode de résolution• écrire l’algorithme par raffinements successifs


Introduction à l’algorithmique Pseudo-langage algorithmique

Sommaire

1 Introduction à l’algorithmiqueIntroductionPseudo-langage algorithmique

Données et constantesVariablesOpérateursExpressionsInstructionsFonctions

Principes de bonne programmation




Pseudo-langage algorithmique

Afin d’uniformiser l’écriture des algorithmes, un pseudo-langage (nonnormalisé) contenant l’indispensable est utilisé : des données, desvariables, des opérateurs, des expressions, des instructions et desfonctions.



Données et constantes

Une donnée est une valeur extérieure introduite dans l’algorithme. Uneconstante est une valeur non modifiable (π, . . . ).



Variables

Une variable est un objet dont la valeur est modifiable.

Elle possède :1 un identificateur : nom (suffisamment explicite)2 un type : simple (booléen, entier, réel, caractère) ou structuré

(chaîne de caractères, liste, tuple, dictionnaire, . . . ),3 une valeur4 une référence : indique l’adresse de stockage dans la zone

mémoire.



Opérateurs arithmétiques

Nom Symbole

addition +soustraction -

produit *division /

division entière div ou //modulo mod ou %

exposant ˆ ou **



Opérateurs relationnels

Nom Symbole

identique ==différent <>inférieur <supérieur >

inférieur ou égal <=supérieur ou égal >=



Opérateurs logiques

négation non, ∼, ¬ou ou, |, ∨et et, &, ∧

opération d’affectation ←

Concaténation de liste +



Expressions

Une expression est un groupe d’opérandes (nombres, constantes,variables,. . . ) liées par des opérateurs. Elles sont évaluées pourdonner un résultat.

EXEMPLE : expression numérique : b/a et expression booléenne : a , 0(vrai ou faux).



Instructions

Une instruction est exécutée. Elle peut contenir une ou plusieursexpressions.

Il existe des instructions simples comme l’affectation : x ← b/a oul’appel de fonction : print("x=",x).

Mais il y a aussi des instructions structurées : groupe d’instructions,structures conditionnelles et structures itératives (répétitives).



Groupe d’instructions simples

Algorithm 3 Résolution de l’équation du 1er degré a.x = b

entrée: a, un réel non nul et b : un réelrésultat: x

1: x ← b/arenvoi: Affiche("x = ",x)



Instructions conditionnelles

Algorithm 4 Pair ou impair ?

entrée: n, un entierrésultat: r , un booléen vrai si n est pair, faux si n est impair

1: si n%2 == 0 alors2: r ← vrai3: sinonr ← faux4: fin si

renvoi: r



Instructions répétitivesBoucle Tant que : le nombre d’itérations n’est pas obligatoirement connu.

Algorithm 5 Devinette

entrée: n, un nombre entier compris entre 1 et 10, généré aléatoi-rement

1: i ← 02: k ← 03: tant que i , n faire4: i ←Entrer("Donner un nombre entier compris entre 1 et 10 : ")

// demande faite à l’utilisateur5: k ← k + 16: fin tant que7: renvoi: Afficher("Gagné en ",k," coups !")



Instructions répétitivesBoucle For : le nombre d’itérations est forcément connu à l’avance.

Algorithm 6 Somme des n premiers entiers

1: entrée: n, un entier2: résultat: S, la somme des n premiers entiers

S ← 03: pour i = 1 à n faire4: S ← S + i5: fin pour6: renvoi: S



Fonctions

Les fonctions permettent :• d’automatiser des tâches répétitives• d’ajouter de la clarté à un algorithme• d’utiliser des portions de code dans un autre algorithme

Le pseudo-langage algorithmique possède comme tout langage infor-matique des fonctions primitives d’entrée/sortie telles que Entrer,Afficher, mais aussi des fonctions primitives mathématiques (cos,racine, . . . ). Il est aussi possible d’écrire ses propres fonctions.



Pour cela, il faut tout d’abord répondre à ces deux questions :• quelles sont les données?• quel doit-être le résultat ?

Il faudra ensuite commenter l’algorithme : usage de la fonction, . . .


Introduction à l’algorithmique Principes de bonne programmation

Sommaire

1 Introduction à l’algorithmiqueIntroductionPseudo-langage algorithmiquePrincipes de bonne programmation




Principes de bonne programmation

Tous les algorithmes vus précédemment sont assez courts. D’autrespeuvent être bien plus longs.

Dans l’industrie, il arrive que des équipes produisent des codes demillions de lignes, dont certains mettent en jeux des vies humaines(aéronautique, nucléaire, . . . ).

Toute la difficulté réside alors dans l’écriture de programmes sûrs. Onconstate que lorsqu’un algorithme est simple, le risque d’erreur estmoindre. C’est sur ce principe essentiel que se basent les bonnesméthodes.



Ainsi, tout problème compliqué doit être découpé ensous-problèmes simples

Chaque module ou sous-programme est alors testé et validé séparé-ment.

Tous les modules doivent aussi être largement documentés.


Analyse des algorithmes

Sommaire

1 Introduction à l’algorithmique

2 Analyse des algorithmesIntroductionLa preuve de terminaisonLa preuve de correctionLa complexité des algorithmes


Analyse des algorithmes Introduction

Sommaire


2 Analyse des algorithmesIntroduction

ProblématiqueCas de l’industrie

La preuve de terminaisonLa preuve de correctionLa complexité des algorithmes



Problématique

PROBLÈME: Comment s’assurer qu’un algorithme se termine, donnedes résultats corrects et est efficace?L’analyse des algorithmes peut se faire suivant trois axes :• la terminaison : il s’agit de vérifier que l’algorithme ne tourne

pas de manière infinie• la correction : il faut s’assurer que le résultat renvoyé est le bon• la complexité : on spécifie le temps d’exécution en fonction de la

taille des données en entrée, ainsi que l’espace mémoire utilisé.



Pourquoi faire?

Pourquoi ces études sont-elles intéressantes?

On ne peut prouver un théorème par des exemples.

EXEMPLE : affirmer les nombres se terminant par 9 sont divisibles par3 est faux.

Il est vrai que les cas 9, 39, 69 et 1239 fonctionnent mais 19 nefonctionne pas.

Comment faire alors les tests permettant de mettre en lumière qu’uneassertion ou un programme ne fonctionne pas?



Pourquoi faire?








Pourquoi faire?








Cas de l’industrie

La preuve de programme n’est pas très développée en informatiqueindustrielle. Le logiciel de vol de l’A380 (premier vol en 2005) estle premier à avoir été prouvé : on sait de façon certaine que lescommandes de vol font ce qu’elles doivent faire. Ce n’était pas le cassur les avions précédents.

En réalité, dans l’industrie, on fait ce qu’on appelle des tests (ou bench-mark) : des scénarios sont créés sur lesquels on teste les logiciels. Onen déduit alors une fiabilité du logiciel qui sert d’argument de vente.Cette phase de tests fait parfois apparaître des erreurs étonnantes.



Cas de l’industrie

La preuve de programme n’est pas très développée en informatiqueindustrielle. Le logiciel de vol de l’A380 (premier vol en 2005) estle premier à avoir été prouvé : on sait de façon certaine que lescommandes de vol font ce qu’elles doivent faire. Ce n’était pas le cassur les avions précédents.

En réalité, dans l’industrie, on fait ce qu’on appelle des tests (ou bench-mark) : des scénarios sont créés sur lesquels on teste les logiciels. Onen déduit alors une fiabilité du logiciel qui sert d’argument de vente.Cette phase de tests fait parfois apparaître des erreurs étonnantes.



On trouve toutes sortes d’anecdotes sur Internet :

• problème de terminaison : Amazon et le livre qui valait 23,7million de dollars

• problème de correction : Sonde Mars Climate Orbiter• problème de complexité : Portail France.fr• problème de calcul numérique : Anti-missile Patriot


http://tisserant.org/cours/qualite-logiciel/qualite_logiciel.html

http://www.linformaticien.com/actualites/id/20511/amazon-vend-un-livre-23-7-millions-de-dollars.aspx


https://fr.wikipedia.org/wiki/Mars_Climate_Orbiter

http://www.01net.com/actualites/le-site-internet-de-la-france-toujours-en-panne-519202.html

http://fas.org/spp/starwars/gao/im92026.htm


On trouve toutes sortes d’anecdotes sur Internet :• problème de terminaison : Amazon et le livre qui valait 23,7

million de dollars

• problème de correction : Sonde Mars Climate Orbiter• problème de complexité : Portail France.fr• problème de calcul numérique : Anti-missile Patriot










million de dollars• problème de correction : Sonde Mars Climate Orbiter

• problème de complexité : Portail France.fr• problème de calcul numérique : Anti-missile Patriot










million de dollars• problème de correction : Sonde Mars Climate Orbiter• problème de complexité : Portail France.fr

• problème de calcul numérique : Anti-missile Patriot










million de dollars• problème de correction : Sonde Mars Climate Orbiter• problème de complexité : Portail France.fr• problème de calcul numérique : Anti-missile Patriot








Analyse des algorithmes La preuve de terminaison

Sommaire


2 Analyse des algorithmesIntroductionLa preuve de terminaison

Tester n’est pas prouverConjecture de SyracuseTerminaison d’un algorithme

La preuve de correctionLa complexité des algorithmes



Tester n’est pas prouver

Il ne s’agit pas de lancer l’implémentation d’un algorithme pour vérifierqu’il se termine. Quand bien même on aurait effectué un très grandnombre d’exécutions ayant toutes terminées, on ne pourrait pas pourautant affirmer que l’algorithme se termine. Il reste toujours la possibilitéqu’un ensemble improbable de paramètres fasse échouer le système,et l’entraîne dans une exécution interminable. C’est un problème determinaison.

Le fond des choses est en fait bien plus compliqué qu’il n’y paraît. Unalgorithme simple tel que le calcul de la suite de Syracuse pose encoreaujourd’hui des problèmes aux mathématiciens.



Tester n’est pas prouver

Il ne s’agit pas de lancer l’implémentation d’un algorithme pour vérifierqu’il se termine. Quand bien même on aurait effectué un très grandnombre d’exécutions ayant toutes terminées, on ne pourrait pas pourautant affirmer que l’algorithme se termine. Il reste toujours la possibilitéqu’un ensemble improbable de paramètres fasse échouer le système,et l’entraîne dans une exécution interminable. C’est un problème determinaison.

Le fond des choses est en fait bien plus compliqué qu’il n’y paraît. Unalgorithme simple tel que le calcul de la suite de Syracuse pose encoreaujourd’hui des problèmes aux mathématiciens.



Conjecture de Syracuse

La suite de Syracuse d’un nombre entier N est définie par récurrencede la manière suivante :

u0 = Net pour tout entier n > 0 :

un+1 =

un2 si un est pair

3.un + 1 si un est impair



0 5 1 0 1 5 2 0 2 50

2 0

4 0

6 0

8 0

1 0 0

1 2 0

1 4 0

1 6 0

N=30



Algorithm 7 Suite de Syracusedonnée: N ; un entierrésultat: syr ; la liste des termes de la suite de Syracuse jusqu’à cequ’un terme soit égal à 1.

Syracuse(N)1: syr←[N]2: i←03: tant que syr[i] ! = 1 faire4: si syr[i] %2 == 0 alors5: syr←[syr,syr[i] / 2]6: sinon7: syr←syr + [3 * syr[i] + 1]8: fin si9: i← i+1

10: fin tant que11: renvoi: syr



Empiriquement, cet algorithme se termine.

On sait montrer qu’une fois arrivée à 1, la suite calculée a alors uncycle d’ordre 3. Mais on ne sait pas montrer que ce cycle est toujoursatteint.



Empiriquement, cet algorithme se termine.

On sait montrer qu’une fois arrivée à 1, la suite calculée a alors uncycle d’ordre 3. Mais on ne sait pas montrer que ce cycle est toujoursatteint.



0 2 4 6 8 1 01

2

3

4

5

6

7

8

N=8



Définition

DÉFINITION: Terminaison d’un algorithme

un algorithme se termine, si son exécution sur machine s’arrête tou-jours quelque soit la nature des données en entrée

Certaines instructions se terminent sans même que l’on ait besoin dese poser de question. C’est le cas par exemple de l’affectation et de lacomposition de deux instructions qui se terminent.



Problématique

Le problème vient des boucles Tant que.

L’exemple de la suite de Syracuse le souligne : une boucle Tant ques’arrête lorsqu’une condition d’arrêt est réalisée, contrairement à laboucle Pour qui s’arrête lorsqu’un nombre prédéfini de répétitions ontété effectuées.



Problématique

Le problème vient des boucles Tant que.

L’exemple de la suite de Syracuse le souligne : une boucle Tant ques’arrête lorsqu’une condition d’arrêt est réalisée, contrairement à laboucle Pour qui s’arrête lorsqu’un nombre prédéfini de répétitions ontété effectuées.



Fonction PGCD

PROBLÈME: Comment déterminer le Plus Grand Diviseur Commun(PGCD) de deux entiers dont on ne connaît pas la factorisation?

D’après l’algorithme ci-contre, on définit la fonction f (u, v) = u + v .

Cette fonction est strictement positive et décroissante : il ne peut doncy avoir une infinité d’itérations. On remarque aussi qu’elle tend versdeux fois la valeur finale de u (ou v ).

REMARQUE: On pourrait aussi raisonner avec la fonctiong(u, v) = max (u, v).



Fonction PGCD







Fonction PGCD







Fonction PGCD







Algorithm 8 Fonction PGCDdonnée: a et b ; deux entiers naturels non nulsrésultat: u ; le PGCD de a et bPGCD(a,b)

1: u←a2: v← b3: tant que u ,v faire4: si u > v alors5: u←u-v6: sinon7: v← v-u8: fin si9: fin tant que

renvoi: u



Fonction PGCD : algorithme d’EuclidePROBLÈME:

dans la tradition grecque, en comprenant un nombre entier comme unelongueur, un couple d’entiers comme un rectangle, leur PGCD est lalongueur du côté du plus grand carré permettant de carreler entière-ment ce rectangle.

24

40

8

8



Fonction PGCD : algorithme d’EuclidePROBLÈME:dans la tradition grecque, en comprenant un nombre entier comme unelongueur, un couple d’entiers comme un rectangle, leur PGCD est lalongueur du côté du plus grand carré permettant de carreler entière-ment ce rectangle.

24

40

8

8




24

40

8

8




24

40

8

8




24

40

8

8




24

40

8

8



Algorithm 9 Fonction PGCD : algorithme d’Euclidedonnée: a et b ; deux entiers naturels non nulsrésultat: le PGCD de a et bEuclide_PGCD(a,b)

1: répéter2: r← a mod b3: a←b4: b←r5: jusqu’à r == 0

renvoi: a



24

40

8

8



24

40

8

8



24

40

8

8



24

40

8

8



24

40

8

8



A la nième itération, on a la relation an = qn.bn + rn où qn est un entier.

L’algorithme d’Euclide entraîne cette définition de la suite (an): pourtout n tel que an+1 soit un entier positif, il existe un entier qn tel que :an = qn.an+1 + an+2.

De plus, 0 ≤ an+2 < an+1 pour tout n tel que an+1 est non nul.

La suite d’entiers naturels est donc strictement décroissante (tantqu’elle est non nulle) à partir du rang 1, et vaut donc 0 à un certainrang.

Il en est donc de même pour la suite (rn).

REMARQUE: L’algorithme d’Euclide (algorithme 3) présente l’avantaged’avoir une complexité en temps d’exécution moindre par rapport à l’al-gorithme initial (algorithme 2).



Variant de boucle

Pour faire une preuve de terminaison, on cherche donc ce que l’onappelle un variant de boucle ou encore une fonction de terminaison,c’est à dire une suite d’entiers strictement croissante majorée ou desuite d’entiers strictement décroissante minorée.

REMARQUE: le nombre de valeurs prises par la fonction de terminaisonest une bonne estimation du nombre de répétitions effectuées lors del’exécution. Si l’on trouve un majorant de cette fonction, on aura doncun majorant du nombre de tours effectués par la boucle quelque soitl’entrée de l’algorithme. C’est donc un premier pas vers l’étude de lacomplexité.


Analyse des algorithmes La preuve de correction

Sommaire


2 Analyse des algorithmesIntroductionLa preuve de terminaisonLa preuve de correction

Problème de correctionInvariant de boucleCas des algorithmes récursifs

La complexité des algorithmes



Problème de correction

On peut montrer qu’un algorithme se termine bien, sans pour autantqu’il ne donne toujours le bon résultat : c’est un problème de correc-tion.EXEMPLE : Fonction PGCD : algorithme d’Euclide, structure itérative(algorithme 3)

On rappelle qu’à la nième itération, on a la relation an = qn.bn + rn =qn.an+1 + an+2 où qn est un entier.

A la dernière itération N, rN = aN+2 = 0. On a donc aN = qN .aN+1. Larelation précédente montre que aN+1 divise aN .

On écrit ensuite que aN−1 = qN−1.aN + aN+1 = (qN−1.qN + 1) .aN+1.



On en déduit que aN+1 divise aussi aN−1 ; puis, de même, et parrécurrence, que aN+1 divise tous les termes de la suite (an) ; enparticulier les premiers termes a et b. aN+1 est donc bien un diviseurcommun de a et b.

Réciproquement, tout diviseur commun de a et b divise aussi tous lestermes de la suite (an) ; donc en particulier aN+1. aN+1 est donc undiviseur commun de a et b, que divise tout autre diviseur commun ;c’est bien le PGCD(a,b).

Le PGCD de an et an+1 pour tout n entier positif non nul, est ce que l’onappelle un invariant de boucle. A chaque itération, c’est une propriétéqui est conservée.



Invariant de boucle

Un invariant de boucle est une propriété :

• qui est vérifiée après la phase d’initialisation,• qui reste vraie après l’exécution d’une itération,• qui, conjointement à la condition d’arrêt, permet de montrer que le

résultat attendu est bien celui qui est calculé.



Invariant de boucle

Un invariant de boucle est une propriété :• qui est vérifiée après la phase d’initialisation,

• qui reste vraie après l’exécution d’une itération,• qui, conjointement à la condition d’arrêt, permet de montrer que le




Invariant de boucle

Un invariant de boucle est une propriété :• qui est vérifiée après la phase d’initialisation,• qui reste vraie après l’exécution d’une itération,

• qui, conjointement à la condition d’arrêt, permet de montrer que lerésultat attendu est bien celui qui est calculé.



Invariant de boucle

Un invariant de boucle est une propriété :• qui est vérifiée après la phase d’initialisation,• qui reste vraie après l’exécution d’une itération,• qui, conjointement à la condition d’arrêt, permet de montrer que le




Cas des algorithmes récursifs

Pour prouver la correction d’un algorithme récursif, on adopte unraisonnement par récurrence.

La preuve s’effectue par induction (récurrence) sur la taille du problèmeà résoudre.• la base de la récurrence est celle de la récursivité.• l’étape de la récurrence : on suppose que l’algorithme est correct

pour les appels récursifs précédents, et on montre qu’il fonctionnecorrectement pour l’appel actuel.



EXEMPLE : Fonction PGCD : algorithme d’Euclide, structure récursive

Algorithm 10 Fonction PGCD : algorithme d’Euclide récursifsdonnée: a et b ; deux entiers naturels non nuls tels que a>brésultat: le PGCD de a et bEuclide_PGCD_recursif(a,b)

1: si b==0 alors2: renvoi: a3: sinon4: renvoi: Euclide_PGCD_recursif(b,a mod b)5: fin si



• au dernier appel N de la fonction Euclide_PGCD_récursif, bN = 0.aN est donc le PGCD(aN ,0).

• on suppose qu’au nième appel de la fonctionEuclide_PGCD_recursif, aN est le PGCD(an,bn).

• à l’appel n − 1 de la fonction Euclide_PGCD_récursif :

an−1 = qn−1.bn−1 + rn−1 = qn−1.an + bn

Or aN étant le PGCD(an,bn), il est aussi plus grand diviseur de(an−1,an), c’est-à-dire que aN = PGCD(an−1,an) et doncaN = PGCD(an−1,bn−1).

• on en déduit par récurrence que aN = PGCD(a,b).






an−1 = qn−1.bn−1 + rn−1 = qn−1.an + bn








an−1 = qn−1.bn−1 + rn−1 = qn−1.an + bn








an−1 = qn−1.bn−1 + rn−1 = qn−1.an + bn




Analyse des algorithmes La complexité des algorithmes

Sommaire


2 Analyse des algorithmesIntroductionLa preuve de terminaisonLa preuve de correctionLa complexité des algorithmes

Complexité en temps et en mémoireOpérations élémentairesClasses de complexitéMéthodes de calcul de la compléxité



Complexité en temps et en mémoire

En plus d’être correct, on demande à un algorithme d’être efficace.

Cette efficacité peut être évaluée par :

• le temps que prend l’exécution de l’algorithme : c’est lacomplexité en temps. Le temps d’exécution dépend de la tailledes données fournies en entrées.

• les ressources nécessaires à son exécution : c’est la complexitéen mémoire (cf cours Pivot de Gauss).





Cette efficacité peut être évaluée par :

• le temps que prend l’exécution de l’algorithme : c’est lacomplexité en temps. Le temps d’exécution dépend de la tailledes données fournies en entrées.






Cette efficacité peut être évaluée par :• le temps que prend l’exécution de l’algorithme : c’est la

complexité en temps. Le temps d’exécution dépend de la tailledes données fournies en entrées.






Cette efficacité peut être évaluée par :• le temps que prend l’exécution de l’algorithme : c’est la

complexité en temps. Le temps d’exécution dépend de la tailledes données fournies en entrées.




On se focalise donc par la suite sur l’étude la complexité en tempsd’exécution, i.e. en nombre d’opérations élémentaires.

Nous étudions donc le nombre d’opérations élémentaires de manièreasymptotique avec les notions mathématiques de Landau : O(), Θ().

On suppose que f (n) ≥ 0 et g(n) ≥ 0 pour tout entier n :

• f est appelée un grand Ô de g et on note f = O(g) lorsqu’il existeun rang n0 et une constante c > 0 tels que ∀n ≥ n0, f (n) ≤ c.g(n)

• f est appelée un theta de g et on note f = Θ(g) lorsqu’il existe unrang n0 et une constante c1, c2 > 0 tels que∀n ≥ n0, c1.g(n) ≤ f (n) ≤ c2.g(n)

Tout le travail de l’étude de complexité repose donc sur l’identificationdes opérations non élémentaires et sur le calcul de leur nombre.





















On suppose que f (n) ≥ 0 et g(n) ≥ 0 pour tout entier n :• f est appelée un grand Ô de g et on note f = O(g) lorsqu’il existe

un rang n0 et une constante c > 0 tels que ∀n ≥ n0, f (n) ≤ c.g(n)





















Opérations élémentairesOn considère comme élémentaires les opérations :

• addition, soustraction, multiplication, division, modulo sur des entiers oudes flottants

• affectation simple,

• accès aux éléments d’un tableau

• modification d’un éléments d’un tableau

• taille d’un tableau

• La méthode append sur une liste Python peut être considérée commeune opération basique.

• la gestion de la variable de boucle d’une boucle Pour

• les tests élémentaires, utilisés principalement dans les boucles Tant queet les structures conditionnelles

Si l’on note T (P) la complexité d’une instruction P, alors pour deux instruc-tions P et Q, on a : T (P; Q) = T (P) + T (Q).

Ainsi, T (Pour i de 1 à n faire P(i) FinPour) =n∑

i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).














i+1

T (P(i)).



Somme géométrique

PROBLÈME: On souhaite calculer la somme des n premiers entiers.

Algorithm 11 Somme des n pre-miers entiers

donnée: n, un entierrésultat: S; la somme des npremiers entiersSomme(n)

1: S←02: pour i de 1 à n faire3: S←S+i4: fin pour5: renvoi: S

Dans l’algorithme ci-dessus, onne considère que le coût t de lasomme S+i effectuée à chaqueitération de la boucle Pour.

Ainsi le coût total est de la formeC(n) = n.t . On dira que la com-plexité est du type : C(n) = Θ(n).

Elle croît linéairement avec lenombre d’entiers n.



Somme géométrique










Somme géométrique










Somme géométrique










Somme géométrique










Classes de complexitéOn définit différentes classes de complexité :

Notation Type de complexitéΘ(1) Complexité constante

Θ(ln(n)) Complexité logarithmiqueΘ(n) Complexité linéaire

Θ(n. ln(n)) Complexité quasi-linéaireΘ(n2) Complexité quadratiqueΘ(n3) Complexité cubiqueΘ(np) Complexité polynomiale

Θ(nln(n)) Complexité quasi-polynomialeΘ(2n) Complexité exponentielleΘ(n!) Complexité factorielle





En s’appuyant sur une base de 109 opérations par secondes, le tableauci-dessous donne le temps d’exécution des différentes complexitéscitées précédemment.

n 5 10 20 50 250 103 104 106

1 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 nslog(n) 10 ns 10 ns 10 ns 20 ns 30 ns 30 ns 40 ns 60 nsO(n) 50 ns 100 ns 200 ns 500 ns 2,5 µs 10 µs 100 µs 10

n. log(n) 50 ns 100 ns 200 ns 501 ns 2,5 µs 10 µs 100.5 µs 10 050 µsn2 250 ns 1 µs 4 µs 25 µs 625 µs 10 ms 1 s 2,8 hn3 1,25 µs 10 µs 80 µs 1,25 ms 156 ms 10 s 2,7 h 316 ans2n 320 ns 10 µs 10 ms 130 jours 1059 ans . . . . . . . . .n! 1,2 µs 36 ms 770 ans 1045 ans . . . . . . . . . . . .



Opération Python Coût moyenCopy O(n)

Append O(1)Insert O(n)

Obtenir un élément O(1)Changer un élément O(1)

Supprimer un élément O(n)Itération O(n)

Obtenir une sélection O(k)Supprimer une sélection O(n)Changer une sélection O(k+n)

Extend O(k)Trier O(n.log(n))

Multiplier O(nk)x in s O(n)

min(s), max(s) O(n)Length O(1)



Il apparaît deux choses :

• il faut éviter les complexités supérieures à la complexitépolynomiale d’ordre 2 ;

• il ne faut absolument pas compter sur les avancéestechnologiques !



Il apparaît deux choses :• il faut éviter les complexités supérieures à la complexité

polynomiale d’ordre 2 ;

• il ne faut absolument pas compter sur les avancéestechnologiques !



Il apparaît deux choses :• il faut éviter les complexités supérieures à la complexité

polynomiale d’ordre 2 ;• il ne faut absolument pas compter sur les avancées

technologiques !



Nous étudierons, lorsque l’exemple s’y prêtera, trois types de complexi-tés en temps :

• la complexité dans le pire cas, Cmax : c’est un majorant dutemps d’exécution sur toutes les entrées possibles d’une mêmetaille ; la complexité dans le pire cas apporte une notion desécurité sur le temps d’exécution ;

• la complexité en moyenne, Cmoy : il s’agit d’une moyenne sur letemps d’exécution sur toutes les entrées possibles d’une mêmetaille en considérant une distribution équiprobable ; elle représentele comportement moyen d’un algorithme ;

• la complexité dans le meilleur cas, Cmin : elle est peu utile,facile à calculer, mais n’apporte qu’une borne inférieure sur lestemps d’exécution.



Nous étudierons, lorsque l’exemple s’y prêtera, trois types de complexi-tés en temps :• la complexité dans le pire cas, Cmax : c’est un majorant du

temps d’exécution sur toutes les entrées possibles d’une mêmetaille ; la complexité dans le pire cas apporte une notion desécurité sur le temps d’exécution ;

















Méthode itérativeOn somme membre à membre et on en déduit la complexité :EXEMPLE : avec une récurrence C(n) = C(n/2) + 1

1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m

Or m est telle que n2m−1 = 1 ce qui entraîne n = 2m−1 soit m = log2 n+1

⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 1

2 C(n/2) = C(n/4) + 1. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1

. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1

C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))




1 C(n) = C(n/2) + 12 C(n/2) = C(n/4) + 1

. . .

i C(n/(2i−1)) = C(n/(2i)) + 1. . .

m C(1) = ��C(0) + 1C(n) = m


⇒ C(n) = O(ln(n))



EXEMPLE : avec une récurrence C(n) = C(n − 1) + 1

1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 1

2 C(n − 1) = C(n − 2) + 1. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1

. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)




1 C(n) = C(n − 1) + 12 C(n − 1) = C(n − 2) + 1

. . .

i C(n − (i − 1))) = C(n − i) + 1. . .

n C(n − (n − 1)) = ��C(0) + 1

C(n) = n

⇒ C(n) = O(n)



Méthode par substitution

on vérifie une intuition :

• hypothèse par intuition C(n) = g(n)

• démontrer que a.g(n/b) + f (n) = g(n) avec g(1) = c en fixant lesconstantes




on vérifie une intuition :• hypothèse par intuition C(n) = g(n)





on vérifie une intuition :• hypothèse par intuition C(n) = g(n)




Exemple : C(n) = C(n/2) + 1 avec C(1) = 1

• intuition : C(n) = Θ(ln(n))

• on pose alors : C(n) = a. log2(n) + c avec a et c à déterminer.• on cherche a et c par substitution

C(n) = a. log2(n) + cC(n/2) = a. log2(n/2) + c = a. log2(n) − a. log2(2) + c

C(n) = C(n/2) + 1⇒ a. log2(n) + c = a. log2(n) − a + c + 1

⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1



Exemple : C(n) = C(n/2) + 1 avec C(1) = 1• intuition : C(n) = Θ(ln(n))




⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1




• on pose alors : C(n) = a. log2(n) + c avec a et c à déterminer.

• on cherche a et c par substitution



⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1







⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1







⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1







⇒ a = 1

Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1







⇒ a = 1Or 1 = C(1) = log2(1) + c ⇒ c = 1. Ainsi :

C(n) = log2(n) + 1



Méthode générale

on utilise les propriétés des suites récurrentes linéaires.

On peut toujours écrire une relation de récurrence de la forme :

C(1) = cC(n) = a.C(n/b) + f (n)



Méthode générale

on utilise les propriétés des suites récurrentes linéaires.

On peut toujours écrire une relation de récurrence de la forme :

C(1) = cC(n) = a.C(n/b) + f (n)



RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)

factorielle, recherche séquentielle (ba-layage) récursive dans un tableau

C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)

répétition a fois d’un traitement sur lerésultat de l’appel récursif

C(n) = C(n − 1) + a.n + bC(n) = C(0) + a.n.(n + 1)/2 + n.b = Θ

(n2

) traitement en coût linéaire avant l’appelrécursif, tri à bulle

C(n) = C(n/2) + bC(n) = C(1) + b. log2(n) = Θ(ln(n))

élimination de la moitié des élémentsen temps constant avant l’appel récur-sif, recherche dichotomique récursive,exponentiation rapide

C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)

)répétition a fois d’un traitement surle résultat de l’appel récursif dichoto-mique

C(n) = C(n/2) + a.n + bC(n) = Θ(n)

traitement linéaire avant l’appel récursifdichotomique

C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))

traitement linéaire avant double appelrécursif dichotomique, tri fusion



RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))




RelationSolution

Exemples

C(n) = C(n − 1) + bC(n) = C(0) + b.n = Θ(n)


C(n) = a.C(n − 1) + b,a , 1

C(n) = an.(C(0) − b

1 − a

)+ b

1 − a= Θ (an)



(n2




C(n) = a.C(n/2) + b,a , 1

C(n) = nlog 2(a).(C(1) − b

1 − a

)+ b

1 − a= Θ

(nlog 2(a)


C(n) = C(n/2) + a.n + bC(n) = Θ(n)


C(n) = 2.C(n/2) + a.n + bC(n) = Θ (n. ln(n))



Documents

Algorithmique et Programmation - Lycée Carnotgondor-carnot.fr/oooo/Info/Diap-INFO-SUP-Cours-ALGO-PROG-Algo.pdf · Algorithmique Algorithmique et Programmation Germain Gondor LYCÉE