Notion de Complexité

Notion de Complexit´e 1
1 Probl´ematique
Les donn´ees num´eriques trait´ees par les odrinateurs sont de plus en plus nombreuses et volumineuses. Pour traiter
efficacement ces donn´ees il faut surmonter 3 grandes difficult´es :
1. Un probl`eme de place :
On consid`ere un litre de gaz `a dans les conditions normales de temp´erature et de pression (p= 1 bar et T= 25 ◦C).
On souhaite mod´eliser le mouvement des particules qui constituent ce syst`eme gazeux. Pour cela on doit disposer
de la position de chaque particule `a t=0 (rep´er´ees par xi,yi,zi), de la vitesse de chaque particule `a t=0 (not´ees
par vxi,vyi,vzi) et d’un mod`ele (par exemple le mod`ele des gaz parfaits). Chaque donn´ee num´erique est entr´ee
comme un flottant cod´e sur 64 bits
◮Quelle est la m´emoire n´ecessaire (exprim´ee en octets) pour stocker les valeurs num´eriques associ´ees aux
positions et aux vitesses des particules ?
2. Un probl`eme de temps :
Lancer le script harmonique complexite.py avec une dur´ee d’observation de 10 s. Ce script r´ealise la r´esolution
num´erique de l’´equation d’un oscillateur harmonique par la m´ethode d’Euler.
◮Commenter le r´esultat obtenu.
3. Un probl`eme de pr´ecision :
◮Le script suivant a-t-il une fin ?
2 Estimation de la complexit´e temporelle d’un algorithme
La dur´ee d’execution d’un programme d´epend du nombre d’op´erations qu’il doit r´ealiser (et de l’ordinateur sur
lequel on travail). Lorsque l’ordinateur effectue un grand nombre d’op´erations, la dur´ee des calculs peut rapidement
devenir un param`etre qu’il faut prendre en compte dans le choix de l’algorithme. Afin de pr´evoir comment ´evolue la
dur´ee du calcul en fonction du nombre nque le programme doit traiter on peut r´ealiser une estimation (plus ou moins
d´etaill´ee) de sa complexit´e.
Pour estimer la complexit´e temporelle d’un algorithme, on identifie une op´eration fondamentale effectu´ee par l’ordi-
nateur et on estime, en fonction de n, le nombre de fois que cette op´eration est r´ealis´ee.
D´ependance en n complexit´e temporelle
Temps constant O(1)
Lin´eaire O(n)
Quadratique O(n2)
logarithmique O(log n)
Exemples :
1. Pour chacune de ces fonctions indiquer le r´esultat si n= 3
2. Estimer la complexit´e temporelle de chacun de ces algorithmes

Notion de Complexit´e 2
Complexit´e dans le meilleur et dans le pire des cas
Pour deux s´eries de donn´ees de mˆeme taille nun algoritme n’effectue pas n´ecessairement le mˆeme nombre
d’op´erations.
◮D´efinir la fonction recherche (vue en cours) qui permet savoir si un ´el´ement appartient `a une liste.
◮Quelle est sa compl´exit´e.
◮Modifier l’algorithme pour que celui-ci s’arrˆete d`es que l’´el´ement de la liste est trouv´e.
On voit sur cet exemple que, si on a de la chance, l’´el´ement recherch´e sera trouv´e d`es le d´ebut et l’algorithme ainsi
modifi´e s’arrˆetera. Au contraire, si l’´el´ement recherch´e n’appartient pas `a la liste, la boucle for s’ex´ecutera jusqu’au
dernier ´el´ement de la liste. On peut alors nuancer l’estimation de la complexit´e temporelle d’un algorithme en parlant
de compl´exit´e dans le pire des cas (qui est un majorant de la complexit´e) et dans le meilleur des cas (qui est un
minorant souvent moins int´eressant).
◮Reprendre l’algorithme pr´ec´edent et d´eterminer la complexit´e dans le meilleur et pire des cas.
3 Exercices :
Exercice 1 Recherche d’un mot dans une chaˆıne de caract`eres
1. D´efinir une fonction recherche mot qui prend comme arguments un mot et un texte et renvoie la position de
la premi`ere occurence du mot choisi dans le texte ´etudi´e s’il existe et False sinon.
2. Analyser la compl´exit´e de l’algorithme propos´e dans le meilleur et le pire des cas.
Exercice 2 Recherche dans un tableau tri´e
On cherche `a d´eterminer si un tableau tri´e contient une certaine valeur.
1. Pour cela on peut utiliser la fonction recherche qui va r´ealiser une analyse s´equentielle du tableau.
Rappeler la complexit´e de la fonction recherche
2. Dans le cas sp´ecifique d’un tableau tri´e, on peut utiliser aussi utiliser une m´ethode dichotomique. D´efinir une
fonction recherche dichotomique qui renvoie les mˆemes informations que la fonction pr´ec´edente mais exploite
par dichotomie la liste tri´ee.
3. On note nla longueur du tableur et {gk, dk}les bornes gauche et droite de l’intervalle encadrant la valeur
cherch´ee `a la keit´eration. Montrer que
dk−gk<n
2k
4. En d´eduire la complexit´e de la recherche dichotomique.
Exercice 3 Produit matriciel
1. Cr´eer les matrices :
A=
1 2 3
2 4 6
2 1 0
B=
−1 2 −3
−2 4 −6
−2 1 0
2. D´efinir une fonction matrice0 qui prend pour arguments un nombre de lignes et un nombre de colonnes et
renvoie une matrice uniquement constitu´ee de z´eros.
3. Etudier la est la complexit´e de cette fonction ?
4. D´efinir une fonction prod matrice prend pour argument deux matrices et qui renvoie le produit de ces deux
matrices.
5. V´erification de l’algorithme :
– afficher le type de A et B,
– importer le module numpy
– changer le type de A et B en array `a l’aide de la fonction array du module numpy,
– effectuer le produit matriciel avec la fonction dot du module numpy
Rq : Vous pouvez aussi tester l’effet de A×B en fonction du type de A et B (list ou array)
6. Analyser la compl´exit´e de l’algorithme propos´e.