Algorithmique

avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures

Algorithmique avancée linéaires

Structures
arborescentes

Fabien Teytaud

Université du Littoral Côte d’Opale

1/111
Résumé Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Volume horaire Structures
linéaires
I 15 heures de cours. Structures
arborescentes
I 18 heures de TD.
I 36 heures de TP.

Objectifs
I Structures de données avancées.
I Algorithmiques avancées.
I Introduction à la complexité.

2/111
Bibliographie Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires

Structures
arborescentes

Emplacement bulco : [511.8 INT]

3/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Premiers pas Analyse d’un
algorithme
Rappels/Notions Initiation à la
complexité
Tri par insertion Méthodes de tri
Analyse d’un algorithme Structures
Initiation à la complexité linéaires

Structures
arborescentes
Méthodes de tri

Structures linéaires

Structures arborescentes

4/111
Une parenthèse sur les vector Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Les vectors Tri par insertion
Analyse d’un
algorithme
Initiation à la
I Tableaux dynamiques. complexité

Méthodes de tri
I Déclaration : std::vector<TYPE> NOM.
Structures
I Exemple : std::vector<float> tableauDeReel. linéaires

Structures
I Accès à l’élément i : NOM[i]. arborescentes

I Avoir la taille : NOM.size().

I Exemple : std::vector<int> tab = { 8, 4, 6, 9,
1, 5 } ;
I Il existe beaucoup d’autres fonctions que nous verrons
quand cela sera nécessaire.

5/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Premiers pas Analyse d’un
algorithme
Rappels/Notions Initiation à la
complexité
Tri par insertion Méthodes de tri
Analyse d’un algorithme Structures
Initiation à la complexité linéaires

Structures
arborescentes
Méthodes de tri

Structures linéaires

Structures arborescentes

6/111
Tri par insertion Algorithmique
avancée

Fabien Teytaud

Problématique Premiers pas

Rappels/Notions
I Entrée : Suite de n nombres < a1 , a2 , . . . , an >. Tri par insertion
Analyse d’un
algorithme
I Sortie : Permutation < a10 , a20 , . . . , an0 >, Initiation à la
complexité
avec a10 ≤ a20 ≤ . . . ≤ an0 . Méthodes de tri

Structures
linéaires
Principe Structures
arborescentes

[interstices.info]

7/111
Tri par insertion Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion Tri par insertion
#include <iostream> Analyse d’un
algorithme
#include <vector>
Initiation à la
complexité
void triInsertion(std::vector<int> &tab)
{ Méthodes de tri
for (int i = 1; i<tab.size(); i++)
{ Structures
// récupère la clé (valeur à insérer) linéaires
int cle = tab[i]; Structures
// cherche la position où il faut insérer la clé arborescentes
int j = i;
while (j>0 && tab[j-1] > cle)
{
// décale les éléments triés supérieurs à la clé
tab[j] = tab[j-1];
j--;
}
tab[j] = cle;
}
}

8/111
Rappel : création d’un programme principal Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Programme principal Initiation à la
int main() complexité
{ Méthodes de tri
std::vector<int> tab = { 8, 4, 6, 9, 1, 5 };
std::cout << "Avant le tri : " << std::endl; Structures
for(int s: tab) linéaires
std::cout << s << ’ ’;
std::cout << std::endl << "Apres le tri : " << std::endl; Structures
triInsertion(tab); arborescentes
for(int s: tab)
std::cout << s << ’ ’;
std::cout << std::endl;

return 0;
}

9/111
Rappel : compilation et exécution Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Initiation à la
complexité

Méthodes de tri
Execution
fabien$ g++ -std=c++11 -o triInsertion triInsertion.cpp Structures
fabien$ ./triInsertion linéaires
Avant le tri :
8 4 6 9 1 5 Structures
Apres le tri : arborescentes
1 4 5 6 8 9

10/111
Exemple Algorithmique
avancée

Fabien Teytaud

0 1 2 3 4 5 Premiers pas
Rappels/Notions
Tri par insertion
i =1 8 4 6 9 1 5 Analyse d’un
algorithme
Initiation à la
complexité

Méthodes de tri

Structures
linéaires

Structures
arborescentes

11/111
Exemple Algorithmique
avancée

Fabien Teytaud

0 1 2 3 4 5 Premiers pas
Rappels/Notions
Tri par insertion
i =1 8 4 6 9 1 5 Analyse d’un
algorithme
Initiation à la
complexité

i =2 4 8 6 9 1 5 Méthodes de tri

Structures
linéaires

Structures
arborescentes

11/111
Exemple Algorithmique
avancée

Fabien Teytaud

0 1 2 3 4 5 Premiers pas
Rappels/Notions
Tri par insertion
i =1 8 4 6 9 1 5 Analyse d’un
algorithme
Initiation à la
complexité

i =2 4 8 6 9 1 5 Méthodes de tri

Structures
linéaires

i =3 4 6 8 9 1 5 Structures
arborescentes

11/111
Exemple Algorithmique
avancée

Fabien Teytaud

0 1 2 3 4 5 Premiers pas
Rappels/Notions
Tri par insertion
i =1 8 4 6 9 1 5 Analyse d’un
algorithme
Initiation à la
complexité

i =2 4 8 6 9 1 5 Méthodes de tri

Structures
linéaires

i =3 4 6 8 9 1 5 Structures
arborescentes

i =4 4 6 8 9 1 5

11/111
Exemple Algorithmique
avancée

Fabien Teytaud

0 1 2 3 4 5 Premiers pas
Rappels/Notions
Tri par insertion
i =1 8 4 6 9 1 5 Analyse d’un
algorithme
Initiation à la
complexité

i =2 4 8 6 9 1 5 Méthodes de tri

Structures
linéaires

i =3 4 6 8 9 1 5 Structures
arborescentes

i =4 4 6 8 9 1 5

i =5 1 4 6 8 9 5

11/111
Rappel sur certaines notations algorithmiques Algorithmique
avancée

Fabien Teytaud

Quelques points sur l’algorithme précédent ... Premiers pas

Rappels/Notions
I tab est un paramètre d’entrée-sortie. Tri par insertion
Analyse d’un
algorithme
I tab[0,i-1] sont les anciens éléments dans [0,i-1] Initiation à la
complexité
mais maintenant triés. Méthodes de tri

I Formellement l’invariant est “les éléments de tab[0] à Structures

linéaires
tab[i-1] sont triés”. Structures
arborescentes

Un invariant de boucle
I Initialisation : il est vrai à la première itération de la
boucle.
I Conservation : s’il est vrai à l’itération i alors il doit
l’être à l’itération i + 1
I Terminaison : Une fois la boucle terminée, il fournit
une propriété utile à la validité d’un algorithme.
12/111
L’invariant de boucle Algorithmique
avancée

Fabien Teytaud

Application des propriétés sur l’algorithme de tri par

Premiers pas
insertion Rappels/Notions
Tri par insertion
Analyse d’un
I Initialisation : Unique élément tab[0], qui est donc bien algorithme
Initiation à la
trié. complexité

Méthodes de tri
I Conservation :
Structures
I La clé est supérieure aux éléments [0, j-1] et linéaires

inférieure aux éléments [j, i-1]. Structures

arborescentes
I Le décalage des éléments [j, i-1] en [j+1, i]
préserve le tri de ces éléments,
I donc l’insertion de la clé à l’indice j ainsi libéré assure
que les éléments [0, i] sont triés.
I Terminaison :
I Fin de boucle quand i vaut la taille du tableau N.
I D’après l’invariant, tab[0, N-1] est donc trié.
I [0,n-1] correspond à l’ensemble du tableau, on peut
donc dire que le tableau complet est trié.

13/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Premiers pas Analyse d’un
algorithme
Rappels/Notions Initiation à la
complexité
Tri par insertion Méthodes de tri
Analyse d’un algorithme Structures
Initiation à la complexité linéaires

Structures
arborescentes
Méthodes de tri

Structures linéaires

Structures arborescentes

14/111
Analyse Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Initiation à la
complexité

Il existe plusieurs mesures : Méthodes de tri

I La mémoire, Structures
linéaires
I les communications réseaux, Structures
arborescentes
I le processeur,
I le temps de calcul

15/111
Notions de complexité Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
La complexité caractérise l’efficacité d’un algorithme et Initiation à la
complexité
fournit une estimation de son coût. Il existe différents types Méthodes de tri
de complexité : Structures
linéaires
I la complexité dans le pire des cas, qui définit le coût Structures
maximal possible. arborescentes

I la complexité en moyenne, qui définit le coût moyen.

I la complexité dans le meilleur des cas, qui définit le
coût minimal possible.

16/111
Analyse du tri par insertion Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
La durée d’exécution de notre tri par insertion dépend de : Initiation à la
complexité
I La taille du tableau d’entrée. Méthodes de tri

I Les données d’entrée : à quel point les valeurs sont déjà Structures
linéaires
triées. Structures
arborescentes
Le temps d’exécution
Il s’agit du nombre d’opérations élémentaires (comparaison,
affectation, . . .) pour exécuter un algorithme avec une
certaine entrée.

17/111
Analyse du tri par insertion Algorithmique
avancée

Fabien Teytaud

Calcul du nombre d’instructions exécutées

Premiers pas
Rappels/Notions
#include <iostream> Tri par insertion
#include <vector> Analyse d’un
algorithme
void triInsertion(std::vector<int> &tab) // coût répétitions Initiation à la
complexité
{
for (int i = 1; i<tab.size(); i++) // c1 N Méthodes de tri
{
int cle = tab[i]; // c2 N−1 Structures
int j = i; // c3 N−1 linéaires
N−1
Structures
X
while (j>0 && tab[j-1] > cle) // c4 ti
i=1
arborescentes
{
N−1
X
tab[j] = tab[j-1]; // c5 (ti − 1)
i=1
N−1
X
j--; // c6 (ti − 1)
i=1
}
tab[j] = cle; // c7 N−1
}
}

ti correspond au nombre de fois que le ième while est

exécuté.
18/111
Analyse du tri par insertion Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Calcul du nombre d’instructions exécutées Initiation à la
complexité

Le coût total est la somme de tous les coûts : Méthodes de tri

Structures
N−1
X linéaires

T (N) = c1 N + c2 (N − 1) + c3 (N − 1) + c4 ti Structures
arborescentes
i=1
N−1
X N−1
X
+c5 (ti − 1) + c6 (ti − 1) + c7 (N − 1)
i=1 i=1

19/111
Analyse du tri par insertion Algorithmique
avancée

Fabien Teytaud

Premiers pas
Et si le tableau est déjà trié ? Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
I Correspond au cas le plus favorable. Initiation à la
complexité

I Dans ce cas le test tab[j-1] > cle est toujours faux. Méthodes de tri

Structures
I ti = 1 linéaires

Structures
arborescentes
T (N) = c1 N + c2 (N − 1) + c3 (N − 1) + c4 (N − 1) + c7 (N − 1)
= (c1 + c2 + c3 + c4 + c7 )N − (c2 + c3 + c4 + c7 )

Dans le meilleur des cas, le coût total est une fonction

linéaire de N (T (N) = aN + b), avec
a = c1 + c2 + c3 + c4 + c7 et
b = −(c2 + c3 + c4 + c7 ).

20/111
Analyse du tri par insertion Algorithmique
avancée

Fabien Teytaud

Et si le tableau est déjà trié dans l’ordre décroissant ?

Premiers pas
Rappels/Notions
I Correspond au pire cas. Tri par insertion
Analyse d’un
algorithme
I ti = i + 1 Initiation à la
complexité

Méthodes de tri
N(N + 1) Structures
T (N) = c1 N + c2 (N − 1) + c3 (N − 1) + c4 ( − 1) linéaires
2
Structures
N(N − 1) N(N − 1) arborescentes
+c5 + c6 + c7 (N − 1)
2 2
1
= (c4 + c5 + c6 )N 2
2
1 1 1
+(c1 + c2 + c3 + c7 + c4 − c5 − c6 )N
2 2 2
−(c2 + c3 + c4 + c7 )

Dans le pire des cas, le coût total est une fonction

quadratique de N (T (N) = aN 2 + bN + c).
21/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Premiers pas Analyse d’un
algorithme
Rappels/Notions Initiation à la
complexité
Tri par insertion Méthodes de tri
Analyse d’un algorithme Structures
Initiation à la complexité linéaires

Structures
arborescentes
Méthodes de tri

Structures linéaires

Structures arborescentes

22/111
Un peu de vocabulaire Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Initiation à la
Ordre de grandeur complexité

Méthodes de tri
I On s’intéresse surtout à l’ordre de grandeur du coût. Structures
linéaires
I On simplifie les constantes, et on ne garde que l’ordre le
Structures
plus élevé (par exemple, linéaire = N, quadratique = arborescentes

N 2 ).
I On s’intéresse aux performances asymptotiques des
algorithmes : quand la valeur de N devient très grande.

23/111
Notations asymptotiques Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Θ (Thêta) Initiation à la
complexité

Méthodes de tri
I Concrètement : s’il existe des constantes c1 , c2 telles que
Structures
f (n) soit comprise entre c1 g (n) et c2 g (n) ⇒ Θ(g (n)). linéaires

I On note Θ(g (n)) l’ensemble des fonctions suivant : Structures

arborescentes
Θ(g (n)) = {f (n) : ∃(c1 , c2 , n0 ),
0 ≤ c1 g (n) ≤ f (n) ≤ c2 g (n), ∀n ≥ n0 },
avec c1 , c2 , n0 des constantes positives.
I Pour le tri par insertion : Θ(n2 ).

24/111
Notations asymptotiques Algorithmique
avancée

Fabien Teytaud

Premiers pas
O (grand ‘O’) Rappels/Notions
Tri par insertion
Analyse d’un
I Notation Θ : borne sup + borne inf. algorithme
Initiation à la
complexité
I Concrètement : s’il existe une constante c telle que f (n) Méthodes de tri
soit majorée par cg (n) ⇒ O(g (n)) (borne supérieure Structures
linéaires
asymptotique).
Structures
I On note O(g (n)) l’ensemble des fonctions suivant : arborescentes

O(g (n)) = {f (n) : ∃(c, n0 ), 0 ≤ f (n) ≤ cg (n), ∀n ≥

n0 },
avec c, n0 des constantes positives.
I On remarque que si f (n) = Θ(g (n)) alors on a
f (n) = O(g (n)).
I Pour le tri par insertion : O(n2 ).

25/111
Mais aussi ... Algorithmique
avancée

Fabien Teytaud

o
Premiers pas
Rappels/Notions
I Borne supérieure non asymptotiquement approchée. Tri par insertion
Analyse d’un
I ∀c ∈ R+ , ∃n0 ≥ 0, (g (n)) = {f (n) : 0 ≤ f (n) ≤ cg (n) algorithme
Initiation à la
complexité
∀n ≥ n0 }.
Méthodes de tri

Structures
Ω linéaires

Structures
I A l’opposé de O ; Ω est une borne inférieur arborescentes

asymptotique.
I ∃(c ∈ R+ , n0 ∈ N ), 0 ≤ cg (n) ≤ f (n), ∀n ≥ n0

ω
I Borne inférieure non asymptotiquement approchée.
I ∀c ∈ R∗+ , ∃n0 > 0, (g (n)) = {f (n) : 0 ≤ cg (n) < f (n)
∀n ≥ n0 }.
26/111
Quelques fonctions de référence Algorithmique
avancée

Fabien Teytaud

Premiers pas
Rappels/Notions
Tri par insertion
Analyse d’un
algorithme
Initiation à la
I 1 (complexité constante) complexité

Méthodes de tri
I log2 (n) (logarithmique)
Structures
I n (linéaire) linéaires

Structures
I nlog (n) (quasi-linéaire) arborescentes

I n2 (quadratique)
I np ; avec p > 2 (polynomiale)
I 2n (exponentielle)

27/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
Méthodes de tri Structures
Tri à bulles linéaires

Tri par sélection Structures

arborescentes
Tri fusion
Tri rapide

Structures linéaires

Structures arborescentes

28/111
Rappel : le tri à bulles Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri à bulles Tri par sélection
void triBulles(std::vector<int> &tab) Tri fusion
{ Tri rapide
for (int i=tab.size()-1; i>0; i--)
{ Structures
bool tableau_trie = true; linéaires
for (int j=0; j<i; j++)
{ Structures
if (tab[j+1] < tab[j]) arborescentes
{
std::swap(tab[j], tab[j+1]);
tableau_trie = false;
}
}
if (tableau_trie)
return;
}
}

29/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas
i =5 Méthodes de tri
Tri à bulles
Tri par sélection
j =0 8 4 6 9 1 5 Tri
Tri
fusion
rapide

Structures
linéaires

Structures
arborescentes

30/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas
i =5 Méthodes de tri
Tri à bulles
Tri par sélection
j =0 8 4 6 9 1 5 Tri
Tri
fusion
rapide

Structures
linéaires
j =1 4 8 6 9 1 5 Structures
arborescentes

30/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas
i =5 Méthodes de tri
Tri à bulles
Tri par sélection
j =0 8 4 6 9 1 5 Tri
Tri
fusion
rapide

Structures
linéaires
j =1 4 8 6 9 1 5 Structures
arborescentes

j =2 4 6 8 9 1 5

30/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas
i =5 Méthodes de tri
Tri à bulles
Tri par sélection
j =0 8 4 6 9 1 5 Tri
Tri
fusion
rapide

Structures
linéaires
j =1 4 8 6 9 1 5 Structures
arborescentes

j =2 4 6 8 9 1 5

j =3 4 6 8 9 1 5

30/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas
i =5 Méthodes de tri
Tri à bulles
Tri par sélection
j =0 8 4 6 9 1 5 Tri
Tri
fusion
rapide

Structures
linéaires
j =1 4 8 6 9 1 5 Structures
arborescentes

j =2 4 6 8 9 1 5

j =3 4 6 8 9 1 5

j =4 4 6 8 1 9 5

30/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
i =4 Tri par sélection
Tri fusion
Tri rapide

j =0 4 6 8 1 5 9 Structures
linéaires

Structures
arborescentes

31/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
i =4 Tri par sélection
Tri fusion
Tri rapide

j =0 4 6 8 1 5 9 Structures
linéaires

Structures
j =1 4 6 8 1 5 9 arborescentes

31/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
i =4 Tri par sélection
Tri fusion
Tri rapide

j =0 4 6 8 1 5 9 Structures
linéaires

Structures
j =1 4 6 8 1 5 9 arborescentes

j =2 4 6 8 1 5 9

31/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
i =4 Tri par sélection
Tri fusion
Tri rapide

j =0 4 6 8 1 5 9 Structures
linéaires

Structures
j =1 4 6 8 1 5 9 arborescentes

j =2 4 6 8 1 5 9

j =3 4 6 1 8 5 9

31/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
i =3 Tri
Tri
fusion
rapide

Structures
j =0 4 6 1 5 8 9 linéaires

Structures
arborescentes
j =1 4 6 1 5 8 9

j =2 4 1 6 5 8 9

32/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
i =2 Structures
linéaires

j =0 4 1 5 6 8 9 Structures
arborescentes

j =1 1 4 5 6 8 9

33/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide

i =1 Structures
linéaires

Structures
j =0 1 4 5 6 8 9 arborescentes

Aucun changement → Arrêt de l’algorithme.

34/111
Conclusion Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide

Pour résumer Structures

linéaires

Structures
I Simple à mettre en oeuvre. arborescentes

I Complexité : O(n2 ).
I Peu efficace.

35/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
Méthodes de tri Structures
Tri à bulles linéaires

Tri par sélection Structures

arborescentes
Tri fusion
Tri rapide

Structures linéaires

Structures arborescentes

36/111
Tri par sélection Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles

L’algorithme du tri par sélection Tri

Tri
par sélection
fusion
Tri rapide

I Egalement appelé tri par extraction ou tri par recherche Structures

linéaires
du minimum. Structures
I Le principe est simple : arborescentes

I A chaque itération le plus petit élément est recherché.

I On l’insère ensuite à la première position.
I On travaille maintenant sur le tableau moins le premier
élément (déjà trié),
I et on répète l’étape 1.

37/111
Algorithme du tri par sélection Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri par sélection Tri rapide
void triSelection(std::vector<int> &tab)
{ Structures
for (int i = 0; i<tab.size()-1; i++) linéaires
{
int min = i; Structures
for (int j=i+1; j < tab.size(); j++) arborescentes
if (tab[j] < tab[min])
min = j;
if (min != i)
std::swap(tab[min], tab[i]);
}
}

38/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
i Tri par sélection
Tri fusion
8 4 6 9 1 5 Tri rapide

Structures
i linéaires
1 4 6 9 8 5 Structures
arborescentes
i
1 4 6 9 8 5
i
1 4 5 9 8 6
i
1 4 5 6 8 9

39/111
Tri par sélection Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide

Structures
linéaires
I Simple à implémenter et à comprendre.
Structures
I Peu efficace, complexité : O(n2 ). arborescentes

I Non stable.

40/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
Méthodes de tri Structures
Tri à bulles linéaires

Tri par sélection Structures

arborescentes
Tri fusion
Tri rapide

Structures linéaires

Structures arborescentes

41/111
Le tri fusion Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
L’algorithme de tri fusion Tri rapide

Structures
linéaires
I Basé sur l’algorithme Diviser pour régner.
Structures
I Principale étape : fusion de deux listes en une seule. arborescentes

I Son efficacité repose sur le fait que deux listes triées

peuvent être fusionnées en temps linéaire.
I Naturellement récursif.

42/111
Le tri fusion Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide

I Si le tableau ne possède qu’un élément, alors il est trié. Structures

linéaires
I Sinon, on sépare le tableau en deux parties égales. Structures
arborescentes
I On appelle récursivement le tri fusion sur les deux
parties.
I On fusionne les deux parties triées en un tableau trié.

43/111
Le tri fusion Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri fusion Tri rapide
// appel avec debut = 0 et fin = tab.size()-1
Structures
void triFusion(std::vector<int> &tab, int debut, int fin)
linéaires
{
if (debut < fin) Structures
{ arborescentes
int milieu = (debut+fin)/2;
triFusion(tab, debut, milieu);
triFusion(tab, milieu+1, fin);
fusion(tab, debut, milieu, fin);
}
}

44/111
Le tri fusion Algorithmique
avancée

Fabien Teytaud
Fusion
void fusion(std::vector<int> &tab, int debut, int milieu, int fin)
{
int compteur1 = debut; Premiers pas
int compteur2 = milieu+1;
std::vector<int> nouveau; Méthodes de tri
Tri à bulles
// copie des éléments jusqu’à ce qu’au moins un des tableaux soit terminé
while ((compteur1 <= milieu) && (compteur2 <= fin))
Tri par sélection
{ Tri fusion
if (tab[compteur1] < tab[compteur2]) Tri rapide
{
nouveau.push_back(tab[compteur1]); Structures
compteur1++; linéaires
}
else
{ Structures
nouveau.push_back(tab[compteur2]); arborescentes
compteur2++;
}
}

// on complète si besoin
if (compteur1 > milieu)
while (compteur2 <= fin)
{
nouveau.push_back(tab[compteur2]);
compteur2++;
}
else
while (compteur1 <= milieu)
{
nouveau.push_back(tab[compteur1]);
compteur1++;
}

// on copie nouveau[0..fin-debut] dans tab[debut..fin)

for (int i=debut; i <= fin; i++)
tab[i] = nouveau[i-debut];
}

45/111
Exemple Algorithmique
avancée

Fabien Teytaud

Premiers pas

8 4 6 9 1 5 Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
8 4 6 9 1 5
Structures
linéaires
8 4 6 9 1 5 Structures
arborescentes

8 4 6 9 1 5

4 8 6 1 9 5

4 6 8 1 5 9

1 4 5 6 8 9

46/111
Complexité du tri fusion Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
I Complexité de la partie “division” : Tri
Tri
à bulles
par sélection
Tri fusion
I A chaque itération, on divise la taille par 2. Tri rapide
I A l’instance i, on a donc une séquence de taille : 2ni . Structures
I On a donc une expression logarithmique (en base 2) du linéaires

nombre d’éléments initiaux. Structures

arborescentes
I On a donc O(log(n)).
I Complexité de la partie “fusion” :
I On a n1 + n2 itérations, correspondant à une fonction
linéaire.
I On a donc O(n).
I Complexité : O(n log(n)).

47/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
Méthodes de tri Structures
Tri à bulles linéaires

Tri par sélection Structures

arborescentes
Tri fusion
Tri rapide

Structures linéaires

Structures arborescentes

48/111
Tri rapide Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
L’algorithme de tri rapide Tri fusion
Tri rapide

I Généralement connu sous son appellation anglaise Quick Structures

linéaires
sort. Structures
arborescentes
I Inventé par Tony Hoare en 1961.
I L’idée consiste à placer un élément du tableau (le pivot)
directement à sa place (en décalant tous les éléments
inférieurs au pivot à sa gauche, et tous les éléments
supérieurs à sa droite).

49/111
Le tri rapide Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Tri par sélection
Tri fusion
Tri rapide
Tri rapide
// appel avec debut = 0 et fin = tab.size()-1 Structures
void triRapide(std::vector<int> &tab, int debut, int fin) linéaires
{
if (debut < fin) Structures
{ arborescentes
int pivot = partition(tab, debut, fin);
triRapide(tab, debut, pivot - 1);
triRapide(tab, pivot + 1, fin);
}
}

50/111
Le tri rapide Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
Partionnement Tri par sélection
int partition(std::vector<int> &tab, int debut, int fin) Tri fusion
{ Tri rapide
int pivot = tab[fin];
Structures
int i = debut-1;
linéaires
for (int j=debut; j<=fin-1; j++) Structures
{ arborescentes
if (tab[j] <= pivot)
{
i++;
std::swap(tab[i], tab[j]);
}
}
std::swap(tab[i+1], tab[fin]);
return i+1;
}

51/111
Exemple de partionnement Algorithmique
avancée

Fabien Teytaud

i d, j f Premiers pas

8 4 6 9 1 5 Méthodes de tri
Tri à bulles
j Tri par sélection
i d f Tri fusion
8 4 6 9 1 5 Tri rapide

Structures
i, d j f linéaires

4 8 6 9 1 5 Structures
arborescentes
i, d j f
4 8 6 9 1 5
i, d j f
4 8 6 9 1 5
d i f
4 1 6 9 8 5
d i f
4 1 5 9 8 6

52/111
Le tri rapide Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Tri à bulles
I Beaucoup utilisé : complexité en moyenne : O(n log(n)). Tri par sélection
Tri fusion
I Choix du pivot : Tri rapide

I Pivot arbitraire. Structures

linéaires
I Pivot aléatoire.
Structures
I Pivot optimal ? : valeur médiane du sous-tableau arborescentes
(O(n)).
I Quelques variantes :
I Sedgesort, amélioration pour les sous-listes de petites
tailles.
I Introsort, combinaison avec le tri par tas : permet
d’améliorer la complexité au pire cas.

53/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas
Structures
linéaires
Les piles
Méthodes de tri Les files
Les pointeurs
Les listes chaînées
Listes doublement
Structures linéaires chaînées

Les piles Structures

arborescentes
Les files
Introduction aux pointeurs
Les listes chaînées
Listes doublement chaînées

Structures arborescentes

54/111
Les piles Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Notion de pile Les piles
Les files
Les pointeurs
I Ensemble d’éléments successifs. Les listes chaînées
Listes doublement
chaînées
I L’insertion et la suppression sont contraintes. Structures
arborescentes
I Seul l’élément le plus récent est accessible.
I Principe du dernier entré, premier sorti (LIFO).
I Exemple : une pile d’assiettes.

55/111
Représentation d’une pile Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Réprésentation d’une pile vide Structures
linéaires
Les piles
Les files
Les pointeurs
Pile Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Sommet Taille Max

56/111
Représentation d’une pile Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajout de l’élément A Structures
linéaires
Les piles
Les files
Les pointeurs
Pile A Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Sommet Taille Max

57/111
Représentation d’une pile Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajout de l’élément A Structures
linéaires
Les piles
Les files
Les pointeurs
Pile Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Sommet Taille Max

58/111
Représentation d’une pile Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajouts des éléments B,C,D,E,F Structures
linéaires
Les piles
Les files
Les pointeurs
Pile Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

A B C D E F

Sommet Taille Max

59/111
Représentation d’une pile Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Suppression d’un élément Structures
linéaires
Les piles
Les files
Les pointeurs
Pile F Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

A B C D E X

Sommet Taille Max

60/111
Les piles Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
Les primitives linéaires
Les piles
Les files
I estVide : retourne VRAI si la pile passée en paramètre Les pointeurs
Les listes chaînées
est vide, FAUX sinon. Listes doublement
chaînées
I empiler : ajouter l’élément passé en paramètre à la pile Structures
arborescentes
(passée en paramètre).
I dépiler : retourne le dernier élément de la pile passée
en paramètre (et le supprime).
I (afficher : affiche la pile passée en paramètre.)

61/111
Les piles Algorithmique
avancée

Fabien Teytaud

Structure et primitives d’une pile

#include <iostream> Premiers pas
#include <array>
Méthodes de tri
#define TAILLE_MAX 10
Structures
linéaires
struct Pile
{ Les piles
Les files
std::array<int, TAILLE_MAX> elements;
Les pointeurs
int sommet;
Les listes chaînées
};
Listes doublement
chaînées
bool estVide(Pile pile)
{ Structures
return (pile.sommet == 0); arborescentes
}

void empiler(Pile &pile, int v)

{
if (pile.sommet < TAILLE_MAX)
pile.elements[pile.sommet++] = v;
}

int depiler(Pile &pile)

{
// on ne traite pas le débordement négatif
return pile.elements[--pile.sommet];
}

62/111
Les piles Algorithmique
avancée

Fabien Teytaud

affichage et programme principal Premiers pas

void afficher(Pile pile)
Méthodes de tri
{
for (int i=0; i < pile.sommet; i++) Structures
std::cout << pile.elements[i] << " "; linéaires
std::cout << std::endl;
Les piles
}
Les files
Les pointeurs
int main() Les listes chaînées
{ Listes doublement
Pile maPile; chaînées
maPile.sommet=0;
Structures
empiler(maPile,1); arborescentes
empiler(maPile,2);
empiler(maPile,3);
empiler(maPile,4);
afficher(maPile);
while (!estVide(maPile))
{
std::cout << "On dépile " << depiler(maPile) << std::endl;
afficher(maPile);
}

return 0;
}

63/111
Les piles Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Execution Les files
fabien$ g++ -o pile pile.cpp
Les pointeurs
fabien$ ./pile Les listes chaînées
1 2 3 4 Listes doublement
On dépile 4 chaînées
1 2 3
On dépile 3 Structures
1 2 arborescentes
On dépile 2
1
On dépile 1

64/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas
Structures
linéaires
Les piles
Méthodes de tri Les files
Les pointeurs
Les listes chaînées
Listes doublement
Structures linéaires chaînées

Les piles Structures

arborescentes
Les files
Introduction aux pointeurs
Les listes chaînées
Listes doublement chaînées

Structures arborescentes

65/111
Les files Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Notion de files Les piles
Les files
Les pointeurs
I Ensemble d’éléments successifs. Les listes chaînées
Listes doublement
chaînées
I L’insertion et la suppression sont contraintes. Structures
arborescentes
I Seul l’élément le plus ancien est accessible.
I Principe du premier entré, premier sorti (FIFO).
I Exemple : une file d’attente.

66/111
1ère représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
File vide Structures
linéaires
Les piles
Les files
Les pointeurs
File Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Queue Taille Max

67/111
1ère représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajout de l’élément A Structures
linéaires
Les piles
Les files
Les pointeurs
File A Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Queue Taille Max

68/111
1ère représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajout de l’élément A Structures
linéaires
Les piles
Les files
Les pointeurs
File Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

Queue Taille Max

69/111
1ère représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Ajouts des éléments B,C,D,E,F Structures
linéaires
Les piles
Les files
Les pointeurs
File Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes

A B C D E F

Queue Taille Max

70/111
1ère représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Suppression d’un élément Méthodes de tri

Structures
linéaires
Les piles
Les files
Les pointeurs
Les listes chaînées
Listes doublement
File A chaînées

Structures
arborescentes

X B C D E F

Queue Taille Max

71/111
Les files Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Les primitives Structures

linéaires
Les piles
I estVide : retourne VRAI si la file passée en paramètre Les files
Les pointeurs
est vide, FAUX sinon. Les listes chaînées
Listes doublement
chaînées
I enfiler : ajouter l’élément passé en paramètre à la file
Structures
(passée en paramètre). arborescentes

I défiler : retourne le premier élément de la file passée

en paramètre (et le supprime). Ensuite, les éléments
restants sont décalés vers la gauche.
I (afficher : affiche la file passée en paramètre.)

72/111
Les files Algorithmique
avancée

Fabien Teytaud
Structure et primitives d’une file
#include <iostream>
#include <array> Premiers pas

#define TAILLE_MAX 10 Méthodes de tri

struct File Structures

{ linéaires
std::array<int, TAILLE_MAX> elements; Les piles
int queue; Les files
}; Les pointeurs
Les listes chaînées
bool estVide(File file) Listes doublement
chaînées
{
return (file.queue == 0); Structures
} arborescentes

void enfiler(File &file, int v)

{
if (file.queue < TAILLE_MAX)
file.elements[file.queue++] = v;
}

int defiler(File &file)

{
// on ne traite pas le débordement négatif
int v = file.elements[0];
file.queue--;
for (int i=0; i < file.queue; i++)
file.elements[i] = file.elements[i+1];
return v;
}

73/111
Les files Algorithmique
avancée

Fabien Teytaud

Affichage et programme principal Premiers pas

void afficher(File file)
Méthodes de tri
{
for (int i=0; i < file.queue; i++) Structures
std::cout << file.elements[i] << " "; linéaires
std::cout << std::endl;
Les piles
}
Les files
Les pointeurs
int main() Les listes chaînées
{ Listes doublement
File maFile; chaînées
maFile.queue=0;
Structures
enfiler(maFile,1); arborescentes
enfiler(maFile,2);
enfiler(maFile,3);
enfiler(maFile,4);
afficher(maFile);
while (!estVide(maFile))
{
std::cout << "On défile " << defiler(maFile) << std::endl;
afficher(maFile);
}

return 0;
}

74/111
Les files Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Execution
Les pointeurs
1 2 3 4
Les listes chaînées
On défile 1
Listes doublement
2 3 4 chaînées
On défile 2
3 4 Structures
On défile 3 arborescentes
4
On défile 4

75/111
Les files - 2ème représentation Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Les pointeurs
Les listes chaînées
Listes doublement
I Quel est le problème de cette représentation ? chaînées

Structures
I Comment y remédier ? arborescentes

76/111
2ème représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Représentation dans un tableau “circulaire” Structures

linéaires
Les piles
Les files
File Les pointeurs
Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes
A B C D E F

Tête Queue

77/111
2ème représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Ajouts de G,H,I,J Structures

linéaires
Les piles
Les files
File Les pointeurs
Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes
J A B C D E F G H I

Queue Tête

78/111
2ème représentation d’une file Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

On supprime un élément Structures

linéaires
Les piles
Les files
File Les pointeurs
Les listes chaînées
A Listes doublement
chaînées

Structures
arborescentes
J X B C D E F G H I

Queue Tête

79/111
Les files Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
Structure et primitives d’une file linéaires
void enfiler(File &file, int v) Les piles
{ Les files
file.elements[file.queue++] = v; Les pointeurs
if (file.queue == TAILLE_MAX) Les listes chaînées
file.queue = 0; Listes doublement
chaînées
}
Structures
int defiler(File &file) arborescentes
{
int v = file.elements[file.tete++];
if (file.tete == TAILLE_MAX)
file.tete = 0;
return v;
}

80/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas
Structures
linéaires
Les piles
Méthodes de tri Les files
Les pointeurs
Les listes chaînées
Listes doublement
Structures linéaires chaînées

Les piles Structures

arborescentes
Les files
Introduction aux pointeurs
Les listes chaînées
Listes doublement chaînées

Structures arborescentes

81/111
Introduction aux pointeurs Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
Notion de pointeur linéaires
Les piles
Les files
I Un pointeur est une variable qui peut contenir l’adresse Les pointeurs
Les listes chaînées
mémoire d’un “objet”, comme une variable ou une Listes doublement
chaînées
fonction. Structures
arborescentes
I Exemple : un pointeur sur un entier contient l’adresse
mémoire où une variable entière range la donnée qu’elle
contient.
I Les adresses sont typées.

82/111
Introduction aux pointeurs Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Pour ce cours : Les files
Les pointeurs
Les listes chaînées
I Déclaration d’un pointeur sur un entier : int *p. Listes doublement
chaînées

I Pour accéder à la valeur de l’objet, il faut le dépointer Structures

arborescentes
avec *.
I Pour avoir l’adresse d’un “objet”, il faut utiliser &.

83/111
Exemple de pointeurs Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

int main() Structures

{ linéaires
int a, b, *c, *d; Les piles
// a et b sont deux entiers Les files
// c et d sont deux pointeurs sur des entiers Les pointeurs
c = &a; // c reçoit l’adresse de a Les listes chaînées
*c = 2; // équivalent à : a = 2; Listes doublement
chaînées
*d = b; // ERREUR : d n’a pas été initialisé (il ne pointe sur rien)
} Structures
arborescentes

a b c d

84/111
Exemple de pointeurs Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

int main() Structures

{ linéaires
int a, b, *c, *d; Les piles
// a et b sont deux entiers Les files
// c et d sont deux pointeurs sur des entiers Les pointeurs
c = &a; // c reçoit l’adresse de a Les listes chaînées
*c = 2; // équivalent à : a = 2; Listes doublement
chaînées
*d = b; // ERREUR : d n’a pas été initialisé (il ne pointe sur rien)
} Structures
arborescentes

a b c d

c a b d

84/111
Exemple sur la fonction echange Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
void echange(int a, int b) Les files
{ Les pointeurs
int tmp = a; Les listes chaînées
a = b; Listes doublement
b = tmp; chaînées
}
Structures
arborescentes

I Quel est le problème de cette fonction ?

I Corrigez cette fonction en utilisant des pointeurs.

85/111
Exemple sur la fonction echange Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Les pointeurs
void echange(int *a, int *b) Les listes chaînées
{ Listes doublement
chaînées
int tmp = *a;
*a = *b; Structures
*b = tmp; arborescentes
}

86/111
Exemple sur la fonction echange Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
void echange(int *a, int *b)
{ Les piles
int tmp = *a; Les files
Les pointeurs
*a = *b;
Les listes chaînées
*b = tmp;
Listes doublement
} chaînées

Structures
arborescentes
L’appel se fera comme ceci :
int main()
{
int a = 2, b = 3;
echange(&a,&b);
}

87/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas
Structures
linéaires
Les piles
Méthodes de tri Les files
Les pointeurs
Les listes chaînées
Listes doublement
Structures linéaires chaînées

Les piles Structures

arborescentes
Les files
Introduction aux pointeurs
Les listes chaînées
Listes doublement chaînées

Structures arborescentes

88/111
Les listes chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires

Notion de listes chaînées Les piles

Les files
Les pointeurs
I Organisation linéaire des données. Les listes chaînées
Listes doublement
chaînées
I L’ordre est déterminé par un pointeur sur chaque Structures
arborescentes
élément de la liste.
I Représentation simple et souple pour les ensembles
dynamiques.

89/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Représentation des listes simplement chaînées Les pointeurs
Les listes chaînées
Listes doublement
chaînées

Structures
arborescentes
DébutListe A B C D X

90/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Représentation des listes simplement chaînées Les pointeurs
Les listes chaînées
Listes doublement
Structure d’un élément chaînées
struct Element
{ Structures
int donnee; arborescentes
Element *suivant;
};

91/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Affichage d’une liste chaînée Les files
void afficherListe(Element *maListe) Les pointeurs
{ Les listes chaînées
Element *courant = maListe; Listes doublement
while (courant != nullptr) chaînées
{
std::cout << courant->donnee << " "; Structures
courant = courant->suivant; arborescentes
}
std::cout << std::endl;
}

92/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Insertion au début d’une liste chaînée Méthodes de tri

Structures
linéaires
Les piles

DébutListe A B C D X Les files

Les pointeurs
Les listes chaînées
Listes doublement
chaînées
nouveau n X
Structures
arborescentes

93/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Insertion au début d’une liste chaînée Méthodes de tri

Structures
linéaires
Les piles

DébutListe A B C D X Les files

Les pointeurs
Les listes chaînées
Listes doublement
chaînées
nouveau n X
Structures
arborescentes

DébutListe A B C D X
(1)
(2)
nouveau n

93/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Insertion au début d’une liste chaînée Les piles
Element* insererDebutListe(Element *maListe, Element *nouveau) Les files
{ Les pointeurs
// si la liste est vide, alors la liste est le nouvel élément Les listes chaînées
if (maListe == nullptr) Listes doublement
return nouveau; chaînées

Structures
// on rajoute la liste à la suite du nouvel élément arborescentes
nouveau->suivant = maListe;

// le début de la liste pointe sur le nouvel élément

return nouveau;
}

94/111
Les listes simplement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Recherche dans une liste chaînée Les piles
Element* rechercherDansListe(Element *maListe, int valeur) Les files
{ Les pointeurs
Element *courant = maListe; Les listes chaînées
while (courant) Listes doublement
{ chaînées
if (courant->donnee == valeur) Structures
return courant; arborescentes
courant = courant->suivant;
}

return nullptr;
}

95/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas
Structures
linéaires
Les piles
Méthodes de tri Les files
Les pointeurs
Les listes chaînées
Listes doublement
Structures linéaires chaînées

Les piles Structures

arborescentes
Les files
Introduction aux pointeurs
Les listes chaînées
Listes doublement chaînées

Structures arborescentes

96/111
Les listes doublement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Représentation d’une liste doublement chaînée Les piles
Les files
Les pointeurs
Les listes chaînées
Listes doublement
chaînées
DébutListe Structures
arborescentes

X A B C D X

97/111
Les listes doublement chaînées Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Les piles
Les files
Représentation des listes doublement chaînées Les pointeurs
Les listes chaînées
Structure d’un élément Listes doublement
struct Element chaînées
{ Structures
Element *precedent; arborescentes
int donnee;
Element *suivant;
};

98/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Structures
linéaires

Méthodes de tri Structures

arborescentes
Définition
Parcours préfixé
Structures linéaires Parcours infixé
Parcours postfixé

Structures arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

99/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

I Structure de données chaînée. Structures

linéaires
I Graphe acyclique orienté possédant une unique racine. Structures
arborescentes
I Chaque noeud de l’arbre contient un pointeur vers son Définition
Parcours préfixé
fils gauche et son fils droit. Parcours infixé
Parcours postfixé
I Représentation ordonnée :
I Soit x un noeud d’un arbre binaire de recherche.
I Si y est un noeud du sous arbre gauche de x alors
y.donnee ≤ x.donnee.
I Si y 0 est un noeud du sous arbre droit de x alors
x.donnee ≤ y0 .donnee.

100/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires
Un peu de vocabulaire Structures
arborescentes
Définition
I Profondeur ou niveau : nombre de noeuds sur une même Parcours préfixé
Parcours infixé
branche de la racine à une feuille. Parcours postfixé

I Hauteur : profondeur maximum de l’arbre.

I Mot : chaîne formée, de gauche à droite, de la valeur
des feuilles de l’arbre.

101/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas
Exemple Méthodes de tri

Structures
linéaires
8
Structures
arborescentes
Définition
Parcours préfixé
Parcours infixé
5 15 Parcours postfixé

2 7 12 17

1 3
11 13

102/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Structures
linéaires

Méthodes de tri Structures

arborescentes
Définition
Parcours préfixé
Structures linéaires Parcours infixé
Parcours postfixé

Structures arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

103/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires

Structures
Parcours préfixé arborescentes
Définition
Parcours préfixé

1. Le traitement du noeud. Parcours infixé

Parcours postfixé

2. Parcours du sous-arbre gauche.

3. Parcours du sous-arbre droit.

104/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours :

105/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours : A - B - D - E - C - F - G

105/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Structures
linéaires

Méthodes de tri Structures

arborescentes
Définition
Parcours préfixé
Structures linéaires Parcours infixé
Parcours postfixé

Structures arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

106/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires

Structures
Parcours infixé arborescentes
Définition
Parcours préfixé
1. Parcours du sous-arbre gauche. Parcours infixé
Parcours postfixé

2. Le traitement du noeud.
3. Parcours du sous-arbre droit.

107/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours :

108/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours : D - B - E - A - F - C - G

108/111
Outline Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Premiers pas Structures
linéaires

Méthodes de tri Structures

arborescentes
Définition
Parcours préfixé
Structures linéaires Parcours infixé
Parcours postfixé

Structures arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

109/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri

Structures
linéaires

Structures
Parcours postfixé arborescentes
Définition
Parcours préfixé

1. Parcours du sous-arbre gauche. Parcours infixé

Parcours postfixé

2. Parcours du sous-arbre droit.

3. Le traitement du noeud.

110/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours :

111/111
Les arbres binaires de recherche Algorithmique
avancée

Fabien Teytaud

Premiers pas

Méthodes de tri
Exemple Structures
linéaires

Structures
A arborescentes
Définition
Parcours préfixé
Parcours infixé
Parcours postfixé

B C

D E F G

Parcours : D - E - B - F - G - C - A

111/111