Algorithmiques,

Structures de Données
& Complexités
1er Année Cycle Préparatoire | MPI

29/01/2023 1
Présentation Générale
Objectif principal
Apprendre à évaluer les algorithmes et à proposer des
algorithmes efficaces et optimisés

Plan
 Notions et concepts de base
 Complexité d’algorithmes itératifs
 Complexité d’algorithmes récursifs
Complexité des
Algorithmes Récursifs
Partie 3

3
Définition
• Algorithme récursif : un algorithme qui s’appelle lui-même
• Tout algorithme récursif doit :
– avoir au moins un cas qui ne comporte pas d’appel récursif :
cas de base ou condition d’arrêt,
– définir les bons cas de base :
• ils doivent être atteignables quelque soit l’exemple en
entrée : par exemple en s’assurant que le tableau dans
l’appel récursif est plus petit que celui en entrée
Exemples
Le calcul de la factorielle de n :
𝑛𝑛! = 𝑛𝑛 × (𝑛𝑛 − 1) × (𝑛𝑛 − 2) × ⋯ × 2 × 1 ,
on peut écrire ainsi 𝒏𝒏! = 𝒏𝒏 × (𝒏𝒏 − 𝟏𝟏)!
4
Itératif vs récursif
Solution itérative Solution récursive

fact(n:entier):entier fact(n:entier):entier
i,f : entier si n=1 alors
f := 1 fact := 1
pour i de 2 à n faire sinon
f := f * i fact := n * fact(n-1)
finpour finsi
fact := f fin
fin

5
Exécution d’un appel récursif
• L’exécution d’un appel récursif passe par deux phases :
– la phase de descente
– la phase de remontée
• Lors de la phase de descente, chaque appel récursif fait à son
tour un appel récursif
• En arrivant à la condition d’arrêt, on commence la phase de
remontée qui se poursuit jusqu’à ce que l’appel initial soit
terminé, ce qui termine le processus récursif

6
Types de récursivité
• On distingue plusieurs types de récursivité :
– Récursivité Simple : c’est une fonction qui contient dans son
corps un seul appel récursif
Exemple : Fonction factorielle

fact(n:entier):entier
si n=1 alors
fact := 1
sinon
fact := n * fact(n-1)
finsi
fin

7
Types de récursivité
• On distingue plusieurs types de récursivité :
– Récursivité Multiple : c’est une fonction qui contient plus
qu’un appel récursif dans son corps
Exemple : Calcul du nombre de combinaisons en se servant
de la relation de Pascal :
𝑝𝑝 1, 𝑠𝑠𝑖𝑖 𝑝𝑝 = 1 𝑜𝑜𝑜𝑜 𝑝𝑝 = 𝑛𝑛
𝐶𝐶𝑛𝑛 = � 𝑝𝑝 𝑝𝑝−1
𝐶𝐶 𝑛𝑛−1 + 𝐶𝐶 𝑛𝑛−1 , 𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠

Combin (n:entier, p:entier):entier

si (p=1) ou (p=n) alors
return 1
sinon
return Combin(n-1,p) + Combin(n-1,p-1)
finsi
fin
8
Types de récursivité
• On distingue plusieurs types de récursivité :
– Récursivité Mutuelle ou Croisée : Des fonctions sont dites
mutuellement récursives si elles dépendent les unes des
autres
Exemple : La définition de la parité :

𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝(𝑛𝑛) = �𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣, 𝑠𝑠𝑠𝑠 𝑛𝑛 = 0

𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖 𝑛𝑛 − 1 , 𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠

𝑖𝑖𝑖𝑖𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝(𝑛𝑛) = �𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓, 𝑠𝑠𝑠𝑠 𝑛𝑛 = 0

𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝 𝑛𝑛 − 1 , 𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠

9
Types de récursivité
• On distingue plusieurs types de récursivité :
– Récursivité Imbriquée : Lorsque un appel récursif est réalisé
à l’intérieur d’un autre appel récursif
Exemple : La fonction d’Ackermann :
𝑛𝑛 + 1, 𝑠𝑠𝑠𝑠 𝑚𝑚 = 0
𝐴𝐴 𝑚𝑚, 𝑛𝑛 = � 𝐴𝐴 𝑚𝑚 − 1, 1 , 𝑠𝑠𝑠𝑠 𝑚𝑚 > 0 𝑒𝑒𝑒𝑒 𝑛𝑛 = 0
𝐴𝐴 𝑚𝑚 − 1, 𝐴𝐴 𝑚𝑚, 𝑛𝑛 − 1 , 𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠

Ackermann(m:entier, n:entier):entier
si m = 0 alors
Ackermann := n + 1
sinonSi m > 0 et n = 0 alors
Ackermann := Ackermann(m-1, 1)
sinon
Ackermann := Ackermann(m-1, Ackermann(m, n-1))
finsi
fin
10
Récursivité terminale !!!
Un algorithme est récursif terminal si l’appel récursif est la toute
dernière instruction réalisée :
• La fonction Somme est récursive terminal : l’addition n + r
est faite avant l’appel pas de stockage de résultats
intermédiaires, les appels successifs sont vus comme des
égalités
Somme(n:entier,r:entier):entier
si n ≤ 1 alors
Somme := n+r
sinon
Somme := Somme(n-1,n+r)
finsi
fin

𝑠𝑠𝑠𝑠𝑠𝑠(5,0) = 𝑠𝑠𝑠𝑠𝑠𝑠(4,5) = 𝑠𝑠𝑠𝑠𝑠𝑠(3,9) = 𝑠𝑠𝑠𝑠𝑠𝑠(2,12) = 𝑠𝑠𝑠𝑠𝑠𝑠(1,14) = 15

11
Récursivité terminale !!!
Un algorithme est récursif terminal si l’appel récursif est la toute
dernière instruction réalisée :
• La fonction Fact n’est pas récursive terminal : après l’appel
récursif il faut faire une multiplication : tous les résultats des
appels à Fact(n-1), Fact(n-2),… doivent être stockés dans un
tampon en attente de la multiplication :
sinon
Fact(n:entier):entier Fact := fact(n-1)
si n = 1 alors Fact := n * Fact
Fact := 1 finsi
sinon
Fact := n * Fact(n-1)
finsi
Fin

𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓(4) ← 𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓(3) ← 𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓(2) ← 𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓(1)

𝟐𝟐𝟐𝟐 ∗4 𝟔𝟔 ∗3 𝟐𝟐 ∗2 𝟏𝟏 12
Récursivité terminale !!!
Transformation de récursivité non terminale
Ajouter un paramètre qui stocke le résultat intermédiaire. Ce
paramètre est appelé paramètre d’accumulation
Avantages :
• théoriquement plus de nécessité de garder en mémoire le
cumule des appels récursifs
• ces programmes peuvent être écrits facilement de manière
itérative
Fact(n:entier, result:entier):entier
si n = 1 alors
Fact := 1
sinon
Fact := Fact(n-1,result*n)
finsi
Fin 13
Calcul de complexité
Si le calcul de la complexité d'un algorithme itératif nécessite le
dénombrement des itérations des boucles et le nombre des
opérations à chaque itération.
Le calcul la complexité d'un algorithme récursif nécessite plutôt
le dénombrement des :
• Appels récursifs
• Opérations impliquées à chaque appel

⇒ La complexité d’un algorithme récursif se calcule par la

résolution d’une équation de récurrence en éliminant la
récurrence par substitution de proche en proche.

14
Types d’équations de récurrence
Il y a 2 types d’appels récursifs :
1. Les appels récursifs se font sur des problèmes de taille :
(𝑛𝑛 − 1), (𝑛𝑛 − 2) (𝑛𝑛 − 𝑏𝑏) …
Dans ce cas, le nombre d’opérations s’écrit :
𝐶𝐶(𝑛𝑛) = 𝑎𝑎 × 𝐶𝐶(𝑛𝑛 − 𝑏𝑏) + 𝑓𝑓(𝑛𝑛)
avec 𝒂𝒂, le nombre d'appels récursifs et 𝒇𝒇(𝒏𝒏) le nombre
d'opérations impliquées à chaque appel.

15
Types d’équations de récurrence
Il y a 2 types d’appels récursifs :
2. Le problème de taille 𝒏𝒏 est décompose en 𝑎𝑎 ≥ 1 sous
problèmes de taille 𝒏𝒏 ∕ 𝒃𝒃, avec 𝑏𝑏 > 1, pour le paradigme
"diviser pour régner" 𝑏𝑏 = 2,
Dans ce cas, le nombre d’opérations s’écrit :
𝐶𝐶(𝑛𝑛) = 𝑎𝑎 × 𝐶𝐶(𝑛𝑛 ∕ 𝑏𝑏) + 𝑓𝑓(𝑛𝑛)
avec :
• 𝒂𝒂 le nombre de sous problèmes
• 𝒃𝒃 le facteur de réduction
• 𝒇𝒇 (𝒏𝒏) le coût de décomposition du problème + le coût de
combinaison des résultats
16
Complexité de type 1 :
Cas simple

17
Calcul de complexité de type 1
Exemple 1 : La fonction factorielle, avec 𝐶𝐶(𝑛𝑛) la complexité d’un
appel à 𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹(𝑛𝑛)

Factoriel (n : entier) : entier ------------------------ C(n)

si n = 1 alors ----------------------------------------------------- 1 (opt. l : test)
Factoriel := 1 --------------------------------------------------- 0
sinon
Factoriel := n * Factoriel (n-1) ------ C(n-1) + 2 (opt. arth – et *)
finsi
Fin

1, 𝑛𝑛 = 1
𝐶𝐶(𝑛𝑛) = � C(n) = C(n-1) + 3
𝐶𝐶(𝑛𝑛 − 1) + 3, 𝑛𝑛 > 1

18
Calcul de complexité de type 1
Exemple 1 : par substitution
Pour calculer la solution générale de cette équation, on peut
procéder par substitution :

𝐶𝐶(𝑛𝑛) = 3 + 𝐶𝐶(𝑛𝑛 − 1)
= 3 + [3 + 𝐶𝐶(𝑛𝑛 − 2)]
= 3 + 3 + 3 + 𝐶𝐶(𝑛𝑛 − 3) 𝐶𝐶(𝑛𝑛) = 3𝑛𝑛 − 2
= ... 𝑖𝑖 𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡

= 3 + 3 + ⋯ + 3 + 𝐶𝐶(𝑛𝑛 − 𝑖𝑖)
→ 𝑪𝑪(𝒏𝒏) = 𝑶𝑶(𝒏𝒏)
= 3 × 𝑖𝑖 + 𝐶𝐶(𝑛𝑛 − 𝑖𝑖)

𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝 𝑖𝑖 = 𝑛𝑛 − 1
= 3 × (𝑛𝑛 − 1) + 𝐶𝐶(𝑛𝑛 − (𝑛𝑛 − 1))
= 3 × (𝑛𝑛 − 1) + 𝐶𝐶(1)
= 3 × (𝑛𝑛 − 1) + 1
= 3 × 𝑛𝑛 − 2
19
Calcul de complexité de type 1
Exemple 1 : par somme d’équations
Pour calculer la solution générale de cette équation, on peut
aussi procéder par somme d’équations :

𝐶𝐶 𝑛𝑛 = 𝐶𝐶(𝑛𝑛 − 1) + 3

𝐶𝐶 𝑛𝑛 = 𝐶𝐶(𝑛𝑛 − 1) + 3 𝐶𝐶(𝑛𝑛) = 3𝑛𝑛 − 2

𝐶𝐶(𝑛𝑛 − 1) = 𝐶𝐶(𝑛𝑛 − 2) + 3
𝑛𝑛 − 1 𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡
→ 𝑪𝑪(𝒏𝒏) = 𝑶𝑶(𝒏𝒏)
𝐶𝐶 𝑛𝑛 − 2 = 𝐶𝐶(𝑛𝑛 − 3) + 3
…
𝐶𝐶 2 = 𝐶𝐶(1) + 3
𝐶𝐶 1 = 1
_________________________
𝐶𝐶 𝑛𝑛 = 1 + 𝑛𝑛 − 1 × 3
𝐶𝐶 𝑛𝑛 = 1 + 3𝑛𝑛 − 3
20
Calcul de complexité de type 1
Exemple 2 : Tours de Hanoï

Les Tours de Hanoï et un jeu de réflexion consistant à déplacer

des disques de diamètres différents d'une tour de départ à une
tour de destination en passant par une tour auxiliaire et ceci en
un minimum de coups, tout en respectant les règles suivantes :
– on ne peut déplacer plus d'un disque à la fois,
– on ne peut placer un disque que sur un autre disque plus
grand que lui ou sur un emplacement vide,

21
Calcul de complexité de type 1
Exemple 2 : Tours de Hanoï

Solution : fonction récursive

Déplacer n disques (n > 0) du tour 1 au tour 3 revient à :

1. Déplacer n-1 disques (les plus petites) du tour 1 au tour 2

2. Déplacer le disque le plus grande du tour 2 au tour 3
3. Déplacer n-1 disques (les plus petites) du tour 2 au tour 3

22
Calcul de complexité de type 1
Exemple 2 : Tours de Hanoï

Solution : fonction récursive

Déplacer 𝑛𝑛 disques (𝑛𝑛 > 0) du tour 1 au tour 3 revient à :

Déplacer_Tour (N:Entier; A,B,I:Tours)

Si (N = 1) alors
DeplacerDisq (A,B) 𝐶𝐶 𝑛𝑛 = 1 𝑜𝑜. 𝑙𝑙 + 1 déplacements
Sinon
Déplacer_Tour (N-1,A,I,B) 𝐶𝐶 𝑛𝑛 = 1 𝑜𝑜. 𝑙𝑙 +
Déplacer_Disq (A,B) 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟 𝐶𝐶 𝑛𝑛 − 1 +
Déplacer_Tour (N-1,I,B,A) 1 𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑 +
𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟 𝐶𝐶(𝑛𝑛 − 1)
Fsi
Fin

1 + 𝑂𝑂(1) 𝑛𝑛 = 1
𝐶𝐶(𝑛𝑛) = � C(n) = 2C(n-1) + 1
1 + 2 × 𝐶𝐶 𝑛𝑛 − 1 𝑛𝑛 > 1
23
 Calcul de complexité de type 1
Exemple 2 : Tours de Hanoï

Pour calculer la solution générale de cette équation, on peut

procéder par somme d’équations :
𝐶𝐶(𝑛𝑛) = 2 × 𝐶𝐶(𝑛𝑛 − 1) + 1 𝟏𝟏 − 𝟐𝟐(𝒏𝒏−𝟏𝟏)+𝟏𝟏
𝑪𝑪 𝒏𝒏 =
𝟏𝟏 − 𝟐𝟐
20 × 𝐶𝐶 𝑛𝑛 = 20 × 2 × 𝐶𝐶(𝑛𝑛 − 1) + 20 × 1
21 × 𝐶𝐶(𝑛𝑛 − 1) = 21 × 2 × 𝐶𝐶(𝑛𝑛 − 2) + 21 × 1 𝑪𝑪 𝒏𝒏 = 𝟐𝟐𝒏𝒏 − 𝟏𝟏
22 × 𝐶𝐶(𝑛𝑛 − 2) = 22 × 2 × 𝐶𝐶(𝑛𝑛 − 3) + 22 × 1
23 × 𝐶𝐶(𝑛𝑛 − 3) = 23 × 2 × 𝐶𝐶(𝑛𝑛 − 4) + 23 × 1 → 𝑪𝑪(𝒏𝒏) = 𝑶𝑶(𝟐𝟐𝒏𝒏 )
…
2𝑛𝑛−1 × 𝐶𝐶 1 = 2𝑛𝑛−1 × 2 × 𝐶𝐶 0 + 2𝑛𝑛−1 × 1
2𝑛𝑛 × 𝐶𝐶 0 = 2𝑛𝑛 × 0
𝑛𝑛−1

𝐶𝐶 𝑛𝑛 = (20 × 1) + (21 × 1) + (22 × 1) +… +(2𝑛𝑛−1 × 1) + 0 = 0 + 1 × � 2𝑖𝑖

24
𝑖𝑖=0
Complexité de type 2 :
"diviser pour régner"

25
Paradigme "diviser pour régner" : Principe

Spécifier la solution du problème en fonction de la (ou des)

solution(s) d’un (ou de plusieurs) sous-problème(s) plus
simple(s) à traiter de façon récursive
Le paradigme "diviser pour régner" parcourt trois étapes à
chaque appel récursif à savoir :
– Diviser : le problème en un certain nombre de sous-
problèmes de taille moindre
– Régner : sur les sous-problèmes en les résolvant d’une façon
récursive ou directement si la taille d’un sous-problème est
assez réduite
– Combiner : les solutions des sous-problèmes en une
solution globale pour le problème initial

26
Paradigme "diviser pour régner" : Principe

27
Paradigme "diviser pour régner" : Principe

28
Calcul de la complexité d’un algorithme "diviser pour régner"

Le temps d’exécution d’un algorithme "diviser pour régner" se

décompose suivant les trois étapes du paradigme de base :
– Diviser : le problème en 𝒂𝒂 sous-problèmes chacun de taille
𝟏𝟏/𝒃𝒃 de la taille du problème initial. Soit 𝑫𝑫𝑫𝑫𝑫𝑫(𝒏𝒏) le temps
nécessaire à la division du problèmes en sous-problèmes,
– Régner : soit 𝒂𝒂 ∗ 𝑪𝑪(𝒏𝒏/𝒃𝒃) le temps de résolution des 𝒂𝒂 sous-
problèmes,
– Combiner : soit 𝑪𝑪𝑪𝑪𝑪𝑪𝑪𝑪(𝒏𝒏) le temps nécessaire pour
construire la solution finale à partir des solutions aux sous-
problèmes,

29
Calcul de la complexité d’un algorithme "diviser pour régner"

Le temps d’exécution d’un algorithme "diviser pour régner" se

décompose suivant les trois étapes du paradigme de base
– Finalement le temps d’exécution global de l’algorithme est :
𝐶𝐶(𝑛𝑛) = 𝑎𝑎 × 𝑪𝑪(𝒏𝒏/𝒃𝒃) + 𝐷𝐷𝐷𝐷𝐷𝐷(𝑛𝑛) + 𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶(𝑛𝑛)
– Soit la fonction 𝑓𝑓(𝑛𝑛) qui regroupe 𝐷𝐷𝐷𝐷𝐷𝐷(𝑛𝑛) et 𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶(𝑛𝑛)
– 𝐶𝐶(𝑛𝑛) est alors définie :
𝑪𝑪(𝒏𝒏) = 𝒂𝒂 × 𝑪𝑪(𝒏𝒏/𝒃𝒃) + 𝒇𝒇(𝒏𝒏)

• Le "Théorème Général" permet de connaître le comportement

asymptotique de l’équations de récurrence.

30
Théorème de résolution de la récurrence

Pour 𝑓𝑓(𝑛𝑛) = 𝑂𝑂(𝑛𝑛𝑘𝑘), la relation de récurrence se définit comme

suit :
𝑪𝑪(𝒏𝒏) = 𝒂𝒂 ∗ 𝑪𝑪(𝒏𝒏/𝒃𝒃) + 𝑶𝑶(𝒏𝒏𝒌𝒌)
Ainsi il faut comparer 𝒏𝒏𝒌𝒌 à 𝒏𝒏𝐥𝐥𝐥𝐥𝐥𝐥 𝒃𝒃 𝒂𝒂 ou particulièrement il faut
comparer les puissances de 𝒏𝒏 : 𝑘𝑘 et log 𝑏𝑏 𝑎𝑎
Le "Théorème Général" permet d'obtenir une expression de la
forme 𝑙𝑙𝑙𝑙𝑙𝑙𝑏𝑏 a complexité de 𝐶𝐶(𝑛𝑛) comme suit :

𝑠𝑠𝑠𝑠 𝑎𝑎 > 𝑏𝑏 𝑘𝑘 | (𝑘𝑘 < log 𝑏𝑏 𝑎𝑎) → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂( 𝑛𝑛𝑙𝑙𝑙𝑙𝑙𝑙𝑏𝑏 𝑎𝑎 )

�𝑠𝑠𝑠𝑠 𝑎𝑎 = 𝑏𝑏 𝑘𝑘 | (𝑘𝑘 = log 𝑏𝑏 𝑎𝑎) → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂(𝑛𝑛𝑘𝑘 log 𝑏𝑏 𝑛𝑛)
𝑠𝑠𝑠𝑠 𝑎𝑎 < 𝑏𝑏 𝑘𝑘 | (𝑘𝑘 > log 𝑏𝑏 𝑎𝑎) → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂 𝑓𝑓 𝑛𝑛 = 𝑂𝑂(𝑛𝑛𝑘𝑘 )

31
Calcul de complexité de type 2

Exemple 1 : Recherche du maximum

Soit Tab un tableau à n éléments, écrire une fonction récursive
permettant de rechercher l’indice du maximum dans Tab en
utilisant le paradigme "diviser pour régner"

5 8 1 10 12 6 4 9

5 8 1 10 12 6 4 9

5 8 1 10 12 6 4 9

8 5 1 10 12 6 4 9

8 10 12 9

10 12

12 32
Calcul de complexité de type 2

Exemple 1 : Recherche du maximum

Fonction maximum (T : t_entier; deb, fin : entier) : entier C(n)
si (deb = fin) alors
return T[deb]
sinon
m := (deb + fin) div 2 /* division du problème en 2 sous-problèmes */
k1 := maximum(T, deb, m) /* régner sur le 1 sous-problèmes */ C(n/2)
k2 := maximum(T, m+1, fin) /* régner sur le 2 sous-problèmes */ C(n/2)

si (T[k1] > T[k2]) alors

return k1 /* combiner les solutions */

sinon
return k2
finsi C(n) = 2*C(n/2) + O(1)
finsi
fin

33
Calcul de complexité de type 2

Exemple 1 : Recherche du maximum

D’après le théorème du paradigme "diviser pour régner", on a:
𝑪𝑪 𝒏𝒏 = 𝒂𝒂 × 𝑪𝑪(𝒏𝒏⁄𝒃𝒃) + 𝑶𝑶(𝒏𝒏𝒌𝒌 )
𝑠𝑠𝑠𝑠 𝑎𝑎 > 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂( 𝑛𝑛𝑙𝑙𝑙𝑙𝑙𝑙𝑏𝑏 𝑎𝑎 )
� 𝑠𝑠𝑠𝑠 𝑎𝑎 = 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂(𝑛𝑛𝑘𝑘 log 𝑏𝑏 𝑛𝑛)
𝑠𝑠𝑠𝑠 𝑎𝑎 < 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂 𝑛𝑛𝑘𝑘

Complexité de l’algorithme de recherche de maximum :

pour a = 2, b = 2, k = 0 → 𝑪𝑪 𝒏𝒏 = 𝟐𝟐 × 𝑪𝑪(𝒏𝒏⁄𝟐𝟐) + 𝑶𝑶(𝟏𝟏)
𝑎𝑎 = 2, 𝑏𝑏 = 2, 𝑘𝑘 = 0 → 𝑎𝑎 = 2 > 𝑏𝑏 𝑘𝑘 = 20 = 1
𝒅𝒅𝒅𝒅𝒅𝒅𝒅𝒅 → 𝒄𝒄 𝒏𝒏 = 𝑶𝑶 𝒏𝒏𝒍𝒍𝒍𝒍𝒍𝒍𝒃𝒃 𝒂𝒂 = 𝑶𝑶(𝒏𝒏log𝟐𝟐 𝟐𝟐 ) = 𝑶𝑶(𝒏𝒏𝟏𝟏 ) = 𝑶𝑶(𝒏𝒏)

34
Calcul de complexité de type 2

Exemple 2 : Recherche dichotomique

• Hypothèse : Liste triée par ordre croissant
• A chaque itération, on compare l’élément recherché x à
l’élément du milieu du tableau
• Si l’élément du milieu est supérieur à x alors on recherche
l’élément dans la sous liste inférieure sinon on la recherche
dans la sous liste supérieure
Exemple : n=20 x=50
Fin

35
Calcul de complexité de type 2
Exemple 2 : Recherche dichotomique
Recherche_Dicho(L:entier, inf,sup:entier, x:entier):booléen C(n)
si (inf <= sup) alors
mil := (inf + sup) div 2
si (x = L[mil]) alors
return vrai
sinon
si (L[mil] > x) alors
return Recherche_Dicho(L,inf,mil-1,x) C(n/2)
sinon
return Recherche_Dicho(L,mil+1,sup,x)
finsi
finsi
sinon
return faux C(n) = C(n/2) + O(1)
finsi
36
Calcul de complexité de type 2

Exemple 2 : Recherche dichotomique

D’après le théorème du paradigme "diviser pour régner", on a:
𝑪𝑪 𝒏𝒏 = 𝒂𝒂 × 𝑪𝑪(𝒏𝒏⁄𝒃𝒃) + 𝑶𝑶(𝒏𝒏𝒌𝒌 )
𝑠𝑠𝑠𝑠 𝑎𝑎 > 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂( 𝑛𝑛𝑙𝑙𝑙𝑙𝑙𝑙𝑏𝑏 𝑎𝑎 )
� 𝑠𝑠𝑠𝑠 𝑎𝑎 = 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂(𝑛𝑛𝑘𝑘 log 𝑏𝑏 𝑛𝑛)
𝑠𝑠𝑠𝑠 𝑎𝑎 < 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂 𝑛𝑛𝑘𝑘

Complexité de l’algorithme de la recherche dichotomique :

pour a = 1, b = 2, k = 0 → 𝑪𝑪 𝒏𝒏 = 𝟏𝟏 × 𝑪𝑪(𝒏𝒏⁄𝟐𝟐) + 𝑶𝑶(𝟏𝟏)
𝑎𝑎 = 1, 𝑏𝑏 = 2, 𝑘𝑘 = 0 → 𝑎𝑎 = 1 = 𝑏𝑏 𝑘𝑘 = 20 = 1
𝒅𝒅𝒅𝒅𝒅𝒅𝒅𝒅 → 𝒄𝒄 𝒏𝒏 = 𝑶𝑶 𝒏𝒏𝒌𝒌 log 𝒃𝒃 𝒏𝒏 = 𝑶𝑶 𝒏𝒏𝟎𝟎 log 𝟐𝟐 𝒏𝒏
= 𝑶𝑶(𝒍𝒍𝒍𝒍𝒍𝒍𝟐𝟐 𝒏𝒏)

37
Calcul de complexité de type 2

Exemple 3 : Tri fusion

• Ce tri est basé sur la technique
algorithmique diviser pour régner.
• L'opération principale de
l'algorithme est la fusion, qui
consiste à réunir deux listes triées
en une seule.
• L'efficacité de l'algorithme vient du
fait que deux listes triées peuvent
être fusionnées en temps linéaire.

38
Calcul de complexité de type 2
Exemple 3 : Tri fusion

Tri_fusion (T:t_entier; deb,fin:entier; var U:t_entier) C(n)

t1, t2: t_entier

Si deb < fin Alors

m := (deb + fin) div 2
Tri_fusion(T,deb,m,t1) C(n/2)
Tri_fusion(T,m+1,fin,t2) C(n/2)
Fusion(t1,deb,m,t2,m+1,fin,U) C(f(n)) = 0(n)
fsi

C(n) = 2*C(n/2) + O(n)

39
Calcul de complexité de type 2

Exemple 3 : Tri fusion

D’après le théorème du paradigme "diviser pour régner", on a:
𝑪𝑪 𝒏𝒏 = 𝒂𝒂 × 𝑪𝑪(𝒏𝒏⁄𝒃𝒃) + 𝑶𝑶(𝒏𝒏𝒌𝒌 )
𝑠𝑠𝑠𝑠 𝑎𝑎 > 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂( 𝑛𝑛𝑙𝑙𝑙𝑙𝑙𝑙𝑏𝑏 𝑎𝑎 )
� 𝑠𝑠𝑠𝑠 𝑎𝑎 = 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂(𝑛𝑛𝑘𝑘 log 𝑏𝑏 𝑛𝑛)
𝑠𝑠𝑠𝑠 𝑎𝑎 < 𝑏𝑏 𝑘𝑘 → 𝑐𝑐 𝑛𝑛 = 𝑂𝑂 𝑛𝑛𝑘𝑘

Complexité de l’algorithme de la recherche dichotomique :

pour a = 2, b = 2, k = 1 → 𝑪𝑪 𝒏𝒏 = 𝟐𝟐 × 𝑪𝑪(𝒏𝒏⁄𝟐𝟐) + 𝑶𝑶(𝒏𝒏𝟏𝟏 )
𝑎𝑎 = 2, 𝑏𝑏 = 2, 𝑘𝑘 = 1 → 𝑎𝑎 = 2 = 𝑏𝑏 𝑘𝑘 = 21 = 2
𝒅𝒅𝒅𝒅𝒅𝒅𝒅𝒅 → 𝒄𝒄 𝒏𝒏 = 𝑶𝑶(𝒏𝒏𝒌𝒌 log 𝒃𝒃 𝒏𝒏) = 𝑶𝑶(𝒏𝒏𝟏𝟏 log 𝟐𝟐 𝒏𝒏) = 𝑶𝑶(𝒏𝒏 log 𝟐𝟐 𝒏𝒏)

40
FIN

Complexité d’algorithmes itératifs

41
Présentation Générale
Objectif principal
Apprendre à évaluer les algorithmes et à proposer des
algorithmes efficaces et optimisés

Plan
 Notions et concepts de base
 Complexité d’algorithmes itératifs
 Complexité d’algorithmes récursifs