Académique Documents
Professionnel Documents
Culture Documents
1
Introduction à L’algorithmique 2013/2014
8 Les algorithmes de Tri ................................................................................................................... 37
8.1 Le tri par la méthode du Min ou Max successif (Tri par sélection) ....................................... 38
8.2 Le tri par la méthode à bulles ................................................................................................ 39
9 Les algorithmes de Recherche....................................................................................................... 40
9.1 Recherche linéaire dans un ensemble non trié ..................................................................... 40
9.2 Recherche linéaire dans un ensemble trié suivant un ordre croissant ................................. 41
9.3 Recherche par la méthode de Dichotomie............................................................................ 41
9.3.1 Utilisation de la dichotomie résolution de f(x) = 0 ........................................................ 43
9.3.2 Utilisation de la dichotomie pour chercher le Maximum.............................................. 44
10 Complexité Algorithmique ........................................................................................................ 45
10.1 L’analyse de la complexité :................................................................................................... 45
10.2 Règles générales .................................................................................................................... 45
10.3 Calcul de la complexité des algorithmes usuels .................................................................... 49
11 Conclusion ................................................................................................................................. 51
2
Introduction à L’algorithmique 2013/2014
Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement,
conduit à un résultat donné. Si l’algorithme est juste, le résultat est le résultat voulu (le
touriste se retrouve là où il voulait aller). Si l’algorithme est faux, le résultat est aléatoire.
Le malheur est que justement, si le touriste vous demande son chemin, c’est qu’il ne le
connaît pas. De même les modes d’emploi contiennent généralement un peu plus
d’informations que « débrouillez-vous pour que ça marche ».
Donc on peut dire qu’un algorithme est un ensemble de règles logiques et chronologiques
qu’on doit suivre pour aboutir à la résolution d’un problème particulier. Ces règles sont
constituées d’un nombre fini d’opérations élémentaires arithmétiques (+, -, *, /, \) et logique
(AND, OR, NON). Ces opérations seront exécutées dans un ordre bien déterminé.
Un algorithme peut être assimilé à un raisonnement que l’on peut traduire avec un langage
que toute personne peut comprendre. Ce langage est appelé LDA : Langage de Description
d’Algorithme qui n’est pas un langage informatique mais un pseudo-code utilisé pour
simplifier l’écriture algorithmique.
En informatique les choses auxquelles on doit donner des instructions sont les ordinateurs et
donc on utilise les langages informatiques (Pascal, Visual basic, C, C++, ….etc) pour leur
décrire ces instructions.
3
Introduction à L’algorithmique 2013/2014
Le programme informatique est donc la traduction du LDA à un autre langage
compréhensible pour la machine (Pascal, Visual Basic, C, C++, C#, Java…)
Exemple-1
Ecrire un plan d’algorithme qui permet de résoudre l’équation ax+b = 0
Début algorithme
Retenir (saisir, lire) la valeur de a.
Retenir (saisir, lire) la valeur de b.
Si a est égal à zéro il y aura pas de solution.
Sinon la valeur de x est obtenue en divisant -b par a.
Afficher la valeur de x
Fin algorithme
4
Introduction à L’algorithmique 2013/2014
Plan de l'algorithme
1. Début de l'algorithme
2. Retenir (lire, saisir) la quantité Q
3. Retenir (lire, saisir) le prix unitaire M
4. Retenir (lire, saisir) le taux TVA
5. Calculer le montant hors taxe en multipliant la quantité Q par le prix unitaire M.
Nommons cette grandeur MHT.
6. Calculer le montant de la TVA en multipliant le montant hors taxe par le taux de la
TVA
7. Calculer le montant TTC en ajoutant au montant hors taxe (MHT) le montant de la
TVA
8. Afficher le montant hors taxe
9. Afficher le montant TTC
Fin de l'algorithme
a. Début algorithme.
b. Retenir (saisir, lire) le mot à rechercher.
c. Ouvrir le dictionnaire à la première page.
d. Tant que le mot ne se trouve pas sur la page courante et la page courante n'est pas la
dernière exécuter l'étape e) sinon passer à l'étape f).
e. Passer à la page suivante.
f. Si le mot s'y trouve lire la définition sinon ce mot ne se trouve pas dans le
dictionnaire.
g. Fin de l'algorithme.
Bien évidement cette méthode n’est pas rapide. Et ce c’est pas la méthode qu’on utilise pour
faire ce genre de recherche ? . La méthode de recherche la plus intuitive est la suivante :
a. Début algorithme.
b. Retenir (saisir, lire) le mot à rechercher.
c. Ouvrir le dictionnaire à la page du milieu.
d. Tant que le mot ne se trouve pas sur la page courante et la page courante n'est pas la
dernière exécuter l'étape e) et f) sinon passer à l'étape g).
e. Si le mot se trouve dans la partie droite ouvre la page du milieu de cette partie
f. Sinon ouvre la page du milieu de la partie gauche
g. Si le mot s'y trouve lire la définition sinon ce mot ne se trouve pas dans le
dictionnaire.
h. Fin de l'algorithme.
5
Introduction à L’algorithmique 2013/2014
D’après l’exemple-2 on peut conclure que plusieurs résonnement (algorithmes) peuvent
aboutir aux mêmes résultats. Donc il est toujours préférable de garder l’algorithme qui donne
le résultat le plus rapidement possible sans consommer beaucoup de mémoire.
C’est pourquoi on utilise généralement une série de conventions appelée « pseudo-code », qui
ressemble à un langage de programmation dont on aurait évacué la plupart des problèmes de
syntaxe. Ce pseudo-code est susceptible de varier légèrement d’un livre (ou d’un enseignant)
à un autre. C’est bien normal : le pseudo-code, encore une fois, est purement conventionnel ;
aucune machine n’est censée le reconnaître.
Dans ce "langage", les algorithmes sont représentés par des blocs d'actions. On appellera bloc
d'actions un ensemble d'actions enchaînées séquentiellement dont l'exécution ne peut
commencer que par la première action du bloc et ne peut se terminer que par la dernière.
D'où la notation:
Début bloc
Action 1;
Action 2;
…………
Action n;
Fin bloc
6
Introduction à L’algorithmique 2013/2014
2.1.1 Structure fondamentale d’un algorithme
Nom de l’algorithme :
Les déclarations :
Le corps de l’algorithme :
Les commentaires :
Les Constantes :
o Elles représentent des chiffres, des nombres, des caractères, des chaînes de
caractères, … dont la valeur ne peut pas être modifiée au cours de l’exécution
de l’algorithme.
Les Variables :
o Elles peuvent stocker des chiffres des nombres, des caractères, des chaînes de
caractères,… dont la valeur peut être modifiée au cours de l’exécution de
l’algorithme.
7
Introduction à L’algorithmique 2013/2014
Les Structures :
Exemples :
8
Introduction à L’algorithmique 2013/2014
Le booléen :
Il ne peut prendre que deux états possibles : VRAI ou FAUX (True ou False)
Les différents types de variables données en langage C sont représentés dans le tableau ci-
dessous.
Arithmétique Comparaison
9
Introduction à L’algorithmique 2013/2014
Logique
Opérateur Algo
Fonction ET ET
Fonction OU OU
Fonction OU Exclusif OUX
Fonction NON NON
Dans les instructions Il y a un certain ordre d’exécution de ces opérateurs. Cette est mentionné
ci-dessous :
10
Introduction à L’algorithmique 2013/2014
Exemples :
Variables A, B, C en Entier
Début
A←5
B←3
C←A+B
A←2
C←B–A+B
Fin
Variables A, B en Entier
Début
A←5
B←A+4
A←A+1
B←A–7
B←A-B-7
Fin
Après exécution de cet algorithme on aura A=6, B=0
Var A, B, K : entiers
Lire (A)
Lire (B)
KA
AB
BK
Ecrire (A, B)
Cet algorithme permet d’échanger les valeurs de deux variables A et B, et ce quel que soit
leur contenu préalable.
4 Structures de contrôles
Sans ces structures un algorithme va s’exécuter d’une manière linéaire c.-à-d. une exécution
suivant l’ordre où elles sont énoncées.
Traitement 1
Traitement 2
Traitement 3
11
Traitement 4
Introduction à L’algorithmique 2013/2014
Les structures de contrôles permettent de contrôler l’exécution linaire d’une suite
d’instructions. Il existe deux catégories de structures de contrôles
Si la condition est vérifiée les traitements se font dans cet ordre : (T1 T2 T3).
Si la condition n’est pas vérifiée les traitements se font dans cet ordre : (T1 T3).
Cette structure est utilisée dans un algorithme de la manière suivante :
SI <condition> ALORS
[<bloc d'actions-1>]
FIN SI
[<bloc d'actions-2>]
12
Introduction à L’algorithmique 2013/2014
Si la condition est vérifiée les traitements se font dans l’ordre suivant: (T1 T2 T4).
Si la condition n’est pas vérifiée les traitements se font dans l’ordre suivant: (T1 T3 T4).
Dans un algorithme on écrit :
SI <condition> ALORS
[<bloc d'actions 1>]
SINON
[<bloc d'actions 2>]
FIN SI
[<bloc d'actions 3>]
13
Introduction à L’algorithmique 2013/2014
Cette structure est utilisée dans les algorithmes de la manière suivante :
Si <condition1> Alors
Traitement 1;
Sinon
Si <condition2> Alors
Traitement 2;
Sinon
Si <condition3> Alors
Traitement 3;
Sinon
Si <condition4> Alors
Traitement 4;
Sinon
Traitement 5;
Fin Si
Fin Si
Fin Si
Fin Si
Si on n’a pas d’instruction à mettre entre le «sinon » et « si », on peut les écrire sur la même
ligne. Dans ce cas on aura besoin de fermer avec « FinSi » que le premier « si » utilisé.
Si <condition1> Alors
Traitement 1;
Sinon Si <condition2> Alors
Traitement 2;
Sinon Si <condition3> Alors
Traitement 3;
Sinon Si <condition4> Alors
Traitement 4;
Sinon
Traitement 5;
Fin Si
14
Introduction à L’algorithmique 2013/2014
Exemple :
15
Introduction à L’algorithmique 2013/2014
Var a, b, c : entiers
Var x1, x2, D : réels
Lire (a, b, c)
Si (a=0) alors
Si (b=0) alors
Si (c=0) alors
Ecrire(«la solution est IR »)
Sinon
Ecrire(«impossible»)
Finsi
Sinon
x1 -c/b
Ecrire(«la solution est :», x1)
Finsi
Sinon
D b^2 – 4*a*c
Si (D>0) alors
Ecrire(«les solutions sont: », (-b+sqrt(D))/(2*a), (-b-sqrt(D))/(2*a))
Sinon
Si (D=0) alors
Ecrire(«la solution est: », -b/(2*a))
sinon
Ecrire (« pas de solution dans IR »)
FinSi
FinSi
FinSi
Fin
16
Introduction à L’algorithmique 2013/2014
4.2 Structures de contrôle itératives
Les structures itératives permettent de répéter l’exécution d’un ensemble d’instructions une ou
plusieurs fois. Ces structures sont regroupées sous deux grandes familles selon si : le nombre
de répétitions est connu ou pas.
Dans cette structure, la sortie de la boucle d’itération s’effectue lorsque le nombre souhaité de
répétition est atteint.
On utilise donc une variable d’itérations caractérisée par :
• sa valeur initiale Vi
• sa valeur finale Vf
• son pas de variation p
En pseudo-code on écrit :
Dans le cas où la valeur finale de l’indice est inférieure à sa valeur initiale le pas de variation
est négatif, la structure est dite «décroissante». Dans le cas contraire, le pas est positif et la
structure est dite «croissante ».
Exemple :
L’algorithme qui permet de faire la somme de N valeurs est :
Var V, S, N, i entiers
S0
Lire (N)
Pour i 1 à N
Ecrire(« V= »)
Lire (V)
SS+V
Suivant i
Ecrire(« la somme est : », S)
La simulation de l’exécution de cet algorithme pour N=3 est donnée par le tableau ci-
dessous :
17
Introduction à L’algorithmique 2013/2014
Donc après l’arrêt de la boucle, les valeurs qui reste en mémoire de i et S sont : i=4, S=-5
i V0
Tant que <condition> faire
[<bloc d’actions >]
i i+1
Fin tant que
Exemple :
Nous voulons écrire un algorithme qui calcul la somme des valeurs saisies à l’entrée. On
arrête le calcul de la somme lorsque l’utilisateur saisi la valeur var = -1. La valeur -1 ne doit
être intégrée dans le calcul de la somme.
18
Introduction à L’algorithmique 2013/2014
Var S, var : entier
i1
S0
Ecrire ("saisir la valeur", i)
Lire (var)
Tant que (var < > -1) faire
S S + var
ii+1
Ecrire ("saisir la valeur", i)
Lire (var)
Fin tant que
Ecrire("La somme est :", S)
Ecrire("Le nombre de valeur sommées est :", i-1)
i V0
Répéter
[<bloc d’actions >]
i i+1
Tant que <condition>
Dans ce cas la vérification de la condition se fait après l’exécution du bloc d’instruction. Donc
le bloc d’instruction s’exécute au moins une fois.
19
Introduction à L’algorithmique 2013/2014
Exemple :
Nous voulons écrire un algorithme qui calcul la somme des valeurs saisies à l’entrée. On
arrête le calcul lorsque la somme devienne supérieure à 1000.
Le choix entre les structures de répétition déjà mentionnées se fait suivant deux critères :
Est que le nombre d’itération connu ou pas ?
Est que le Traitement doit être exécuté avant ou après le test d’arrêt de la boucle ?
20
Introduction à L’algorithmique 2013/2014
On veut trouver la valeur maximale (minimale) d’un ensemble de valeurs dont le nombre est
inconnu. La saisie de ces nombres se termine lors de la saisie d’un nombre nul. La valeur 0
ne doit pas appartenir à l’ensemble de nombre dont on cherche le maximum. La méthode
qu’on va utiliser est une méthode itérative. Le principe c’est de comparer chaque valeur avec
la suivante et d’éliminer la valeur la plus petite (la plus grande). On gardera en mémoire que
la valeur maximale (minimale).
6 Les tableaux
Dans la plus part du temps, on aura besoin dans des algorithmes de garder en mémoire
plusieurs valeurs. Dans ce cas on doit déclarer des tableaux. Ces dernières permettent de
stoker plusieurs variables de même type sous un même identificateur. On peut déclarer des
tableaux d’entiers de réels ou de caractères. Chaque tableau possède des dimensions, on
parlera de tableau à :
Les cases sont numérotées à partir de zéro, autrement dit que le plus petit indice est zéro. Lors
de la déclaration d’un tableau on doit préciser sa dimension. C-a-d le nombre de cases qu’on
doit réserver dans la mémoire pour stocker toutes les valeurs qu’on aura besoin dans notre
traitement. On précise donc dans la déclaration la plus grande valeur de l'indice qui est
différente du nombre de cases du tableau. Si, par exemple, on veut 12 emplacements, le plus
grand indice sera 11.
Syntaxe en pseudo-code :
En mémoire un tableau occupe un seul bloc continu et linéaire. Chaque case du tableau
déclaré correspond à une allocation d’un ensemble continu d’emplacement mémoire appelé
« élément mémoire ». Chaque case est adressée par l’adresse mémoire qui correspond au
premier emplacement mémoire réservé pour stocker le contenu de cette case. La taille de
22
Introduction à L’algorithmique 2013/2014
l’élément mémoire dépond du type de données stockées dans le tableau. La figure-1
représente l’implantation dans la mémoire centrale d’un tableau à deux dimensions.
Exemple-1 :
Dans cet algorithme on a déclaré un tableau T(19). On peut stocker donc 20 valeurs.
Dans cet algorithme on a déclaré une variable Tab. On va stocker donc en mémoire que la
dernière valeur saisie.
Exemple-2:
On veut saisir une suite de nombres, puis afficher cette suite après avoir divisé tous les
nombres par la valeur maximale de la suite. Nécessité donc de conserver les nombres en
mémoire.
23
Introduction à L’algorithmique 2013/2014
Pour un ensemble de 5 valeurs, l’algorithme qui permet de résoudre le problème est :
24
Introduction à L’algorithmique 2013/2014
Var Notes() en Numérique
Var nb en Numérique
Début
Ecrire("Combien y a-t-il de valeurs à saisir ?")
Lire(nb)
Dim(Notes, nb)
…………
Ecrire(« Nous voulons ajouter des valeurs »)
Lire(nb’)
ReDim(Notes, nb+nb’)
…..
…..
…..
Fin
Exemple-1:
Donner un algorithme qui stocke n notes dans un tableau de valeur et calcule et affiche la
moyenne. L’utilisateur peut saisir un nombre n de note.
Exemple-2:
Exercice:
Donner un algorithme qui stocke un certain nombre inconnu de notes dans un tableau de
valeur et calcule et affiche la moyenne. L’utilisateur peut arrêter la saisie en entrant (-1).
25
Introduction à L’algorithmique 2013/2014
var Note() : réels
Var S, Moy : réel
Var i, n : entier
i=0
Dim(Note, 1)
Ecrire(« donner la note », i+1)
Lire(Note(0))
S0
Tant que (Note(i)<>-1) faire
SS+Note(i)
i i+1
Redim(Note, i+1)
Ecrire(« donner la note », i+1)
lire(Note(i))
Fin tant que
Moy S/n
Ecrire(« la moyenne est : », Moy)
7.1 Structuration
Les fonctions et les procédures présentent donc un intérêt primordial dans les conceptions des
algorithmes. Ils ont comme rôles de :
Regrouper un ensemble d’instruction dans le même algorithme afin de pouvoir y faire
appel autant de fois que nécessaire.
Avoir un algorithme principal qui fait appel aux différents fonctions et/ou procédures
Avoir une lisibilité et identification faciles des erreurs.
26
Introduction à L’algorithmique 2013/2014
Il est inutile de connaître comment est définie une fonction ou une procédure pour y faire
appel. Par contre il est nécessaire de connaître sa déclaration (son manuel d’utilisation):
Quel est son rôle?
Quels sont les arguments à fournir?
Quelles est la valeur retournée?
Un paramètre de sortie est une variable dont la valeur est affectée par les instructions du
sous-programme
Syntaxe en pseudo-code
Remarque :
Dans la syntaxe, on précise qu’un paramètre est d’entrée ou de sortie si on précède le
paramètre par, respectivement, la lettre « E » ou « S ». Si ne précède le paramètre par aucune
lettre on le considère comme d’entrée. Un paramètre est noté d’entrée-Sortie s’il est précédé
par « E/S ».
27
Introduction à L’algorithmique 2013/2014
Exercice1 : Ecrire un algo qui permet de calculer les termes U1, U2, …., U10 d’une suite
arithmétique connaissant le premier terme U0, la raison « r » et le rang « n ».
Solution :
1. Début
2. Var n, U0, U, r : entier
3. Ecrire(« premier terme ?»)
4. Lire(U0)
5. Ecrire(« raison ?»)
6. Lire(r)
7. Ecrire(« les termes U0, U1, …U10 sont: »)
8. Pour n=1 à 10
9. U terme(n, r, U0)
10. Ecrire(U)
11. Ecrire(« »)
12. Suivant n
13. Fin
Exercice2 : Ecrire une fonction Maximum(T, n) qui permet de trouver le maximum d’un
tableau d’un certain nombre de valeurs. Ecrire un algorithme test qui appelle cette fonction.
Solution
Maximum(T(): réel, n : entier)
Var Max : reél
Var i : entier
Max T(0)
POUR i 1 à n-1
SI(T(i) > Max) ALORS
Max T(i)
FIN SI
suivant i
Renvoyer(Max)
28
Introduction à L’algorithmique 2013/2014
Tableau V( ) : réels
Var M : reél
Var N, k : entiers
Début
Ecrire(‘’’N=‘’)
Lire (N)
Dim(V, N)
POUR k 0 à N-1
Ecrire(« donner la valeur », k)
lire(V(k))
SUIVANT k
M Maximum(V, N)
Ecrire(« le max est : », M)
Les procédures sont des sous-programmes qui ne retournent aucun résultat. Par contre elles
admettent des paramètres d’entrés, de sorties ou d’Entrés/Sorties.
Syntaxe en pseudo-code
Exercice-1 :
Ecrire une procédure permute(a, b) qui permute les valeurs de ceux variables entiers.
Ecrire une autre procédure Tri (x, y, z) qui tri dans l’ordre croissant en appelant la procédure
permute(a, b). Ecrire un algorithme d’essai.
Solution :
Permuter (a : entier, b: entier)
Début
Var k : entier
Ka
ab
bk
Fin
29
Introduction à L’algorithmique 2013/2014
Trier (x: entier, y : entier, z : entier)
Début
Si (x<y) alors
Permuter(x, y)
Fin si
Si (y<z) alors
Permuter(y, z)
Fin si
Si (x<y) alors
Permuter(x, y)
Fin si
Fin
Attention!!!!
Dans le langage C la permutation ne va pas s’effectuer à cause des noms des paramètres
fictifs et formels qui ne sont pas les mêmes. Dans ce cas les adresses de ces paramètres seront
différentes. Par conséquent La permutation va se faire seulement pour les valeurs stockées
dans les adresses des paramètres fictifs.
Pour surmonter ce problème on propose deux solutions :
Prendre les mêmes noms des paramètres ce qui est impossible dans ce cas.
Copier dans les paramètres d’entrées les adresses des variables et non pas les valeurs
donc nécessité d’utiliser les pointeurs
Exercice-2 :
Créer une fonction max2(a, b) qui renvoi le maximum de deux variables:
Créer une fonction VMAX(T) qui permet trouver le maximum des éléments d’un vecteur de 4
valeurs et ceci en appelant la fonction max2().
Créer un algorithme d’essai.
30
Introduction à L’algorithmique 2013/2014
Solution :
VMAX(T(3)): réel
Début
Var M :réel
M Max2(Max2(Max2(T(0), T(1)),T(2)),T(3))
Renvoyer (M)
Afin de pouvoir manipuler les adresses mémoires, nous utilisons les pointeurs. Ces derniers
sont des variables qui contiennent l’adresse des variables d’un certain type. On parle des
pointeurs d’entiers des pointeurs des réels etc….
Il y a deux façons pour manipuler les adresses des variables
En déclarant une variable d’un certain type de valeur. L’adresse sera manipuler par
« &nomvariable » tandis que la valeur stockée dans cette adresse sera donnée par
« nomvariable »
Syntaxe:
Var x : entier
Lire(x)
Ecrire (« l’adresse de x est : &x)
Ecrire (« la valeur de x est : x)
31
Introduction à L’algorithmique 2013/2014
En déclarant un pointeur sur une variable d’un certain type. L’adresse sera manipulée par
« nompointeur » et la valeur stockée dans cette adresse est donnée par « *nompointeur »
Syntaxe:
Var x : entier
Var p : pointeur_entier
Lire(x)
P = &x
Ecrire (« l’adresse de x est : p)
Ecrire (« la valeur de x est : *p)
32
Introduction à L’algorithmique 2013/2014
Exemple de Récursivité
n! = 1*2*…..*(n-1)*n
33
Introduction à L’algorithmique 2013/2014
n! = n*(n-1)!
Pour calculer la valeur de n!, il suffit donc de savoir calculer (n-1)! Et ensuite de multiplier
cette valeur par n.
Le sous problème du calcul (n-1)! Est le même problème initial, mais pour un cas « plus
simple » car (n-1 < n)
7.7.1 Exemples
7.7.1.1 Fonction Factoriel
Ecrire l'algorithme de la fonction factorielle en employant les deux méthodes itérative et
récursive.
Algorithme : principal
var N : entier
Début
Ecrire(« donner la valeur de N »)
Lire(N)
Ecrire(N, ‘’!=’’, FACT(N))
Fin
Fin Algo
34
Introduction à L’algorithmique 2013/2014
Simulation: de du résonnement récursive pour N = 5
Fact(5)=5*Fact(4)
=5*4*Fact(3)
=5*4*3*Fact(2)
=5*4*3*2*Fact(1)
=5*4*3*2*1
On constate que la récursivité ne porte pas sur la variable principale du problème A (variable
dont on cherche la racine : A) mais la récursivité porte sur une autre variable X
Solution :
1. Var Z réel
2. Ecrire(‘’Z=‘’)
3. lire(Z)
4. Ecrire(‘’la racine carré de’’, z, ‘’est’’, racine(Z, 1))
5. Fin
35
Introduction à L’algorithmique 2013/2014
Simulation A=2, X=1
Ecrire une fonction récursive « RecMax(V, n) » qui renvoi le maximum des valeurs d’un
tableau V de dimension n. cette fonction aura pour argument les éléments du vecteur V et la
dimension n
Solution
36
Introduction à L’algorithmique 2013/2014
7.7.1.4 Recherche du Maximum avec la Méthode de diviser pour régner
Pour trouver le maximum des valeurs d’un tableau de dimension n (V(0..n-1)) en utilise la
méthode « diviser pour régner ». Cette méthode se compose de trois étapes
Algorithme :
On suppose qu’on dispose d’une fonction Max() qui permet de trouver la maximum de deux
valeurs.
Soit les variables :
Deb : indice du premier élément du tableau
Fin : indice du dernier élément du tableau
Med : indice du milieu d tableau
Max1 : le maximum du premier demi-tableau
Max2 : le minimum du deuxième demi-tableau
Il existe plusieurs méthodes de tri qui se différencient par leur complexité d'exécution et leur
complexité de compréhension pour le programmeur.
Le tri à bulles
37
Introduction à L’algorithmique 2013/2014
Dans ces deux méthodes de tri, on doit utiliser une procédure qui permet d'échanger (de
permuter) la valeur de deux variables.
8.1 Le tri par la méthode du Min ou Max successif (Tri par sélection)
Cette méthode consiste à parcourir le tableau de gauche à droite, on cherche le plus petit
élément puis on le positionne dans l’indice i du tableau. On recommence la même opération
pour le sous-tableau de droite qui commence par l’indice i+1.
Par exemple, pour trier [221, 215, 130, 163, 147, 120] suivant un ordre croissant, on va avoir
les boucles suivantes :
- une fonction Index_min() qui soit capable de déterminer l’indice du petit élément d'un
tableau à partir d'un certain rang.
- Une procédure Tri() qui appelle la fonction Index_Min() pour trouver l’indice i_min
correspondant au minimum puis permute l’élément i_min avec l’élément i.
38
Introduction à L’algorithmique 2013/2014
Pmin rang i_min Index_min(T, N, i)
Pour i rang+1, n-1 si(i <> i_min) alors
si V(i)<Min alors k V(i)
Min V(i) V(i) V(i_min)
pmin i V(i_min) k
fin si Fin si
Suivant i Suivant i
Renvoyer(pmin) Fin procédure
Fin fontion
Algo test
Tableau Tab() : entiers
Var i, D : entiers
Début
Ecrire(« donner le nbre de valeurs)
Lire(D)
Dim(tab, D)
Pour i 0, D-1
Ecrire(« Tab() », i)
lire(Tab(i))
Suivant i
Tri(tab, D)
Pour i 0, D-1
Ecrire(Tab(i))
Suivant i
Par exemple, pour trier [130, 156, 213, 230, 300] suivant un ordre décroissant, on va avoir les
boucles suivantes :
39
Introduction à L’algorithmique 2013/2014
i=2 ; ………….
40
Introduction à L’algorithmique 2013/2014
Recherche(T(), X, Nb)
Var i, R : entier
i0
Tant que (i<=Nb-1 ET T(i) <> X) Alors
i i+1
Fin tant que
Si (i = Nb) alors
Ecrire (« le nombre est introuvable »)
Sinon
Ecrire (« le nombre de trouve dans l’indice »)
Renvoyer (i)
FinFonction
Recherche(T(), X, Nb)
Var i, R : entier
i0
Tant que (i<=Nb-1 ET T(i) < X) Alors
i i+1
Fin tant que
Si (i = Nb) alors
Ecrire (« le nombre est introuvable »)
Sinon
Ecrire (« le nombre de trouve dans l’indice »)
Renvoyer (i)
Fin
Une personne choisi un nombre compris entre 1 et 100, on doit deviner ce nombre. Nous
allons faire des propositions et la personne répond "trop grand", "trop petit" ou "gagné". Le
jeu s’arrête lorsqu’on va trouver le nombre.
41
Introduction à L’algorithmique 2013/2014
Var X, N, P
Ecrire (« donner un nombre entre 0 et 100)
Lire (N)
Lire (P)
Tant que (P <> N) faire
Si (P > N) alors
Ecrire (« trop grand »)
Sinon
Ecrire (« trop petit »)
Fin Si
Lire (P)
Fin tant que
Ecrire (« gagné »)
Si on procède avec cette méthode, nous allons passer beaucoup de temps à chercher le nombre
caché. Quelles techniques de jeu peut-on employer pour gagner le plus rapidement possible ?
42
Introduction à L’algorithmique 2013/2014
Cette méthode est identique à la précédente seulement les valeurs proposées seront proche du
milieu des intervalles [Min..Max]. la proposition va être donc trouvée dans un traitement dans
l’algorithme.
Chaque fois qu’on propose un nombre on limite plus l’intervalle de recherche en écrasant les
valeurs de Min et Max.
Simulation
Le nombre caché est 72
Min Max Proposition milieu
43
Introduction à L’algorithmique 2013/2014
On peut éliminer tout d’abord les cas où f(a)=0 ou f(b)=0. L’existence d’une racine sur
l’intervalle ] [ est subordonnée au fait que f(a) et f(b) sont de signe contraires, ce qui
équivaut à ( ) ( ) , et que f est continue sur [a,b].
Si P est un réel de ] [, la position X0 par apport à P peut être testée par l’algorithme
suivant :
Si ( ) ( ) alors
Chercher X0 dans ] ]
Sinon
Chercher X0 dans ] ]
Pour trouver la solution le plus rapidement possible nous allons utiliser la méthode de
dichotomie. On prendra pour P le milieu de [a, b].
On itérera le processus jusqu’à obtenir par exemple ( ) avec
44
Introduction à L’algorithmique 2013/2014
10 Complexité Algorithmique
Différents algorithmes, donnant le même résultat, ont des couts différents en termes de temps
d'exécution (nombre d'opérations effectuées par l'algorithme) et taille mémoire (taille
nécessaire pour stocker les différentes structures de données pour l'exécution). Le but d’un
algorithme est de proposer une solution à un problème posé, en minimisant le temps de
traitement et la taille de mémoire consommée. Ces deux concepts sont appelés la complexité
en temps et en espace de l'algorithme.
Il existe plusieurs méthodes pour analyser la performance d’un algorithme. Par exemple on
peut citer l’analyse moyenne et l’analyse pessimiste. L’analyse pessimiste est la plus
courante. Elle informe sur le nombre de calculs à prendre en compte dans le pire des cas.
Contrairement à l’analyse moyenne, qui informe sur le temps moyen des calculs.
Dans un algorithme de recherche d’une donnée parmi N données initiales on doit parcourir,
dans le pire des cas, toutes les données. L’analyse pessimiste indique que la recherche
effectue N comparaison. Dans ce cas la complexité est dite linéaire et elle notée O(N). la
notation O formalise que l’analyse de performance porte sur la limite supérieure.
L’intérêt principal de cette analyse pessimiste est d’évaluer les algorithmes dans leur
fonctionnement extrême. Le pire des cas est connu à l’avance.
2. Le temps d'une séquence d'instructions est la somme des TE des instructions qui la
composent.
45
Introduction à L’algorithmique 2013/2014
3. le temps d'un branchement conditionnel est égal au TE du test plus le max des deux TE
correspondant aux deux alternatives (dans le cas d'un temps max).
4. Le temps d'une boucle est égal au coût du test de sortie de boucle plus le corps de la
boucle.
Var T : Entier
Début
T a
ab
bT
fin
début
R <-- 0
i <-- 1
TantQue i <= n Faire
R <-- R+T[i]
i <-- i+1
FinTantQue
Fin
46
Introduction à L’algorithmique 2013/2014
Puisque t1, t2, t3 et t4 sont des constantes qui ne dépendent pas du nombre de données n
L’algorithme est donc asymptotiquement linéaire en n. Cet algorithme à une complexité O(n).
R <-- 0
i <-- 1
TantQue i <= N Faire
R <-- R+T[i]
Si R>1000 Alors
R<-- 2*R
FinSi
i <-- i+1
FinTantQue
t1 : affectation
t2 : test
t3 : somme
t4 : incrémentation
t5: multiplication
47
Introduction à L’algorithmique 2013/2014
Renvoyer (res)
Fin
t1: test
t2: multiplication
Dans le cas d’un traitement récursif les deux branchements vont être exécutés
T(n) = t1 + t2 + T(n-1)
B<--0
i <--1
Pour i <-- 1 à n Faire
B<--B+2
Pour j <-- 1 à n Faire
T[i,j] <-- (1+T[i,j])*B
Suivant j
Suivant i
Soient :
t1: affectation
t2: somme
t3: test
t4: multiplication
t5: incrémentation
48
Introduction à L’algorithmique 2013/2014
49
Introduction à L’algorithmique 2013/2014
Le Pire des cas est celui où l’élément cherché est absent du tableau. On va effectuer n tests:
T(n)=n*C
La complexité est donc linéaire : O(n).
Le temps d’exécution est proportionnel aux nombres de données. Il existe un algorithme plus
efficace
Recherche dichotomique :
N=2k
Donc
50
Introduction à L’algorithmique 2013/2014
11 Conclusion
La qualité d’un algorithme est garantie par deux points essentiels. Le premier est la
Maintenabilité de l’algorithme c.-à-d. un algo facile à comprendre à coder et à déboguer.
Deuxième point c’est la rapidité de l’exécution c.-à-d une complexité minimale. En générale
on Privilégie le deuxième point sur le premier uniquement si on gagne en complexité. On
faire également attention à la précision, la stabilité et la sécurité des résultats.
Enfin pour trouver un algorithme pour résoudre un problème il faut suivre plus ou
moins les étapes suivantes :
Prendre un exemple
Voir intuitivement comment résoudre le problème.
essayer de généraliser ces opérations pour obtenir les principes généraux de votre
algorithme.
traduire ces principes en pseudo-code. Si besoin, décomposez le problème en sous
problèmes que vous traitez indépendamment.
51