Algorithmique

Algorithmique
Adel Khalfallah
adel.khalfallah@isi.utm.tn
Structures séquentielles
Adel Khalfallah
Adel Khalfallah - Institut Supérieur d’Informatique -

Structures séquentielles
• Listes
• Piles
• Files
Adel Khalfallah - Institut Supérieur d’Informatique - 3

Listes
•Collection ordonnée d’éléments

•L’opération successeur est définie. Tout
élément de la liste à pour successeur un
élément la liste de sauf le dernier qui a pour
successeur un élément prédéfini 

Listes – Opérations usuelles
• Insertion: En tête, en queue ou à une position

donnée
• Suppression: En tête, en queue, à une position
donnée ou d’une valeur donnée
• Recherche: D’une valeur ou de l’élément se
trouvant à une position donnée
Listes - Implantations
• La relation successeur est implicite : les éléments
sont contigus, i.e. utilisation d’un tableau
• Inconvénients
• La taille de la liste est bornée
• Gaspillage de mémoire
• L’insertion est couteuse
• Avantages : L’accès est immédiat
•La relation successeur est explicite : chaque

élément désigne explicitement son
successeur
•Chainage
Liste simplement chainée

Liste doublement chainée

Liste circulaires

Les listes chainées peuvent s’implanter avec des pointeurs
type Liste = ^Nœud
type Nœud = enregistrement
Info : Elément
Suivant : Liste
fenreg

Les listes chainées peuvent s’implanter avec des tableaux et des index
type Nœud = enregistrement
Info : Elément
Suivant : 0..Max
fenreg
type Liste = enregistrement
Tete : 0..Max
LesElements : Tableau[1..Max] de Nœuds
Occupés : Tableau[1..Max] de booléens
fenreg

Listes triées
• Il existe une relation d’ordre sur les éléments de la
liste
• Les éléments de la liste respectent la relation d’ordre:

Listes triées
• Les opérations d’insertion et de suppression doivent
maintenir l’ordre
• La recherche d’un élément bénéficie de l’ordre: la

recherche s’arrête dés qu’on atteint un élément
supérieur à l’élément recherché

Piles
• Une pile est une liste dont on ne manipule que la tête: l’insertion, la
suppression et la consultation ne se font qu’en tête.
• Empiler : Pile x Elément → Pile
Précond : non EstPleine(P)
• Dépiler : Pile → Pile
Précond : non EstVide(P)
• Tete : Pile → Element
Précond : non EstVide(P)

Files
• Une file est une liste dont on ne manipule que la tête ou la queue:
l’insertion se fait en queue, la suppression et la consultation ne se
font qu’en tête.
• Enfiler : File x Elément → File
• Défiler : File → File
Précond : non EstVide(F)
• Tête : File → Elément
Précond : non EstVide(F)
Complexité des algorithmes
Adel Khalfallah
Gagner aux échecs
• Ecrire un programme capable de battre n’importe quel champion
d’échecs n’est pas difficile, il suffit de construire l’arbre de toutes les
configurations possibles !
• La racine de l’arbre est la configuration initiale
• Les fils d’un nœud donné de l’arbre s’obtiennent en essayant tous les
déplacements possibles de toutes les pièces, si la configuration père a été
obtenue par déplacement d’une pièce blanche, les configurations filles de ce
nœud s’obtiennent par déplacement d’une pièce noire et inversement
• Les feuilles de l’arbre sont les configurations qui correspondent à « échec et
mat »

Gagner aux échecs
• En moyenne une partie dure 40 x 2 coups
• En moyenne 30 déplacements possibles par nœud
• Combien y-a-t-il de nœuds dans l’arbres
Somme d’une suite géométrique de raison 30

Gagner aux échecs
• Admettons que 8 bits sont suffisants pour représenter une
configuration, il faut 8 x 3081 bits soit environ
octets
Le volume de données transitant sur internet en une année (estimé en

2015):

Gagner aux échecs
• Admettons qu’une seule opération est nécessaire pour générer une
configuration
• L’ordinateur le plus rapide (en 2015) traite 16,32 1015 opérations par
secondes.
• Il faut à cet ordinateur 1087milliards d’années pour générer l’arbre,

l’univers existe depuis 14 milliards d’années

Caractérisation des algorithmes
• Cela ne suffit pas d’écrire un algorithme qui ‘marche’,
il faut que cet algorithme:
• Soit correct
• Termine
• Présente une complexité raisonnable

Quantification de la complexité
•Complexité spatiale : espace mémoire

utilisé par l’algorithme
•Complexité temporelle: temps d’exécution
de l’algorithme

Complexité temporelle
• Le temps d’exécution dépend de la taille des données entrée de
l’algorithme
• Algorithme de tri: Taille de la population à trier
• Multiplication de 2 nombres: Taille en bits des mots représentant les nombres
• Multiplication de matrices : Taille des matrices
• Parfois on peut avoir plusieurs grandeurs; Traitements des graphes dépendent

du nombre de nœuds et du nombre d’arcs

• On convient de fixer un coût à chaque instruction:
• Affecta on → C1
• Condi onnelle → C2
• Boucle tant que → C3
…
• Le temps d’exécution de l’algorithme est la somme des temps
d’exécution des instructions
• Une instruction ayant le temps d’exécution Ci et s’exécutant n fois
aura un temps d’exécution global n x Ci
• Algorithme de tri par insertion:
Tri-Insertion(A)
Pour j de 2 à longueur(A) faire
Cle  A[j]
//Recherche de la place de A[j]
i j-1
tantque i>0 et A[i] > cle faire
A[i+1] A[i]
i i-1
ftque
A[i+1] Cle
fpour

Instruction coût Nbr. fois
Pour j de 2 à longueur(A) faire C1 n
Cle  A[j] C2 n-1
//Recherche de la place de A[j] C3=0 n-1
i j-1 C4 n-1
tantque i>0 et A[i] > cle faire C5 𝑡
A[i+1] A[i] C6
(𝑡 −1)
i i-1 C7
(𝑡 −1)
A[i+1] Cle C8 n-1

𝑇 𝑛 =𝐶 𝑛+𝐶 𝑛−1 +𝐶 𝑛−1 +𝐶 𝑡 +𝐶 𝑡 −1 +𝐶 𝑡 − 1 + 𝐶 (𝑛 − 1)
• Cas le plus favorable: Que se passe-t-il lorsque le tableau est trié ?
Car à chaque itération A[j] reste à sa place, donc
Au meilleur des cas : la complexité est linéaire

𝑇 𝑛 =𝐶 𝑛+𝐶 𝑛−1 +𝐶 𝑛−1 +𝐶 𝑡 +𝐶 𝑡 −1 +𝐶 𝑡 − 1 + 𝐶 (𝑛 − 1)
• Cas le plus défavorable: Que se passe-t-il lorsque le tableau est déjà trié en ordre décroissant ?
𝐴[𝑗] sera comparé à tous les éléments 𝐴 1 . . 𝐴 𝑛 donc 𝑡 = 𝑗
( ) ( )
∑ 𝑗= ∑ 𝑗 −1= − 1; ∑ 𝑗−1 =∑ 𝑗=
Donc
𝑛(𝑛 − 1) 𝑛(𝑛 − 1) 𝑛(𝑛 − 1)

𝑇 𝑛 =𝐶 𝑛+𝐶 𝑛−1 +𝐶 𝑛−1 +𝐶 −1 +𝐶 +𝐶 + 𝐶 (𝑛 − 1)
2 2 2
𝐶 𝐶 𝐶 𝐶 𝐶 𝐶
= + + 𝑛 + 𝐶 +𝐶 +𝐶 + − − +𝐶 𝑛− 𝐶 +𝐶 +𝐶 +𝐶
2 2 2 2 2 2
Au pire des cas : 𝑇 𝑛 = 𝐴𝑛 + 𝐵𝑛 + 𝐶 la complexité est quadratique

• Pire des cas : Analyse dans le cas de la donnée qui va nécessiter le temps de
calcul le plus élevé
• Meilleur des cas : Analyse dans le cas de la donnée qui va nécessiter le temps de
calcul le moins élevé
• Complexité en moyenne: On suppose disposer d’une partitionnement de
l’ensemble des entrées de taille n: la partition , est constituée des entrées de
taille n ayant un coût et d’une distribution de probabilités associant à chaque
partition , sa probabilité d’occurrence,
,
𝒫 ,

• Complexité en moyenne: Déterminer n’est

pas trivial, on peut simplifier en supposant que toutes
les entrées sont équiprobable, on a alors:

Exemple :
Fonction Trouve(T : Tableau[1..n] de 1..k;
v:1..k):booléen
début
Trouve=faux
i 1
tque non trouve et (i≤n) faire
trouveT[i]=v
i i+1
ftque
fin

• Au pire des cas l’élément n’est pas dans le tableau: 𝑇 𝑛 = 𝐴𝑛 + 𝐵
• Cas moyen: On partitionne l’ensemble des tableaux en sous-ensembles ayant un coût de recherche d
𝑇 = Π 𝑡𝑎𝑏𝑙𝑒𝑎𝑢𝑥 𝑒𝑛𝑡𝑟𝑎𝑖𝑛𝑎𝑛𝑡 𝑢𝑛 𝑐𝑜û𝑡 𝑑 × 𝑑

û
• On simplifie en supposant que tous les tableaux sont équiprobables

• il y a en tout 𝑘 = 𝒫 tableaux
• 𝑘−1 ne contiennent pas v, 𝑑 = 𝑛 × 𝐶
• 𝑘 tableaux contiennent v en première position, 𝑑 = 1 × C
• 𝑘−1 𝑘 tableaux contiennent v en seconde position, 𝑑 = 2 × 𝐶
• 𝑘−1 𝑘 tableaux contiennent v en troisième position, 𝑑 = 3 × 𝐶
• 𝑘−1 𝑘 tableaux contiennent v en ième position, 𝑑 = i × C
𝑇 = 𝑛+∑ 𝑖 à un facteur constant près

Or:
1−𝑥
𝑥 =
1−𝑥
En passant à la dérivée
1+𝑥 𝑛𝑥 − 𝑛 − 1
∀𝑥, 𝑖𝑥 =
1−𝑥
On pose 𝑥 = ; ∑ 𝑖=∑ 𝑖=∑ 𝑥 𝑖 D’où

𝑘−1 𝑘−1 𝑛
𝑇 = 𝑛+𝑘 1− 1+
𝑘 𝑘 𝑘
1
=𝑘 1− 1−
𝑘

• Lorsque les valeurs du tableau sont quelconques, k devient infini
est indéterminé, on calcule la moyenne des coûts :

• Les complexités des algorithmes de tri ont été très étudiées:
• Le tri rapide offre une complexité moyenne meilleure que la complexité au

pire des cas
• Le tri fusion offre des complexités moyenne et au pire des cas similaires
• Le tri par insertion offre des complexités moyennes et au pire des cas
similaires mais moins bonnes que celles du tri fusion

• Etudier précisément la complexité est difficile, on préfère étudier un
ordre de grandeur
• Notations de Landau (Notations asymptotiques)
𝐶 𝑔(𝑛)
𝑓(𝑛)
𝐶 𝑔(𝑛)

𝐶𝑔(𝑛)
𝑓(𝑛)

𝑓(𝑛)
𝐶𝑔(𝑛)

•
• Lorsque on dira que

• Lorsque alors pour n suffisamment grand
donc donc
Et pour n suffisamment grand est contredite donc

• Lorsque alors pour n suffisamment grand
donc donc
Et pour n suffisamment grand est contredite donc

• Lorsque alors pour n suffisamment grand et
donc
donc

• Rappel : Règle de l’Hôpital : la limite d’un rapport est égale à la limite
du rapport des dérivées

Quantification de la complexité : Exemples
f(n) g(n) comparaison
6𝑛 𝑛 log 𝑛 6𝑛 = 𝒪 𝑛 log 𝑛 et 6𝑛 ≠
𝜃 𝑛 log 𝑛 et 6𝑛 ≠ Ω 𝑛 log 𝑛
8𝑛 − 4 = 𝜃 8𝑛 − 4
𝑛 log 𝑛 𝑛 = Ω log 𝑛 et 𝑛 ≠ 𝜃 log 𝑛

• est une borne inférieure elle ne présente pas d’intérêt pour la
complexité moyenne ou au pire des cas, elle peut servir à minorer la
complexité au meilleur des cas
• est la meilleure approximation pour les 3 complexités
• La plupart du temps on utilisera pour disposer d’une majoration de

la complexité dans les pire des cas

• xy; y t; t x :
• pour i de 1 à n :
• Pour i de 1 à n
pour j de 1 à n :
pour j de 1 à i :
pour je de 1 à n
pour k de 1 à n :

• Ordres de complexité croissants:
• constante
• logarithmique
• linéaire
• quasi linéaire
• quadratique
• polynomiale
• exponentielle
• factorielle

T(n) n=10 n=20 n=30 n=40 n=50 n=60

𝑙𝑜𝑔(𝑛) 1 𝜇𝑠 1,3 𝜇𝑠 1,5 𝜇𝑠 1,6 𝜇𝑠 1,7 𝜇𝑠 1,8 𝜇𝑠
𝑛 10 𝜇𝑠 20 𝜇𝑠 30 𝜇𝑠 40 𝜇𝑠 50 𝜇𝑠 60 𝜇𝑠
𝑛 𝑙𝑜𝑔(𝑛) 10 𝜇𝑠 26 𝜇𝑠 44 𝜇𝑠 64 𝜇𝑠 85 𝜇𝑠 107 𝜇𝑠
𝑛 100 𝜇𝑠 400 𝜇𝑠 900 𝜇𝑠 1,6 𝑚𝑠 2,5 𝑚𝑠 3,6 𝑚𝑠
𝑛 0,1 𝑠 3𝑠 24 𝑠 1,7 𝑚𝑛 125 𝑚𝑠 216 𝑚𝑠
2 1 𝑚𝑠 1𝑠 18 𝑚𝑛 13 𝑗𝑜𝑢𝑟𝑠 36 𝑎𝑛𝑠 366 𝑠𝑖è𝑐𝑙𝑒𝑠
• Complexité exponentielle et factorielle inutilisable très rapidement

Algorithme coût
Recherche dichotomique dans un tableau trié 𝒪(log 𝑛 )
Calcul du produit scalaire de 2 vecteurs 𝒪(𝑛)
Tri par fusion 𝒪(𝑛 log 𝑛 )
Tours de Hanoi 𝒪 2

• La complexité pour le problème des tours de Hanoi est définie par les
relations de récurrence suivante:

Récursivité
Adel Khalfallah
Définition récursive
• Que signifient les initiales GNU ?
•G N U GNU is Not Unix
GNU is Not Unix is Not Unix
GNU is Not Unix is Not Unix is Not Unix
…
• Une définition récursive est construite avec le concept qu’elle définit
• Un traitement (procédure ou fonction) récursif fait référence à lui
même

Définition récursive
• Factorielle :
• On en déduit une fonction récursive factorielle

Factorielle(n : Entier):Entier
Début
si n=0 alors
retourner 1
sinon retourner n*Factorielle(n-1)
fsi
fin

Calcul de
fonction Comb(p : entier, n : entier):entier

début
si (p=0 ou p=n) alors
retourner 1
sinon retourner Comb(p,n-1) + Comb(p-1,n-1)
fsi
fin
• Il y a 2 appels récursifs

Récursivité croisée
• •
fonction pair(n:entier):booléen fonction impair(n:entier):booléen

début début
si n=0 alors si n=0 alors
retourner Vrai retourner faux
sinon retourner impair(n-1) sinon retourner pair(n-1)
fsi fsi
fin fin

Récursivité imbriquée
• Fonction d’Ackermann
𝑛+1 𝑠𝑖 𝑚 = 0
𝐴 𝑚, 𝑛 = 𝐴 𝑚 − 1,1 𝑠𝑖 𝑚 > 0 𝑒𝑡 𝑛 = 0
𝐴 𝑚 − 1, 𝐴 𝑚, 𝑛 − 1 𝑠𝑖 𝑚 > 0 𝑒𝑡 𝑛 > 0
Fonction Ack(m,n : entier):entier

début
si m=0 alors
retourner n+1 Ack(4,2)=265536 − 3, supérieur au nombre estimé
sinon si n=0 et m>0 alors d’atomes dans l’univers
retourner Ack(m-1,1)
sinon retourner Ack(m-1,Ack(m,n-1)
fsi
fin

Forme récursive sur un ensemble muni d’un
ordre bien fondé
• Ordre bien fondé : Relation d’ordre (éventuellement partielle) sur E
sans suite infinie strictement décroissante d’éléments de E
• Exemples
• L’ordre habituel sur est bien fondé
• Les ordre produit sur suivants sont bien fondés
• Au sens large ; non total, le minimum est (0,0)
• Au sens stricte: ; non total (n,0) et
(0,n) sont des minimaux
• Ordre lexicographique: , total min est
Listes: si et seulement si est extraite de ; non total le min est la liste vide

Forme récursive sur un ensemble muni d’un
ordre bien fondé
• Dans un ensemble bien fondé, la définition d’une fonction récursive
se décompose comme suit:
• Cas de base: Pour x minimal et éventuellement pour d’autres éléments la
valeur de est déterminée
• Etape récursive: pour x non minimal s’exprime en fonctions des
où

Terminaison
• Soit une une fonction récursive et son domaine de définition,
pour prouver la terminaison de (i.e. ) il
faut:
• Exhiber un ordre bien fondé sur
• Soient les la suite des paramètres obtenus à chaque appel récursif ( est
le paramètre de l’appel initial), il faut montrer que:
•
•

Terminaison
• Exemple: Calcul de la puissance
Fonction Puissance(x:Réel, n:Entier):Entier
début
si n=0 alors
retourner 1
sinon retourner n*Puissance(x,n-1)
fsi
fin
• l’ordre suivant sur est bien fondé
• ,…,
• on a bien : et

Récursivité
• La récursivité permet d’écrire des algorithmes concis et élégant
• Certains algorithmes sont extrêmement simples sous leur forme
récursive et extrêmement compliqués sous leur forme itérative
• Il n’y a pas de microprocesseur usuel qui supporte la récursivité donc
à la compilation tout algorithme récursif est transformé en algorithme
itératif
• On est facilement amené à écrire des algorithmes récursifs inefficaces
dont la complexité est en ou

Pile d’exécution
𝑓 0 =1
Exemple factorielle
𝑓 𝑛 = 𝑛 ∗ 𝑓(𝑛 − 1)
F(0)
F(1)=1*F(0)
F(2)=2*F(1)
F(3)=3*F(2)
F(4)=4*F(3)
F(5)=5*F(4)

Pile d’exécution – retour implicite
𝑓 0 =1
Exemple factorielle
𝑓 𝑛 = 𝑛 ∗ 𝑓(𝑛 − 1)
F(0)=1
F(1)=1*1
F(2)=2*1
F(3)=3*2
F(4)=4*6
F(5)=5*24

Tours de Hanoi
• On dispose de 3 piquets numérotés 1, 2, 3.
• Sur le 1er piquet il y a n disques disposés par ordre de taille
décroissante (le plus grand en bas)
• On souhaite déplacer les n disques vers le piquet 3 en respectant les
règles suivantes:
• On ne peut retirer que le disque qui est au sommet d’une pile
• On ne peut pas inverser l’ordre, i.e. poser un disque sur un disque plus petit

Solution récursive
• Pour résoudre Hanoi à n disques de 1 vers 3
• On résout Hanoi à n-1 disques de 1 vers 2
n-1
n
1 2 3

Solution récursive
• Puis on déplace le nième disques de 1 vers 3
n n-1
1 2 3

Solution récursive
• On résout Hanoi à n-1 disques de 2 vers 3
n-1 n
1 2 3

Hanoi
Procédure Hanoi(N : Entier, départ:1..3,arrivée:1..3)
début
si n > 0 alors
Hanoi(N-1,depart,6-depart-arrivée)
Ecrire(’déplacer le disque’, N, ’de’, départ, ’vers’, arrivée)
Hanoi(N-1,6-depart-arrivée,arrivée)
fsi
fin

Hanoi – déroulement
1
Hanoi(3,1,3)
2 9
Hanoi(2,1,2) Déplacer(3,1,3) Hanoi(2,2,3)
3 6 10 13
Hanoi(1,1,3) Déplacer(2,1,2) Hanoi(1,3,2) Hanoi(1,2,1) Déplacer(2,2,3) Hanoi(1,1,3)
Déplacer(1,1,3) 5 7
Déplacer(1,3,2) Déplacer(1,2,1) Déplacer(1,1,3)

Complexité
• La complexité d’un algorithme récursif pourra s’obtenir par l’études des
termes d’une suite
• Une équation récurrente est dite linéaire d’ordre k si chaque terme
s’exprime comme combinaison linéaire des k termes qui le précèdent plus
une certaine fonction de n.
• Pour k=1, on a: on en déduit:

Complexité
• Lorsque f(n)=0; on pose on a alors:
• est appelé le polynôme caractéristique associé

à
• Lorsque l’équation caractéristique admet k racines caractéristiques distinctes
r1,..rk, on montre que:
• Les sont déterminés à partir de

• Lorsque le nombre de racines est inférieur à k; a une forme plus complexe

Complexité
• Exemple: tours de Hanoi
k=1, a=2, f(n)=1

Complexité
• Exemple: fonction de Fibonacci
• La complexité est donnée par:
• Equation de récurrence avec k=2 et f(n)=0

Complexité
• Polynôme caractéristique
• L’équation: admet deux racines distinctes:

Complexité
• D’où et
• Complexité exponentielle !

Complexité
• Les algorithmes récursifs dans le paradigme « diviser pour régner » présentent une
complexité qui prend la forme suivante:
• n est la taille du problème

• Le problème est divisé en a (a 1) sous problèmes
• est la taille des sous problèmes, s’il n’est pas entier il est remplacé par ou
• est le coût de l’appel n en dehors des appels récursifs; est donc positive

TriFusion(Tab : [1...N]) =
TriFusion(Tab[1..N/2])
TriFusion(Tab[N/2+1..N])
Fusionner(Tab[1..N/2],Tab[N/2+1..N]) -> f(n)=O(n)

Complexité
• Dans un premier temps, on suppose on redéfinit T(n) comme
suit:
• Le premier appel a pour paramètre le second , le

troisième jusqu’à atteindre 1
• La hauteur de l’arbre d’appels est
Arborescence des appels
𝑓 𝑛 𝑓(𝑛)
a
𝑓
𝑛
𝑓
𝑛 … 𝑓
𝑛 𝑛
𝑎𝑓( )
𝑏
𝑏 a 𝑏 𝑏
a
a
… … …
𝑛 𝑛 𝑛 𝑛 𝑛 𝑛 𝑛 𝑛 𝑛 𝑛
𝑓 𝑓 𝑓 𝑓 𝑓 𝑓 𝑓 𝑓 𝑓 𝑎 𝑓( )
𝑏 𝑏 𝑏 𝑏 𝑏 𝑏 𝑏 𝑏 𝑏 𝑏
a a a a a a a a a
… … … … … … … … …
( )
Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(1) Θ(𝑎 )

Complexité
On a alors:

Complexité
Soit lorsque

Complexité
= donc:
+ =
Lorsque

Complexité
lorsque
= log
lorsque

Complexité
g si
Les termes plus petits que n0 sont constants ils sont majorés par

Complexité
Si de plus
Lorsque
T

Théorème des récurrences de partition
(Master theorem)
a les bornes asymptotiques suivantes:

1. Si alors
2. Si alors
3. Si alors
T

(Master theorem)
• La preuve étend la preuve précédente au cas ou n n’est pas une puissance entière
de b
• Interprétation du théorème:
• Lorsque f(n) est plus petite asymptotiquement que d’un facteur alors
• Lorsque f(n) se comporte comme asymptotiquement alors
• Lorsque f(n) est plus grande asymptotiquement que d’un facteur et obéit à la
condition de régularité (la plupart des fonctions bornées polynomialement y obeissent) alors

(Master theorem)
• Exemple:
a=9, b=3 et f(n)=n; donc
• Exemple:
a=1, b=3/2 et f(n)=1; donc

(Master theorem)
• Exemple:
a=3, b=4 et ; ,
,
où 0,21
Il reste à vérifier la condition de régularité:
donc

(Master theorem)
• Contre-exemple:
a=2, b=2, f(n)= bien que est majoré
asymptotiquement par f(n) cette majoration n’est pas polynomiale car
( )
est inférieure asymptotiquement à pour tout

Retour sur la somme contiguë
• Le principe de « diviser pour régner » s’applique à la
recherche de la somme maximale:
• on divise le tableau en 2 sous tableaux de tailles égales;
• la somme maximale se trouve alors
• soit dans le 1er sous tableau
• soit dans le 2ème sous tableau
• soit à cheval entre les deux

Procédure somme(T:Tableau[1..N] pour i de m à g pas -1 faire
d’entiers;g,d:0..N) Sum  Sum+T[i]
début si Sum > max1 alors
si g > d alors max1  Sum
fsi
retourner 0
fpour
sinon si g=d alors max2  0
si T[g] > 0 alors Sum  0
retourner T[g] pour i de m+1 à d faire
sinon retourner 0 Sum  Sum+T[i]
fsi si Sum > max2 alors
sinon max2  Sum
m(g+d)/2 fsi
fpour
max1  0
max  max1+max2
Sum  0

Sum  Somme(T,g,m)
si Sum > max alors
max  Sum
fsi
Sum  Somme(T,m+1,d)
si Sum > max alors
max  Sum
fsi
retourner max
fsi
fsi
fin

• La relation de récurrence pour le calcul de la complexité est:
a=2, b=2 f(n)=n;
D’où =

Dérécursivation
• Il est toujours possible de dérécursiver une fonction récursive en se
substituant au compilateur: On procède comme suit:
• On introduit une variable qui contiendra le résultat
• On introduit une pile de contextes un contexte est composé de toutes les variables
locales de la fonctions, de tous ses paramètres et d’une étiquette.
• Le corps de la fonction est imbriqué dans une boucle ‘tant que non pile vide’, suivi
d’un dépilement suivi d’un branchement à l’étiquette.
• Chaque appel récursif est transformé comme suit:
• Un 1er empilement sauvegarde le contexte actuel et l’étiquette du traitement suivant l’appel
récursif, il simule le retour de l’appel récursif, s’il y a lieu
• Le 2ème empilement sauvegarde les paramètres de l’appel, les valeurs initiales des variables
locales et l’étiquette d’entrée dans la fonction, il simule l’appel récursif

Dérécursivation
fonction fctIter(p1:T1,p2:T2):T5
fonction fctRec(p1:T1,p2:T2):T5 var
var l1:T3; l2:T4
RetVal:T5
l1:T3; l2:T4 P:pile<contexte>
début début
Empiler(P,p1,p2,l1,l2,1)
//traitement1 sans récursivité RetVal 0
tantque non EstVide(P) faire
... dépiler(P,p1,p2,l1,l2,e)
retourner fctRec(l1,l2) selon e faire
cas 1:
//traitement2 sans récursivité //traitement1 ...
empiler(p1,p2,l1,l2,2)
... empiler(l1,l2,0,0,1)
retourner fctRec(p1,l2) cas 2:
//traitement2 ...
//traitement3 sans récursivité empiler(p1,p2,l1,l2,3)
empiler(p1,l2,0,0,1)
... cas 3: //traitement3 ...
ftque
retourner RetVal
fin

Dérécursivation - factorielle
fonction factRec(N:Ent):Ent fonction factIter(N : Ent):Ent
var
var Tmp : Ent
RetVal:ent
Tmp : Ent P:pile<contexte>
début début
Empiler(P,N,Tmp,1)
si N=0 alors tantque non EstVide(P) faire
retourner 1 dépiler(P,N,Tmp,e)
selon e faire
sinon cas 1: si n=0 alors
Tmp=factRec(N-1) RetVal=1
sinon
retourner N*Tmp empiler(P,N,Tmp,2)
NN-1
fsi empiler(P,N,Tmp,1)
fin fsi;
fcas
cas 2:Tmp  RetVal
RetVal  N*Tmp
fcas
ftque
retourner RetVal
fin

Dérécursivation - Ackermann
fonction Ackerman(x,y:Ent):Ent fonction Ackerman(x,y:Ent):Ent
var
début RetVal:ent; P:pile<contexte>
début
si x=0 alors Empiler(P,x,y,1)
retourner y+1 tantque non EstVide(P) faire
dépiler(P,x,y,e)
sinon si y=0 et x > 0 alors selon e faire
retourner Ackermann(x-1,1) cas 1: si x=0 alors
RetVal=y+1
sinon sinon si y=0 et x>0 alors
//tmpAckermann(x,y-1) xx-1;y1
Empiler(P,x,y,1)
//retourner Ackermann(x-1,tmp) sinon
Empiler(P,x,y,2)
y y-1
retourner Empiler(P,x,y,1)
fcas
Ackermann(x-1,Ackermann(x,y-1)) cas 2:x  x-1,y  RetVal
fsi Empiler(P,x,y,1)
fcas
fin ftque
retourner RetVal
fin

Dérécursivation - Hanoi
Procédure Hanoi(N : Entier, Procédure Hanoi(N : Entier,dép:1..3,arr:1..3)
var
dép:1..3,arr:1..3) P:pile<contexte>
début
début Empiler(P,N,dép,arr,1)
si N > 0 alors tantque non EstVide(P) faire
dépiler(P, N,dép,arr,e)
Hanoi(N-1,dep,6-dep-arr) selon e faire
cas 1: si N>0 alors
Ecrire(’déplacer le disque’, N, ’de’, Empiler(P,N,dép,arr,2)
dép, ’vers’, arr) N N-1;arr 6-dép-arr
Empiler(P,N,dép,arr,1)
Hanoi(N-1,6-dep-arr,arr) fsi
fcas
fsi cas 2 : Ecrire(’déplacer le disque’, N, ’de’,
fin dép, ’vers’, arr)
N N-1;dép 6-dép-arr
Empiler(P,N,dép,arr,1)
fcas
ftque
fin

Dérécursivation - Optimisations
• Lorsque la transformation des paramètres est réversible, il est inutile
de les empiler
• En particulier: lorsque des variables ne sont pas modifiées, il est inutile de les
empiler
• Lorsque la récursivité est terminale, on n’a pas besoin de pile

Dérécursivation – factorielle - Optimisation
fonction factIter(N : Ent):Ent
fonction factIter(N : Ent):Ent var
var
Tmp : Ent; RetVal:ent; P:pile<contexte>
Tmp : Ent
début
RetVal:ent
P:pile<contexte> Empiler(P,1)
début tantque non EstVide(P) faire
Empiler(P,N,Tmp,1) dépiler(P,e)
tantque non EstVide(P) faire selon e faire
dépiler(P,N,Tmp,e) cas 1: si n=0 alors
selon e faire RetVal=1
cas 1: si n=0 alors sinon
RetVal=1 empiler(P,2)
sinon NN-1
empiler(P,N,Tmp,2)
empiler(P,1)
NN-1
fsi;
empiler(P,N,Tmp,1)
fsi; fcas
fcas cas 2:Tmp  RetVal //On pourrait supprimer
cas 2:Tmp  RetVal NN+1 // Tmp
RetVal  N*Tmp RetVal  N*Tmp //RetVal  N*RetVal
fcas fcas
ftque ftque
retourner RetVal retourner RetVal
fin
fin

Récursivité terminale (tail recursion)
• La récursivité est terminale lorsque l’appel récursif
termine la fonction: il n’y a plus de traitements après
l’appel
• La fonction factorielle n’est pas terminale:
N*factorielle(N-1)
• Après l’appel récursif il faut encore multiplier par N

Factorielle récursive terminale
fonction Factorielle(N:Ent; Res:Ent): Ent
début
si n=1 alors
retourner Res
sinon retourner Factorielle(N-1,N*Res)
fsi
Fin
• Puisqu’il n’y a rien après l’appel récursif, il n’y a plus besoin de pile

Factorielle récursive terminale
fonction factIter(N : Ent, fonction factIter(N : Ent,
Res:Ent):Ent Res:Ent):Ent
var var
RetVal:ent; RetVal:ent;
Début Début
1:si n=1 alors tantque n > 1 faire
RetVal=Res ResN*Res; NN-1;
sinon ftque
Res N*Res; NN-1; retourner Res;
Aller à 1 fin
fsi;
ftque
retourner RetVal
fin

Récursivité
• Dérécursiver en simulant la pile d’exécution présente l’avantage de ne
plus être limité par les contraintes mémoires sur la dite pile
• Beaucoup de compilateurs détectent les récursivités terminales et
font automatiquement l’optimisation
• Les programmes récursifs sont élégants les programmes itératifs sont
efficaces c’est souvent vrai mais pas tout le temps

Algorithmes de Tri
Adel Khalfallah
Introduction
• On souhaite organiser une collection d’éléments conformément à une
relation d’ordre totale
• On distingue entre :
• Tri interne: Les données à trier sont stockées en mémoire centrale (RAM)
• Tri externe: Les données à trier sont stockées sur un périphérique de stockage de
masse (disque dur, CD, bande magnétique,…)
• Les différentes complexités temporelles sont le critère le plus important
dans le choix d’un algorithme de tri, mais d’autres facteurs sont pris en
compte: complexité spatiale, stabilité (les éléments égaux conservent leur
ordre initial), en place (non utilisation d’un tableau/liste auxiliaire)

Tri par sélection (Selection sort)
Min du sous
Triés
tableau non trié
ième itération

procédure TriSelection(var tmp  T[i]
T:Tableau[1..N] d’Eléments) T[i]  T[IndMin]
var T[IndMin]  tmp
IndMin,i,j : 1..N fpour
tmp : Elément fin
début
pour i de 1 à N-1 faire
IndMin  i
pour j de i+1 à N faire
si T[j] < T[IndMin] alors
IndMin  j
fsi
fpour

i min 1 2 3 4 5 6 7
1 4 10 14 11 5 7 9 21
2 5 5 14 11 10 7 9 21
3 6 5 7 11 10 14 9 21
4 4 5 7 9 10 14 11 21
5 6 5 7 9 10 14 11 21
6 6 5 7 9 10 11 14 21

Tri par sélection - Complexité
• La boucle externe est exécutée dans tous les cas (pire, meilleur et
moyen), le nombre de fois où le test est exécuté est donné par:
• La complexité dans tous les cas est en car L’échange est

effectué au plus n-1 fois, l’affectation de IndMin contribue au plus en
un terme aussi en

Tri par Insertion (Insertion Sort)
Triés Non triés

Le ième élément est
placé à sa place dans
le sous tableau trié

Tri par Insertion (Insertion Sort)
procédure TriInsertion(var tantque j > 1 et
T:Tableau[1..N] d’Eléments) T[j-1] < tmp faire
Var T[j]  T[j-1]
Tmp : Elément j  j-1
i,j : 1..N ftque
Début T[j]  tmp
pour i de 2 à N faire fpour
tmp  T[i] fin
j  i

Tri par Insertion - Complexité
• Meilleur des cas, le tableau est trié: Chaque élément est directement à sa place, il
n’y a pas de décalages, seule la boucle externe est exécutée, la complexité est en
• Pire des cas, le tableau est trié en ordre inverse: Il faut effectuer j-1 décalages à
chaque itération, la complexité est en

Tri par Insertion – Complexité moyenne
• On suppose que les éléments du tableau sont compris entre 1 et n
é
• Cas moyen:
• le nombre de tableaux ayant i valeurs (distinctes) est i!

• Lorsque l’élément i est inséré en 1ère position, il y aura i-1 décalages, il y a (i-1)!
tableaux où l’insertion se fait en 1ère position, car celle-ci est fixée
• Lorsque l’élément est inséré en pème position, il y aura i-p+1 décalages, il y a (i-1)!
tableaux où l’insertion se fait en pème position, car celle-ci est fixée

Tri par Insertion – complexité moyenne
Or donc

Tri par Insertion – Complexité moyenne
• Lorsque
• Pour un tableau de taille i, le nombre moyen de coût de décalage est:
• La complexité moyenne est alors:

Tri à bulles (Bubble sort)
Le maximum du sous tableau

non trié remonte à sa place,
d’autres maxima locaux
peuvent aussi remonter
non triés triés

ième itération

procédure TriBulle(var T: T[j+1]  T[j]
Tableau[1..N] d’Elément T[j]  tmp
var échange  vrai
i,j : 1..N fsi
échange : booléen i  i-1
Début fpour
i  N ftque
échange  vrai fin
tantque i ≥ 2 et échange faire
échange  faux
pour j de 1 à i-1 faire
si T[j+1] < T[j] alors
tmp  T[j+1]

7 10 1 7 20 3 9 5
6 1 7 10 3 9 5 20
5 1 7 3 9 5 10 20
4 1 3 7 5 9 10 20
3 1 3 5 7 9 10 20

Tri à bulles - complexité
• Au meilleur des cas, lorsque le tableau est trié, un seul passage suffit
pour trier le tableau donc la complexité est en
• Au pire des cas, lorsque le tableau est trié en ordre inverse, la boucle
interne est exécutée i-1 fois, donc
• La complexité moyenne a été calculée par D. Knuth dans ‘The Art of
Computer Programming-vol3: Sorting and searching’

Tri fusion (Merge sort)
9 1 8 6 2 7 4 5
Séparation en
= 2 sous tableaux
9 1 8 6 2 7 4 5 (non triés)
9 1 8 6 2 7 4 5
9 1 8 6 2 7 4 5
Sous 1 9 6 8 2 7 4 5
Fusion en 2
tableaux
triés
= sous tableaux
1 6 8 9 2 4 5 7 triés
1 2 4 5 6 7 8 9

procédure Fusion(var k  k+1
T:Tableau[1..N]d’Elément,
ftque
int D,F:1..N)
var tque i ≤ M faire
Tmp : Tableau[1..N] d’Elément Tmp[k]  A[i]
i,j,k,M:1..N i  i+1; k  k+1
début ftque
M  (D+F)/2;i  D;j  M+1;k  1 tque j ≤ F faire
tque i ≤ M et et j ≤ F faire Tmp[k]  A[j]
si A[i] < A[j] alors i  i+1; k  k+1
Tmp[k]  A[i] ftque
i  i+1 pour i de 0 à F-D faire
sinon T[D+i] Tmp[i]
Tmp[k]  A[j] fpour
j  j+1 fin
fsi

procédure TriFusion(var T:Tableau[1..N] d’Elément, D,F :1..N)
var
M : 1..N
début
si D < F alors
M  (D+F)/2
TriFusion(T,D,M)
TriFusion(T,M+1,F)
Fusion(T,D,F)
fsi
fin

Tri Fusion - Complexité
• Dans tous les cas (pire, meilleur et moyen) les appels récursifs et la
fusion ont la même complexité
• La complexité est fournie par le théorème des récurrences de

partitions pour la récurrence
• Ce n’est pas un tri en place, la complexité spatiale est

Tri rapide (Quick sort)
pivot Inférieurs au pivot Supérieurs au pivot
Inférieurs au pivot Supérieurs au pivot Inférieurs au pivot
Supérieurs au pivot

fonction Partitionner(var T : Tableau[1..N] d’Elément,
Deb, Fin: Entier): Entier
Var
i,j,tmp : Entier
début
i  deb; j fin+1; pivot  T[Deb]
Répéter
Répéter i  i+1 jusqu’à i = Fin ou T[i] > Pivot
Répéter j  j-1 jusqu’à j = Deb ou T[j] < Pivot
si i < j alors
Echange(T,i,j)
fsi
jusqu’à i ≥ j
Echange(T,Deb,j)
retourner j
fin

procédure TriRapide (var T : Tableau[1..N] d’entier,
Deb, Fin : Entier)
Var
PosPivot : 1..N
début
si Deb < Fin alors
PosPivot  Partitionner(T,Deb,Fin)
TriRapide(T,Deb,PosPivot-1)
TriRapide(T,PosPivot+1,Fin)
fin
fin

Tri rapide - Complexité
• Complexité au meilleur des cas: Il se produit lorsqu’à chaque appel récursif on
obtient 2 sous tableaux de même taille, on a alors la relation de récurrence:
Où n est le coût du partitionnement du tableau de taille n, on en déduit que
• Complexité au pire des cas: Il se produit lorsque le tableau est déjà trié, l’appel
récursif se fait alors pour un sous tableau de taille 1 et un sous tableau de taille n-
1, le partitionnement a un coût , on a alors
donc

• Complexité moyenne: le coût du tri rapide à 2 composantes:
• une composante liée au partitionnement et qui ne dépend pas des données en entrée, son
coût est n+1
• Une composante liée aux appels récursifs, le coût dépend de la position du pivot, on rappelle
que
𝒫 𝒫, ,
où , est l’ensemble des tableaux en entrée où le pivot est en position i et le coût pour ces
entrées. On admet que chaque position du pivot est équiprobable, i.e. pour tout i,j il y a autant
de tableaux où le pivot est en position i que de tableaux où il est en position j
𝒫
, , , est l’ensemble des tableaux de taille n

Donc:
1 1
𝑇 𝑛 = 𝒫, 𝑑 = 𝑛 +1+ 𝑇 𝑖−1 +𝑇 𝑛−𝑖
𝒫 𝑛
𝒫,
Finalement:
1
𝑇 𝑛 =𝑛+1+ 𝑇 𝑖−1 +𝑇 𝑛−𝑖
𝑛
𝑇 1 =𝑇 0 =1
1 1 1
𝑇 𝑛 = 𝑛+1+ 𝑇 𝑖−1 +𝑇 𝑛−𝑖 = 𝑛+1+ 𝑇 𝑖−1 + 𝑇 (𝑛 − 𝑖)
𝑛 𝑛 𝑛
1 1 2
= 𝑛+1+ 𝑇 𝑖−1 + 𝑇 𝑖 − 1 =𝑛 + 1 + 𝑇 (𝑖 − 1)
𝑛 𝑛 𝑛

2 2
𝑇 𝑛 = 𝑛+1+ 𝑇 𝑖−1 ; 𝑇 𝑛−1 =𝑛+ 𝑇 𝑖−1 ;
𝑛 𝑛−1
𝑛𝑇 𝑛 − 𝑛−1 𝑇 𝑛 − 1 = 𝑛(𝑛 + 1) − (𝑛 − 1)𝑛 + 2𝑇 𝑛 − 1 = 2𝑛 + 2𝑇 𝑛−1
𝑛𝑇 𝑛 = 2𝑛 + 𝑛 + 1 𝑇 𝑛−1
𝑇 (𝑛) 2 𝑇 𝑛−1
= +
𝑛+1 𝑛+1 𝑛
𝑇 (𝑛 − 1) 2 𝑇 𝑛−2 𝑇 (𝑛) 𝑇 𝑛−2 2 2 𝑇 (1) 2
= + 𝑑 𝑜𝑢 = + + = +
𝑛 𝑛 𝑛−1 𝑛+1 𝑛−1 𝑛+1 𝑛 2 𝑘
1
𝑝𝑢𝑖𝑠𝑞𝑢𝑒 lim = log 𝑛 , lim 𝑇 𝑛 = 𝑛 log 𝑛; 𝑙𝑎 𝑐𝑜𝑚𝑝𝑙𝑒𝑥𝑖𝑡é 𝑚𝑜𝑦𝑒𝑛𝑛𝑒 𝑒𝑠𝑡 𝑑𝑜𝑛𝑐 𝜃(𝑛 log 𝑛)
→ 𝑘 →

Arbres binaires
Arbres binaires
• L’arbre vide est un arbre binaire
• L’arbre constitué d’une racine, d’un arbre binaire (appelé le sous arbre
gauche) et d’un autre arbre binaire (appelé le sous arbre droit) est un
arbre binaire

Arbres binaires - terminologie
• Soit A= <r; Fg; Fd> un arbre binaire où r est la racine est Fg; Fd les fils
gauche et droit:
• La racine de Fg est le fils gauche de r. De même la racine de Fd est le fils droit de r.
r est le père.
• Chaque nœud (sauf r) à un seul père
• 2 Nœuds qui ont le même père sont frères
• Un nœud n1 est l’ascendant ou l’ancêtre du nœud n2 si et seulement si n1
est le père de n2 ou l’ascendant du père de n2. n2 est alors le descendant de
n1
• Un nœud sans fils est une feuille

r
r’

• Les nœuds qui ne sont pas des feuilles sont des nœuds internes
• Le nombre de fils d’un nœud est le degré du nœud.
• Un chemin entre n1 et son descendant n2 est la succession de nœuds

qui relient n1 à n2
• La longueur du chemin entre la racine est un nœud n est appelée

profondeur de n
• La hauteur d’un arbre est la plus grande profondeur des ses feuilles
1
2 3

• Un arbre binaire dégénéré ou filiforme est un arbre dans lequel
chaque nœud interne a exactement un fils
• Un arbre binaire est complet si chaque nœud interne a exactement 2

fils et toutes les feuilles sont à la même hauteur.
• Un arbre binaire est parfait si chaque nœud interne a exactement 2

fils et les feuilles de plus grande profondeur sont regroupées à gauche

1

1
2 3
4
4 4 4

1
2 3
4
4

Arbres binaires
• L’arbre filiforme de hauteur h est l’arbre binaire qui possède le moins
de nœuds (N=h+1)
• L’arbre complet de hauter h est l’arbre binaire qui possède le plus de

nœuds (N=2h+1 – 1)
• Soit A un arbre binaire de hauteur h et ayant N nœuds alors:

log2(N) ≤ h ≤ N-1

Arbres binaires - Parcours
• Parcours en profondeur
• Infixe : fils gauche / racine / fils droit
• Préfixe : racine / fils gauche / fils droit
• Post-fixe :fils gauche / fils droit / racine
• Parcours en largeur : on visite les frères avant de visiter les fils

1
2 3
4 7 10
5 6 8 9 11 12
• parcours infixe : 5;4;6;2;8;7;9;1;3;11;10;12

• parcours préfixe:1;2;4;5;6;7;8;9;3;10;11;12
• parcours postfixe:5;6;4;8;9;7;2;11;12;10;3;1
• parcours largeur:1;2;3;4;7;10;5;6;8;9;11;12

parcours infixe
procedure ParcoursI(A:ArbreB) type ArbreB=^Nœud
debut type Nœud = enregistrement
si A != null alors val : Element
ParcoursI(A->FG) FG : ArbreB
Afficher(A->Val) FD : ArbreB
Parcours(A->FD) fenreg
fsi
fin

Arbres binaires de recherche
• Soit A =<r, Fg, Fd> un arbre binaire et n un nœud de A, Cont(n) est
l’information stockée dans n.
A =<r, Fg, Fd> est un arbre binaire de recherche lorsque A est vide ou A
vérifie:
•
•

Arbres binaires de recherche ?
20
10 40
3 18 25 46
13 20 21 45 62
30

Arbres binaires de recherche ?
43
21 50
15 44 56
42 55 72
12 46
6 13

Recherche dans un ABR
• Soit A=<r, Fg, Fd> un ABR contenant x, la recherche de x dans A
revient à parcourir le chemin de r à x
• Recherche(x,A)= si Cont(r) >= x

alors Recherche(x, Fg)
sinon Recherche(x, Fd)
• La complexité au pire des cas :

Recherche dans un ABR
fonction Cherche(A : ABR, clé : Élément) : Booléen type ABR = ^Nœud
debut type Nœud = enregistrement
si A = null alors val : Element
retourner faux FG : ABR
sinon si A-> val = clé alors FD : ABR
retourner vrai fenreg
sinon si A->val > clé alors
retourner Cherche(A->FG,clé)
sinon retourner Cherche(A->FD,clé)
fsi
fsi
fsi
fin

Recherche dans un ABR – version itérative
fonction ChercheI(A : ABR, clé : Element) : Booléen
var
tmp : ABR
debut
tmp<-A
tque (tmp!=null et tmp->val !=clé) faire
si clé < tmp->val alors
tmp<-tmp->FG
sinon tmp<-tmp->FD
fsi
ftque
retourne non (tmp=null)

propriétés d’un arbre binaire de recherche
• Le minimum d’un arbre binaire de recherche est la feuille la plus à gauche
• Le maximum d’un arbre binaire de recherche est la feuille la plus à droite
• Le parcours infixe permet d’obtenir les valeurs dans l’ordre

Insertion dans un ABR
• Insertion aux feuilles:
• Le nouvel élément aura pour père une feuille
• On parcourt le chemin depuis jusqu’à la feuille
• Risque de déstructurer l’arbre pour le rendre filiforme
• Insertion à la racine
• Requière de couper l’arbre en 2 sous arbres : le premier contenant tous les
éléments inférieurs au nouvel élément le second contenant tous les éléments
supérieurs au nouvel élément

Recherche dans un ABR – Version récursive
procedure InsereF(var A : ABR, clé : Elément)
debut
si A = null alors
A<-Allouer(nœud)
A->val <-clé; A->FG<-null; A->FD<-null;
sinon si clé <= A->val alors
InsereF(A->FG,clé)
sinon InsereF(A->FD,clé)
fsi
fsi
fin

Insertiondans un ABR – Version itérative
procedure InsereF_I(var A : ABR, clé : Element)
var
tmp, parcours : ABR
fin : bool
début
tmp = Allouer(Nœud); tmp->val<-clé; tmp->FG<-null; tmp->FD<-null;
si A = null alors
A=tmp
sinon
parcours <-A; fin<-faux;
tque non fin faire
si clé <= parcours -> val alors
si parcours -> FG = null alors parcours->FG<-tmp; fin<-vrai
sinon paracours<-parcours->FG
sinon
si parcours -> FD = null alors parcours->FD<-tmp; fin<-vrai
sinon paracours<-parcours->FD
fsi
fsi
ftque
fsi
fin

20
10 40
3 18 25 46
13 20 21 45 62
30

20
10 40
3 18 25 46
13 20 21 45 62
30

Insertion à la racine – Coupure
• Coupure par rapport à la clé 17
20
10 40
3 18 25 46
13 20 21 45 62
30

20
10 40
3 18 25 46
13 20 21 45 62
30

20
10 40
3 18 25 46
13 20 21 45 62
30

20
10 40
3 18 25 46
13 20 21 45 62
30

• Soit Coupure la procédure qui permet de couper un arbre par rapport à
une clé, cette procédure fournit en résultat 2 Arbres G et D
• 1er cas : la racine est strictement supérieure à la clé

• Soit Coupure la procédure qui permet de couper un arbre par rapport à
une clé, cette procédure fournit en résultat 2 Arbres A1 et A2
• 2ème cas : la racine est inférieure ou égale à la clé

Coupure
procedure Couper(var A : ABR, clé : Elément; var G, D : ABR)
var G’,D’ : ABR
debut
si A = null alors
G<-null; D<-null
sinon si A->val > clé alors
D<-A
Couper(A->FG, clé, G,D->FG)
sinon
G<-A
Couper(A->FD,clé,G->FD,D)
fsi
fsi
fin A d e l K h a l f a l l a h - Institut Supérieur d’Informatique - 166
Insertion à la racine
procedure InsereR(var A : ABR; clé : Element)
var
G,D, tmp : ABR; cle
debut
tmp = Allouer(Nœud)
tmp->val=clé G D
Couper(A, clé, G, D)
tmp->FG<-G
tmp->FD<-D
A<-tmp
fin

Suppression dans un ABR
• 1er cas : l’élément à supprimer est une feuille
6
6
8
2 8
2
1 5
1

Suppression dans un ABR
• 2ème cas : l’élément à supprimer possède un fils
6 6
8 8
2 2
1 5
1 3

• 3ème cas le nœud à supprimer possède 2 fils
4 4
2 8 2
5 12 5 12

procedure SupMax(var Max : Element, var A : ABR)
debut a
a
si A->FD = null alors
b
Max<-A->Val A b
A
tmp <-A
c
A<-A->FG
liberer(tmp)
sinon SupMAx(Max, A->FD)
fsi
fin

procedure Supprime(e: Element, var A : ABR) si A->FD=null alors //exactement 1 fils
var tmp<-A
Max : Element A<-A->FG
debut libère(tmp)
si A != null alors sinon //2 fils
si e > A-> val alors Supprime(e,A->FD) fsi SupMax(Max, A->FG)
sinon si e < A->val alors supprime(e, A->FG) fsi
A->val<-Max
sinon
fsi
si A->FG=null alors //0 ou 1 fils
tmp<-A
fsi
A<-A->FD fsi
libère(tmp) fin
sinon

a
a
b
A b
A
c

Graphes
Adel Khalfallah
Définition
• Un graphe est défini par:
Où S est appelé l’ensemble fini des sommets (on dit aussi nœuds) et
, lorsque le graphe est orienté A est appelé l’ensemble fini
des arcs, lorsqu’il est non orienté, il est appelé l’ensemble fini des
arêtes
• Un graphe valué est défini par:
Où est un graphe et est la fonction de coût

Exemples
• De nombreuses données peuvent être représentées sous forme de
graphe:
• Carte routière : S modélise l’ensemble des villes, A les routes
• Ordonnancement : S modélise des tâches, A les relations de dépendance
• UML : S modélise les classes, A les associations
• Automate: S modélise les places, A les transitions
• …

Représentation graphique
•
• On le représente graphiquement comme suit:
1 2
3 4

Représentation graphique
• Lorsqu’il n’est pas orienté, on ne représente pas les flèches :
1 2
3 4

Terminologie
• Soit un arc a=(s1, s2) s1 est l’extrémité initiale et s2 est l’extrémité
terminale de l’arc, s1 est le prédécesseur de s2 et s2 est le successeur
de s1
• Deux arcs sont adjacents lorsqu’ils ont au moins une extrémité
commune
• On appelle le degré d’un sommet, le nombre d’arcs dont il est
l’extrémité
• Un arc (x, x) est appelé boucle

Terminologie
• Dans un graphe orienté, on appelle chemin de longueur l une suite de l+1
sommets (s0, s1,…,sl) tel que pour tout i 0≤i≤l-1 (si,si+1) est un arc du graphe
• Un sous chemin de C= (s0, s1,…,sl) est sous-séquence (si,si+1,…sj) extraite de C
• Lorsque le graphe n’est pas orienté on parle de chaine
• Un chemin est élémentaire lorsqu’il ne contient pas plusieurs fois le même
sommet
• Dans un graphe orienté, un circuit est une chemin dont le premier et le dernier
sommets sont identiques. Lorsque le graphe est non orienté on parle de cycle. Un
circuit ou un cycle est élémentaire si tous ses sommets (sauf le 1er et le dernier)
sont distincts
• Un graphe sans cycles est dit acyclique

Terminologie
• Soient s1 et s2 2 sommets, s1 et relié à s2, s’il existe un chemin (s1,…,s2)
• Un graphe orienté est connexe si pour chaque sommets si, sj du
graphe si est relié à sj ou sj est relié à si.
• Un graphe orienté est fortement connexe si pour chaque sommets si,
sj du graphe si est relié à sj et sj est relié à si.
• Un graphe G=<S,A> non orienté est complet si et seulement si s1 et
s2 S, (s1, s2 ) A.
• Un graphe orienté est complet si et seulement si s1 et s2 S, (s1,s2 )
A ou (s2 , s1) A.

Terminologie
• Un graphe biparti est un graphe dont l’ensemble des sommets est
partitionné en 2 sous-ensembles S1 et S2 tel que : (s1, s2) A , s1
S1 et s2 S2 ou s2 S1 et s1 S2
• Un hypergraphe est un graphe non orienté ou chaque arrête est une
hyper arête qui relie un sommet à un sous ensemble de sommets.
• Un arbre est un graphe non orienté connexe acyclique
• Un graphe est planaire s’il peut être dessiné sans que ses arcs/arêtes
se croisent

Implantation – Liste d’adjacence
• Soit G=<S,A> l’ensemble S est stocké dans un tableau (ou une liste)
• L’ensemble A est représenté comme suit: à chaque sommet s on
associe une liste Ls telle que (s,si)  A  si  Ls
1 1 2 3
2 1 3 4
2 3 3 1 2 4 5
4
2 3 5
4 5 5
3 4

Implantation – Matrice d’adjacence
• Soit G=<S,A> on l’implante par une matrice G[si,sj]=n signifie
qu’il y a n arcs entre si,sj 1 2 3 4 5
1 0 1 1 0 0
2 1 0 1 1 0
1
3 1 1 0 1 1
2 3 4 0 1 1 0 1
5 0 0 1 1 0
4 5

Algorithmique

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

Algorithmique

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique

Adel Khalfallah - Institut Supérieur d’Informatique -

Adel Khalfallah - Institut Supérieur d’Informatique - 3

•Collection ordonnée d’éléments

Adel Khalfallah - Institut Supérieur d’Informatique - 4

• Insertion: En tête, en queue ou à une position

•La relation successeur est explicite : chaque

Liste simplement chainée

Adel Khalfallah - Institut Supérieur d’Informatique - 8

Liste doublement chainée

Adel Khalfallah - Institut Supérieur d’Informatique - 9

Adel Khalfallah - Institut Supérieur d’Informatique - 10

Adel Khalfallah - Institut Supérieur d’Informatique - 11

Adel Khalfallah - Institut Supérieur d’Informatique - 12

• Les éléments de la liste respectent la relation d’ordre:

Adel Khalfallah - Institut Supérieur d’Informatique - 13

• La recherche d’un élément bénéficie de l’ordre: la

Adel Khalfallah - Institut Supérieur d’Informatique - 14

Adel Khalfallah - Institut Supérieur d’Informatique - 15

Adel Khalfallah - Institut Supérieur d’Informatique - 18

Somme d’une suite géométrique de raison 30

Adel Khalfallah - Institut Supérieur d’Informatique - 19

Le volume de données transitant sur internet en une année (estimé en

Adel Khalfallah - Institut Supérieur d’Informatique - 20

• Il faut à cet ordinateur 1087milliards d’années pour générer l’arbre,

Adel Khalfallah - Institut Supérieur d’Informatique - 21

Adel Khalfallah - Institut Supérieur d’Informatique - 22

•Complexité spatiale : espace mémoire

Adel Khalfallah - Institut Supérieur d’Informatique - 23

• Multiplication de 2 nombres: Taille en bits des mots représentant les nombres

• Multiplication de matrices : Taille des matrices

• Parfois on peut avoir plusieurs grandeurs; Traitements des graphes dépendent

Adel Khalfallah - Institut Supérieur d’Informatique - 24

Adel Khalfallah - Institut Supérieur d’Informatique - 26

A[i+1] Cle C8 n-1

Adel Khalfallah - Institut Supérieur d’Informatique - 27

𝑇 𝑛 =𝐶 𝑛+𝐶 𝑛−1 +𝐶 𝑛−1 +𝐶 𝑡 +𝐶 𝑡 −1 +𝐶 𝑡 − 1 + 𝐶 (𝑛 − 1)

• Cas le plus favorable: Que se passe-t-il lorsque le tableau est trié ?

Car à chaque itération A[j] reste à sa place, donc

Au meilleur des cas : la complexité est linéaire

Adel Khalfallah - Institut Supérieur d’Informatique - 28

𝐴[𝑗] sera comparé à tous les éléments 𝐴 1 . . 𝐴 𝑛 donc 𝑡 = 𝑗

𝑛(𝑛 − 1) 𝑛(𝑛 − 1) 𝑛(𝑛 − 1)

Au pire des cas : 𝑇 𝑛 = 𝐴𝑛 + 𝐵𝑛 + 𝐶 la complexité est quadratique

Adel Khalfallah - Institut Supérieur d’Informatique - 29

Adel Khalfallah - Institut Supérieur d’Informatique - 30

• Complexité en moyenne: Déterminer n’est

Adel Khalfallah - Institut Supérieur d’Informatique - 31

Adel Khalfallah - Institut Supérieur d’Informatique - 32

𝑇 = Π 𝑡𝑎𝑏𝑙𝑒𝑎𝑢𝑥 𝑒𝑛𝑡𝑟𝑎𝑖𝑛𝑎𝑛𝑡 𝑢𝑛 𝑐𝑜û𝑡 𝑑 × 𝑑

• On simplifie en supposant que tous les tableaux sont équiprobables

Adel Khalfallah - Institut Supérieur d’Informatique - 33

On pose 𝑥 = ; ∑ 𝑖=∑ 𝑖=∑ 𝑥 𝑖 D’où

Adel Khalfallah - Institut Supérieur d’Informatique - 34

est indéterminé, on calcule la moyenne des coûts :

Adel Khalfallah - Institut Supérieur d’Informatique - 35

• Le tri rapide offre une complexité moyenne meilleure que la complexité au

Adel Khalfallah - Institut Supérieur d’Informatique - 36

Adel Khalfallah - Institut Supérieur d’Informatique - 37

Adel Khalfallah - Institut Supérieur d’Informatique - 38

Adel Khalfallah - Institut Supérieur d’Informatique - 39

• Lorsque on dira que

Adel Khalfallah - Institut Supérieur d’Informatique - 40