Chapitre 1 - Algorithmique Et Complexitã©

Algorithmique et
complexité
1
1. Introduction
 Un algorithme est une suite finie d’opérations
élémentaires constituant un schéma de calcul ou de
résolution d’un problème.
 Le temps d’exécution d’un algorithme dépend des
facteurs suivants :
• Les données du programme: généralement lorsque
la taille des données traités par le programme
augmente son temps d’exécution augmente aussi.
Exemple: le tri d’un tableau de 10 éléments prend
un temps inferieur au temps du tri d’un tableau de
100 éléments.
• La qualité du compilateur (langage utilisé):
Exemple: les programmes écrits en Java sont

généralement plus lents que ceux écrits en C ou en
2
C++.
2. Notion de la complexité
Définition: La complexité d’un algorithme est la

mesure du nombre d’opérations élémentaires qu’il
effectue sur un jeu de données. La complexité est
exprimée comme une fonction (f(N), C(N), …) de la taille
du jeu de données.
Opération élémentaire: Une opération élémentaire est

une opération dont le temps d’exécution est
indépendant de la taille n des données tel que:
- l’affectation : x 3
- la lecture : lire (x)
- l’écriture : écrire (x);
- la comparaison (<, >, =,…): if (x<8)
- les opérations arithmétiques ...etc. Z= x+y
3
2. Notion de la complexité
La taille de données N: est le nombre des éléments traités par

l’algorithme.
Exemples:
- Dans le cas de tri d’un tableau, N est le nombre d’éléments
du tableau.
- Dans le cas de calcul d’un terme d’une suite, N est l’indice
du terme
- Dans le cas de calcule de la somme des éléments d’une
matrice de n*m éléments, la taille de données est n*m.
4
2. Notion de complexité
Objectif
 On cherche à mesurer la complexité d’un
algorithme indépendamment de la machine et du
langage utilisés, c-à-d uniquement en fonction de
la taille des données N que l’algorithme doit traiter.
 L’objectif est donc de trouver la fonction (f(N), C(N)
…) qui exprime le nombre d’opérations effectuées
par l’algorithme en fonction de la taille de données
N.
Exemple:
 F(n) = 3n+6
 C(n)= 4n2
5
Exemple 1:
Algorithme: somme
Cet algorithme calcule la somme des N
N, i, S : entier premiers entiers.
La taille des données est N.
Début
L’algorithme somme effectue:
i 1;
S 0; 2 affectations ( i  1, S0))
N + 1 comparaison ( i<=N);
Tantque i <=N faire
N additions (s+i);
S  S+i; N affectations (S S+i);
N additions (i+1);
i  i+1;
N affectations (ii+1);
Fintantque
Ecrire (s);
1 affichage (écrire (s)):
fin
6
5N+4 opérations élémentaires
f(n) = 5N+4
1.3 Pourquoi calculer la complexité des

algorithmes:
1.Calculer le temps et l’espace mémoire
nécessaire pour l’exécution d’un programme.
2.Vérifier si un algorithme est exécutable dans un

temps raisonnable.
3.Comparer deux algorithme résolvant le même

problème pour choisir le meilleure.
4.Vérifier si un algorithme est optimal. C.-à-d.

vérifier s’il existe ou non un algorithme plus
7
3. Règles de calcul de la complexité d’un
algorithme
1)Instruction simple: le nombre d’opérations

élémentaires dans l’instruction.
Exemple: dans l’instruction y 3+5*x; nous avons 3
opérations élémentaire, une affectation, une addition
et une multiplication.
2)Séquence d’instructions: La complexité d’une
séquence d’instructions égale la somme des
complexités des instructions de la séquence .
Exemple: lire (x);
lire (y); 5 opérations
zx+y;
écrire (z);
8
algorithme
3) La complexité d’une conditionnelle

La complexité d’une instruction <si – alors – sinon>
égale la somme de la complexité de l’évaluation de la
condition et la plus grande complexité entre le bloc
alors et le bloc sinon.
La complexité = C1+ max (C2, C3)
Si (condition) alors Où :
bloc alors
……..…. • C1 est le nombre d’opérations
exécutées pour l’évaluation de la
Sinon bloc sinon
condition.
………… • C2 est le nombre d’opérations
Finsi exécutées si la condition est vrai (le
bloc alors )
9 • C3 est le nombre d’opérations
algorithme
4) La complexité d’une boucle: La complexité d’une
boucle égale la somme, sur toutes les itérations, de la

complexité de l’évaluation de la condition de sortie et la
complexité du bloc d’instructions du corps de la boucle.
- Dans cette boucle nous avons N itérations
Exemple
Lire (N); i=1; - La comparaison i<=N s’effectue N+1 fois (N
Tantque i<=N faireitérations de la boucle plus une fois pour sortir de la
S=s+i; boucle)
i=i+1;
- Dans le bloc d’instruction nous avons 4 instructions
Fin Tantque
chacune s’effectue N fois.
- La complexité de la boucle est donc 5N+1
10
algorithme
5) Sous programmes (fonctions et

procédures)
La complexité de l’appel d’un sous programme égale la
somme des complexités de ses instructions.
11
4. Complexité des algorithme récursive
La complexité d’un algorithme récursif se fait

par raisonnement et démonstration par récurrence.
Exemple
 Soit la fonction récursive suivante :
fonction factorielle(n :entier): entier
début
Op1
Si n=0 alors
retourneOp2
1;
Sinon
Op3 Op4 Op5
retourne (n* factorielle(n-1))
fin si
fin
12
Posons C(n) le temps d’exécution nécessaire pour un appel

à factorielle (n). 5 opérations
C (0) = Op1+ Op2 = 2

C(1) = Op1 +Op3+ Op4+ Op5+ C(0) = b + C(0) ( b= Op1 +Op3+
Op4+ Op5+ Op6)
C(2) = Op1 +Op3+ Op4+ Op5+ + C(1) = b + b + C(0) = 2b+ C(0)

C(3) = Op1 +Op3+ Op4+ Op5+ C(2) = 3b+ C(0)
.
.
C(n-1)= (n-1) b +C(0)
C(n) = Op1 +Op3+ Op4+ Op5+C(n-1)=
=4n+2
= b + (n-1) b +C(0) = n .b +C(0)
Donc
13 la complexité de la fonction factorielle est en O(n).
Exercice:
Soit la fonction produit suivante qui calcule le
produit x*a. Evaluer sa complexité.
fonction produit(x, a :entier): entier
début
Si a=0 alors
retourne 0;
Sinon
Si a=1 alors
retourne x;
Sinon
retourne (x+ produit(x, a-1))
fin si
fin si
fin
14
5. Complexité au mieux et au pire
Exemple: recherche séquentielle d'un élément

dans un tableau de n entiers
Fonction recherche Élément(n, x: entier, tab: tableau

d’entier): booléan
i: entier; b: booléan;
début
i  1; bfaux;
tantque (i <= n) et (b=faux) faire
si (tab[i] = x) alors
b=vrai;
finsi
ii+1;
fintantque
retourne b;
Fin
 Le paramètre de complexité est la taille du tableau d'entrée.
15
 Le nombre de tours de boucles varie selon que x est dans le
 Si x est dans la première case du tableau : 1 tour
de boucle avec la condition b=vraie
 Si x est dans la deuxième case du tableau : 1 tour
de boucle avec la
b= faux et 1 tour de boucle avec b= vrai
...
 Si x est dans dernière case du tableau : N-1 tours
de boucle avec la b= faux et 1 tour de boucle avec b=
vrai.
 Si x n'est pas dans le tableau : N tours de boucle
avec la condition b= faux.
16
Lorsque, pour une valeur donnée du paramètre de

complexité, le temps d'exécution varie selon les
données d'entrée, on peut distinguer:
 La complexité au pire : temps d'exécution
maximum, dans le cas le plus défavorable.

 La complexité au mieux : temps d'exécution
minimum, dans le cas le plus favorable (en

pratique, cette complexité n'est pas très utile).
 La complexité moyenne : temps d'exécution
17 dans un cas médian, ou moyenne des temps

6. La notation landau (O)
 Soit la fonction T(n) qui représente l’évolution

du temps d’exécution d’un programme P en
fonction du nombre de données n. Par
exemple :
T(n) = a n2
 On dit dans l’exemple précédent que la

complexité de P est O(n2). Cela veut dire qu’il
existe une constante C positive tel que pour n
suffisamment grand on a :
T(n) ≤ Cn2
 Cette notation donne une majoration du

nombre d’opérations exécutées (temps
18
d’exécution) par le programme P. Un
6. La notation landau (O)
Exemple:
Soit la fonction f(n) qui représente le temps
d’exécution d’un programme P. f (n) = n3 +
3n + 6
si n=10 et c=2 on obtient:
f (n)= 103 + 3*10 + 6 = 1036 ≤ 2 *

103 = 2000
On dit que la complexité de P est O(n3).
Parce que il existe une constante c positive

(c=2) tel que pour n suffisamment grand
(N=10) on a :
19 n3 + 3n + 6 ≤ cn3
7. Classes de complexité algorithmique
1. T(n) = O(1), temps constant : temps d’exécution
indépendant de la taille des données à traiter.
2. T(n) = O(log(n)), temps logarithmique : on rencontre

généralement une telle complexité lorsque
l’algorithme casse un gros problème en plusieurs
petits, de sorte que la résolution d’un seul de ces
problèmes conduit à la solution du problème initial.
3. T(n) = O(n), temps linéaire : cette complexité est

généralement obtenue lorsqu’un travail en temps
constant est effectué sur chaque donnée en entrée.
4. T(n) = O(n.log(n)) : l’algorithme scinde le problème

en plusieurs sous-problèmes plus petits qui sont
résolus de manière indépendante. La résolution de
l’ensemble de ces problèmes plus petits apporte la
20
solution du problème initial.
5. T(n) = O(n2), temps quadratique : apparaît

notamment lorsque l’algorithme envisage toutes les
paires de données parmi les n entrées (ex. deux
boucles imbriquées)
Remarque : O(n3) temps cubique, O(nk )polynomial
6. T(n) = O(2n), temps exponentiel : souvent le résultat

de recherche brutale d’une solution.
21
Les temps d’exécution selon la taille de donnée.
NB: chiffres pour une machine pouvant effectuer 106 opérations par
seconde
22

Chapitre 1 - Algorithmique Et Complexitã©

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 1 - Algorithmique Et Complexitã©

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

Chapitre 1 - Algorithmique Et Complexitã©

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique et

Exemple: les programmes écrits en Java sont

Définition: La complexité d’un algorithme est la

Opération élémentaire: Une opération élémentaire est

La taille de données N: est le nombre des éléments traités par

1.3 Pourquoi calculer la complexité des

2.Vérifier si un algorithme est exécutable dans un

3.Comparer deux algorithme résolvant le même

4.Vérifier si un algorithme est optimal. C.-à-d.

1)Instruction simple: le nombre d’opérations

3) La complexité d’une conditionnelle

4) La complexité d’une boucle: La complexité d’une

boucle égale la somme, sur toutes les itérations, de la

5) Sous programmes (fonctions et

La complexité d’un algorithme récursif se fait

Posons C(n) le temps d’exécution nécessaire pour un appel

C (0) = Op1+ Op2 = 2

C(2) = Op1 +Op3+ Op4+ Op5+ + C(1) = b + b + C(0) = 2b+ C(0)

Exemple: recherche séquentielle d'un élément

Fonction recherche Élément(n, x: entier, tab: tableau

Lorsque, pour une valeur donnée du paramètre de

maximum, dans le cas le plus défavorable.

minimum, dans le cas le plus favorable (en

17 dans un cas médian, ou moyenne des temps

 Soit la fonction T(n) qui représente l’évolution

 On dit dans l’exemple précédent que la

 Cette notation donne une majoration du

f (n)= 103 + 3*10 + 6 = 1036 ≤ 2 *

On dit que la complexité de P est O(n3).

Parce que il existe une constante c positive

2. T(n) = O(log(n)), temps logarithmique : on rencontre

3. T(n) = O(n), temps linéaire : cette complexité est

4. T(n) = O(n.log(n)) : l’algorithme scinde le problème

5. T(n) = O(n2), temps quadratique : apparaît

6. T(n) = O(2n), temps exponentiel : souvent le résultat

Vous aimerez peut-être aussi

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

f (n)= 103 + 310 + 6 = 1036 ≤ 2