Module: Algorithmique & Structures de Données Licence Fondamentale SMA, S4

Module: Algorithmique & Structures de données
Licence Fondamentale SMA, S4
Pr. Abdelkaher AIT ABDELOUAHAD
Département d’Informatique
Faculté des Sciences, Université Chouaib Doukkali
El Jadida
a.abdelkaher@gmail.com
01 Mars 2023
Pr. A. AIT ABDELOUAHAD Informatique 4

Pré requis
Informatique 2 (Algorithmique)
Informatique 3 (Programmation en langage C)

Objectifs du cours
Étudier les structures de données les plus utilisées en

programmation
Être capable de choisir la structure adéquate à chaque

problème
Être familiarisé à la résolution des problèmes algorithmiques
Pouvoir implémenter les structures de données en C

Contenu
La complexité des algorithmes
Structures en C
Type abstrait de données
Liste chaînée
Pile
File
Arbre

Partie 1 : Complexité des algorithmes

Plan
1 Algorithmes
I Représentations des algorithmes
I Codage d’un algorithme
I Opérations élémentaires
2 Complexité
I Notions de complexité
I Complexité en temps
I Types de complexité
I Notations en O
I Notations en Θ
I Complexité d’un algorithme récursif
I Échelle de complexité

Algorithmes
Un algorithme est une description complète et détaillée des
actions à effectuer et de leur séquencement pour arriver à un
résultat donné
I Intérêt : séparation analyse/codage (pas de préoccupation de
syntaxe)
I Qualités : exact (fournit le résultat souhaité), efficace (temps
d’exécution, mémoire occupée), clair (compréhensible), général
(traite le plus grand nombre de cas possibles),...
L’algorithmique désigne aussi la discipline qui étudie les
algorithmes et leurs applications en Informatique
Une bonne connaissance de l’algorithmique permet d’écrire des
algorithmes exacts et efficaces
Exemples :
I Une recette de cuisine est un algorithme, l’entrée étant les
ingrédients et la sortie le plat cuisiné.
I L’algorithme d’Euclide : c’est un algorithme permettant de
déterminer le plus grand commun diviseur (P.G.C.D.) de deux
entiers
Représentations des algorithmes
Historiquement, deux façons pour représenter un algorithme :
L’organigramme : représentation graphique avec des symboles

(carrés, losanges, etc.)
I offre une vue d’ensemble de l’algorithme
I représentation quasiment abandonnée aujourd’hui
Le pseudo-code : représentation textuelle avec une série de

conventions ressemblant à un langage de programmation (sans
les problèmes de syntaxe)
I plus pratique pour écrire un algorithme
I représentation largement utilisée

Pseudo langage
Structures élémentaires d’un pseudo langage :

1 Entrées/Sorties : Lire, Écrire
2 Affectation : X ←Y
3 Instructions conditionnelles :
Si condition Alors instructions FinSi

Si condition Alors instructions1 Sinon instructions2 FinSi
4 Instructions répétitives (les boucles)
TantQue condition Faire instructions FinTantQue

Faire instructions TantQue condition
Pour i=0 à n Faire instructions FinPour

Pseudo langage
Calculer la factorielle de N
Ecrire("saisissez le nombre :")
Lire (N)
F←1
Pour I=1 à N Faire F← F × I
FinPour
Ecrire(F)
Remarque
Il n’existe pas de formalisme universel pour l’écriture d’un pseudo
programme.

Codage d’un algorithme
Traduire l’algorithme dans un langage de programmation pour

pouvoir l’exécuter sur un ordinateur.
Chaque instruction élémentaire sera traduite dans le langage

de programmation.
Il faut choisir la façon de représenter les données (structures

de données).
Pour résoudre un problème : nombreux algorithmes possibles.
Pour chaque algorithme : plusieurs choix de structures de

données.

Opérations élémentaires
étant donné un algorithme, nous appelons opérations

élémentaires :
1 un accès en mémoire pour lire ou écrire la valeur d’une
variable ;
2 une opération arithmétique entre deux variables : +,- ...etc ;
3 une comparaison entre deux variables.
Considérons par exemple l’instruction c ← a + b. Elle fait

appel à quatre opérations élémentaires :
1 l’accès en mémoire pour lire la valeur de a,
2 l’accès en mémoire pour lire la valeur de b,
3 l’addition de a et b,
4 l’accès en mémoire pour écrire la nouvelle valeur de c.

Notions de complexité
Plusieurs algorithmes permettent de résoudre un même

problème.
Exemple : Pour trier les éléments d’un tableau il y a différents

algorithmes :
1 tri par sélection,
2 tri par insertion,
3 tri rapide,
4 tri par fusion,
5 ....
Comment évaluer les performances d’un algorithme ?
Sur quel critère il faut se baser pour choisir le meilleur

algorithme ?

La différence entre les algorithmes peut ne pas être visible si la

taille des données est petite.
Cette différence augmente proportionnellement à la quantité

des données.
La complexité a été développée pour mesurer le degré de

difficulté d’un algorithme (le coût de l’algorithme).
La complexité permet de comparer l’efficacité des algorithmes.

La complexité d’un algorithme est une évaluation du coût de

l’algorithme en termes de :
1 temps d’exécution (complexité temporelle) ou
2 d’espace mémoire (complexité spatiale, encombrement en
mémoire des données)
On va traiter dans la suite la complexité temporelle. Les

mêmes notions permettent de traiter la complexité spatiale.
⇒ Le temps est beaucoup plus important que l’espace.
La complexité permet de déterminer si un algorithme A et

meilleur qu’un algorithme B.

Complexité en temps
Bonne maîtrise de la complexité se traduit par :

1 temps de calcul des applications prévisible,
2 mémoire occupée par l’application est contrôlée.
Mauvaise compréhension de la complexité débouche sur :

1 des latences importantes dans les temps de calcul,
2 des débordements mémoire,
3 conséquence : planter la machine.

L’évaluation exacte du temps de calcul dépend de nombreux

paramètres :
1 le langage utilisé pour coder l’algorithme (compilé ou

interprété).
2 le compilateur utilisé.
3 l’ordinateur sur lequel va tourner le programme (sa rapidité).
4 taille et structure de données.
5 ....

Pour évaluer un algorithme, une relation, entre la taille des

données n et le temps t nécessaire pour leur traitement, est
utilisée.
Pour une relation linéaire entre n et t tel que t1 = cn1

n2 = 5n1 → t2 = 5t1
Multiplication des données par 5 =⇒ Multiplication du temps

par 5.
Pour une relation non linéaire entre n et t : t1 = log2 n1

n2 = 2n1 → t2 = log2 (2n1 ) = t1 + 1
Multiplication des données par 2 =⇒ Augmentation du temps

par une unité (1).

La fonction d’efficacité f liant n et t est importante pour une

taille énorme de données.
Les termes qui influencent faiblement sur l’amplitude de f pour

une taille importante des données sont à éliminer.
I On garde uniquement une approximation de f.
I Cette approximation est plus proche à la fonction originale

lorsqu’on traite une grande quantité de données.
I Nous sommes plus intéressés par un comportement
asymptotique : que se passe-t’il quand la taille des données
tend vers l’infini ?
I Cette mesure d’efficacité est appelée : Complexité
asymptotique

Exemple illustratif : f (n) = n2 + 100n + log10 n + 1000

I La fonction f est composée de 4 termes : n2 , 100n, log10 n et
1000.
I Analyser la contribution de chaque terme en fonction de n
(taille de données)
I Pour des valeurs importantes de n la fonction f dépend

principalement de son premier terme n2 . Les autres termes
peuvent être ignorés.

Complexité : définition
Définition
Soit A un algorithme et d une donnée d’entrée de A. On appelle
complexité de A pour d, notée CA (d), le nombre d’opérations
élémentaires effectuées lors de l’exécution de A sur d.
Le nombre d’opérations est exprimé en fonction de paramètres

associés aux instances à traiter.
Exemple : la complexité d’un tri est fonction du nombre de

données à trier. La complexité n’est pas la même avec deux
jeux de données différents à savoir :
I rapide si des données sont déjà triées.
I moins rapide si les données sont désordonnées.

Types de complexité
1 La complexité dans le pire des cas : on considère le plus grand

nombre d’opérations élémentaires effectuées sur les données.
On cherche un majorant de la complexité
(SupA (n) = sup{CA (d)/d de taille n}). C’est la mesure la plus
utilisée.
2 La complexité dans le meilleur des cas : on considère le plus

petit nombre d’opérations élémentaires effectuées sur les
données (InfA (n) = inf {CA (d)/d de taille n}).
3 La complexité en moyenne : la moyenne des nombres

d’opérations élémentaires effectuées sur tous les jeux des
données. Ce calcul est généralement difficile à formuler car il
faut connaître la probabilité de chacun des jeux de données
pour un calcul pertinent de cette moyenne.

Calcul de la complexité dans le pire des cas
Exemple 1
1 K←0
2 I←0
3 TantQue I ≤ N Faire
I a. R←R+I
I b. I←I+1
4 FinTantQue
Supposons que (avec t1, t2, t3, et t4 sont des constantes) :

t1 : temps d’exécution des instructions 1-2.
t2 : temps d’exécution de l’instruction 3 (comparaison).
t3 : temps d’exécution de l’instructions a.
t4 : temps d’exécution de l’instructions b.

Calcul de la complexité dans le pire des cas
Le temps d’exécution
Pn t(n) pour N = n s’écrit :
t(n) = t1 + i=1 (t2 + t3 + t4) + t2
Soit tot le temps d’exécution d’une itération défini par

tot = t2 + t3 + t4 alors t(n) = t1 + t2 + n × tot
Le temps d’exécution dépend linéairement de la taille n

(fonction affine).
Comportement asymptotique : valeur de t(n) quand n tend

vers l’infini ?
t(n) est équivalente à tot × n lorsque n tend à l’infini.
L’algorithme est donc asymptotiquement linéaire en n.

Notations en O
Domination asymptotique
Soient f et g deux fonctions de N dans R∗+ , Si ∃c ∈ R∗+ et
∃n0 ∈ N∗ tels que ∀n > n0 , f (n) ≤ c × g (n) on dit que f est
asymptotiquement dominée par g
Pour deux fonctions f et g on dit que la fonction f est un

grand O de la fonction g ssi f est dominée asymptotiquement
par g .
On écrit : f (n) = O(g (n))
Example
f (n) = 3n + 1, g (n) = n alors 3n + 1 est un O(n).
En effet pour n0 = 2 et c = 4 on a 3n + 1 ≤ 4n pour n > n0

Notations en O
Exemple
Considérons la fonction
f (n) = 8n + 128.
Est ce que f (n) = O(n2 ) ?
Trouver un entier n0 et
c > 0 tel que pour n ≥ n0 ,
f (n) < cn2
Pour c = 1, f (n) ≤ cn2
→ 8n + 128 ≤ n2
→ 0 ≤ n2 − 8n − 128
→ 0 ≤ (n − 16)(n + 8)
→ n0 = 16
Sur la figure,g (n) = n2 est
supérieure à
f (n) = 8n + 128 à droite de
n = 16

Notations en O
Exemple
Considérons la fonction
f (n) = 8n + 128.
f (n) = O(n2 )
Autres valeurs de c et
n0 (figure) :
I c = 2 et n0 =
√
2 + 4 17 ≈ 10.2
I c = 4 et
√
n0 = 1 + 33 ≈ 6.7

Propriétés de O (BIG-O)
La notation O a des propriétés qui peuvent être utilisés pour

l’estimation de l’efficacité des algorithmes :
Transitivité : Si f (n) est O(g (n)) et g (n) est O(h(n)) alors

f (n) est O(h(n))
Si f (n) est O(h(n)) et g (n) est O(h(n)) alors f (n) + g (n) est
O(h(n))
La fonction f (n) = ank estO(nk )
La fonction f (n) = nk est O(nk+j ) pour chaque j positif
Si f (n) = cg (n), ∀c > 0 alors f (n) est O(g (n))

Notations en Θ
Ordre de grandeur
Soient f et g deux fonctions de N dans R∗+ , Si f est en O(g ) et g
est en O(f ) alors on dit que f est en Θ(g ) (f et g sont de même
ordre de grandeur asymptotique).
Exemple
f (n) = 3n + 1, g (n) = n alors 3n + 1 est en Θ(n).
En effet, d’une part 3n + 1 est en O(n), d’autre part pour n0 = 2
et c = 2
on a n ≤ 2 × (3n + 1) pour n > n0 et donc n est en O(3n + 1)

Propriétés
f est en Θ(g ) si et seulement si ∃c ∈ R∗+ , ∃d ∈ R∗+ ,

∃n0 ∈ N∗ tels que ∀n ∈ N∗ ,
n > n0 ⇒ d × g (n) ≤ f (n) ≤ c × g (n)
La notation Θ se ramène à un encadrement (à partir d’un

certain rang) de la quantité f .
f (n)
Si lim = a 6= 0 ⇒ f est en Θ(g )
n→∞ g (n)
f (n)
Si lim = 0 ⇒ f est en O(g ) mais f n’est pas en Θ(g )
n→∞ g (n)
f (n)
Si lim = ∞ ⇒ f n’est pas en O(g ) et donc f n’est pas
n→∞ g (n)
en Θ(g )

Propriétés
En pratique :
La fonction f représente une quantité à étudier (temps, nombre

d’opérations).
La fonction g fait partie d’une échelle de fonctions simples

(n, n × log2 (n), n2 , etc...) destinée à informer sur le
comportement asymptotique de f .
Les propriétés citées ci-dessus permettent dans la plupart des

cas d’évaluer f . On cherche l’équivalent de f à l’infini.
Exemple : f (n) = 3n + 1, 3n + 1 ∼ 3n et donc :
3n + 1
lim = 3 6= 0 ⇒ (3n + 1) est en Θ(n)
n→∞ n

Régles de calcul de la complexité (en pire)
La complexité est évaluée en temps ou en nombre d’opérations d’un

algorithme. Les règles générales sont :
Le temps d’exécution (TE) d’une affectation ou d’un test est

considéré comme constant c.
Le temps d’une séquence d’instructions = la somme des TE

des instructions qui la composent.
Le temps d’un branchement conditionnel = TE du test + le

max des deux TE correspondant aux deux alternatives.
Le temps d’une boucle = (le coût du test + le coût du corps

de la boucle)*(nombre d’itérations) + le test de la sortie de la
boucle.

Exemples de calcul de la complexité
Donner la complexité de l’algorithme suivant :

Soit Op(n) le nombre d’opérations
élémentaires, avec N = n
B←B+2 : 1 addition+1
Algorithme 1 affectation → 2 opérations
B←0 Op(n) = 1 + 1 + ni=1 (1 + 2 +
P
I←1 1) + 1 = 4n + 3
TantQue I ≤ N Faire 4n + 3
B ← B+2 lim = 4 ⇒ Op(n) est
n→∞ n
J←1 en Θ(n)
FinTantQue Op(n) = Θ(n)
On peut dire aussi que
Op(n) = O(n)

Exemples de calcul de la complexité
Deux boucles imbriquées sans dépendance des indices :
Soit Op(n) le nombre d’opérations
élémentaires, avec N = n
B←B+2 : 1 addition+1 affectation →
Algorithme 2 2 opérations
B←0
T[i,j] ← (1+T[j,i])×B : 1 addition + 1
I←1
multiplication + 1 affectation → 3
TantQue I ≤ N Faire
opérations
B ← B+2
Op(n) = 1 + 1 + ni=1 (1 + 2 + 1 +
P
J←1 P n 2
TantQue J ≤ N Faire j=1 (1 + 3) + 1) + 1 = 3 + 5n + 4n
T[i,j] ←(1+T[j,i])*B 3 + 5n + 4n2
lim = 4 ⇒ Op(n) est
FinTantQue n→∞ n2
2
en Θ(n )
FinTantQue
Op(n) = Θ(n2 )
On peut dire aussi que Op(n) = O(n2 )
Complexité d’un algorithme récursif
Factorielle d’un entier

fonction factorielle(n :entier) :entier
début
si n=0 alors
retourner 1
sinon
retourner n*factorielle(n-1)
finsi
fin

Complexité d’un algorithme récursif
Solution :
c1 : temps d’exécution pour le test et c2 : le temps

d’exécution pour la multiplication.
T (n = 0) = c1
T (n) = c1 + c2 + T (n − 1) ⇒ T (n) = n × c2 + (n + 1) × c1
Complexité O(n)
Les calculs de la complexité récursive induisent naturellement des

suites.

Échelle de complexité
Nous donnerons ici les ordres de grandeur et leur correspondance :
O(1) : constante. une instruction simple ou nombre fini

d’instructions.
O(log (n)) : logarithmique. Quand on part d’un grand

problème à un sous-problème plus petit par réduction.
O(n) : linéaire,
n × log (n)
O(n2 ), O(n3 ), O(np ) : polynomiales (quadratique, cubique,

...etc).
O(p n ) : exponentielle.

Fonctions utilisées pour l’estimation de la complexité
asymptotique

Influence de la complexité
Le tableau ci-dessous donne le temps d’exécution de cinq

algorithmes selon leur comportement et la taille des données ;
on suppose que la durée d’une instruction est de l’ordre de 1µs
(1 million d’instructions par seconde).

Le temps de traitement de 100 instructions :

I Algorithme quadratique : 10ms.
I Algorithme exponentiel : 3.17 × 107 années.

Le temps de traitement de 106 instructions :

I Algorithme quadratique : 11 jours.
I Algorithme exponentiel : 32000 années.

Module: Algorithmique & Structures de Données Licence Fondamentale SMA, S4

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

Module: Algorithmique & Structures de Données Licence Fondamentale SMA, S4

Transféré par

Droits d'auteur :

Formats disponibles

Module: Algorithmique & Structures de données

Licence Fondamentale SMA, S4

Pr. Abdelkaher AIT ABDELOUAHAD

Pr. A. AIT ABDELOUAHAD Informatique 4

Informatique 3 (Programmation en langage C)

Pr. A. AIT ABDELOUAHAD Informatique 4

Étudier les structures de données les plus utilisées en

Être capable de choisir la structure adéquate à chaque

Être familiarisé à la résolution des problèmes algorithmiques

Pouvoir implémenter les structures de données en C

Pr. A. AIT ABDELOUAHAD Informatique 4

La complexité des algorithmes

Type abstrait de données

Pr. A. AIT ABDELOUAHAD Informatique 4

Pr. A. AIT ABDELOUAHAD Informatique 4

Pr. A. AIT ABDELOUAHAD Informatique 4

Historiquement, deux façons pour représenter un algorithme :

L’organigramme : représentation graphique avec des symboles

I représentation quasiment abandonnée aujourd’hui

Le pseudo-code : représentation textuelle avec une série de

I représentation largement utilisée

Pr. A. AIT ABDELOUAHAD Informatique 4

Structures élémentaires d’un pseudo langage :

Si condition Alors instructions FinSi

4 Instructions répétitives (les boucles)

TantQue condition Faire instructions FinTantQue

Pr. A. AIT ABDELOUAHAD Informatique 4

Pr. A. AIT ABDELOUAHAD Informatique 4

Traduire l’algorithme dans un langage de programmation pour

Chaque instruction élémentaire sera traduite dans le langage

Il faut choisir la façon de représenter les données (structures

Pour résoudre un problème : nombreux algorithmes possibles.

Pour chaque algorithme : plusieurs choix de structures de

Pr. A. AIT ABDELOUAHAD Informatique 4

étant donné un algorithme, nous appelons opérations

Considérons par exemple l’instruction c ← a + b. Elle fait

Pr. A. AIT ABDELOUAHAD Informatique 4

Plusieurs algorithmes permettent de résoudre un même

Exemple : Pour trier les éléments d’un tableau il y a différents

Comment évaluer les performances d’un algorithme ?

Sur quel critère il faut se baser pour choisir le meilleur

Pr. A. AIT ABDELOUAHAD Informatique 4

La différence entre les algorithmes peut ne pas être visible si la

Cette différence augmente proportionnellement à la quantité

La complexité a été développée pour mesurer le degré de

La complexité permet de comparer l’efficacité des algorithmes.

Pr. A. AIT ABDELOUAHAD Informatique 4

La complexité d’un algorithme est une évaluation du coût de

On va traiter dans la suite la complexité temporelle. Les

La complexité permet de déterminer si un algorithme A et

Pr. A. AIT ABDELOUAHAD Informatique 4

Bonne maîtrise de la complexité se traduit par :

Mauvaise compréhension de la complexité débouche sur :

Pr. A. AIT ABDELOUAHAD Informatique 4

L’évaluation exacte du temps de calcul dépend de nombreux

1 le langage utilisé pour coder l’algorithme (compilé ou

3 l’ordinateur sur lequel va tourner le programme (sa rapidité).

4 taille et structure de données.

Pr. A. AIT ABDELOUAHAD Informatique 4

Pour évaluer un algorithme, une relation, entre la taille des

Pour une relation linéaire entre n et t tel que t1 = cn1

Multiplication des données par 5 =⇒ Multiplication du temps

Pour une relation non linéaire entre n et t : t1 = log2 n1