Algorithmes

 et  Structures  de  

Données  -­‐  2  
Fabrice  Huet  
Université  de  Nice-­‐Sophia  An>polis  

1  
Piles  et  Files  

2  
 LIFO  et  FIFO  
• Listes  par>culières  
– Accès  aux  éléments  aux  extrémités  
• LIFO    
– Last  In  First  Out  
– C’est  une  pile  
• FIFO  
– First  In  First  Out  
– C’est  une  file  

3  
 Exemple  de  pile  
• Pile  d’assieLe  ou  boite  de  
comprimés  
• On  peut    
– Ajouter  au  sommet  
(empiler)  
– Supprimer  du  sommet  
(dépiler)  

4  
 Type  abstrait  Pile  
• Opéra>ons  possibles  
– estPlein(),  estVide()  
– empiler()  (ou  push())  
– depiler()  (ou  pop())  

5  
 Exemple  :  expressions  posVixées  
• Une  expression  est  posVixée  si  l’opérateur  
suit  les  opérandes    
– Reverse  Polish    Nota>on  
– L’opérateur  suit  toujours  le  deuxième  opérande  
• Exemples  :  
– 7  *  2  =>  7  2  *  
– 7  *  (2  +  5)  =>  7  2  5  +  *      
• Très  pra>que  car  non  ambigue  

6  
 Évalua>on  des  expressions  posVixées  
• On  u>lise  une  pile  
• On  lit  l’expression  de  gauche  à  droite  
– Si  opérande,  on  l’empile  
– Si  opérateur,  on  dépile  deux  opérandes,  on  fait  le  
calcule,  on  empile  le  résultat  

7  
 Algorithme  
en>er  evalPosVix(caractère  expression[1..N])  {    
 pile  p  vide;  
 pour  (i  de  1  à  N)  {    
   si  (estNombre(expression[i]))    
     empiler(p,  nombre(expression[i]));    
   sinon    
     si  (estOpérateur(expression[i])  {  
       op1  <-­‐  dépiler(p);  
       op2  <-­‐  dépiler(p);  
       résultat  <-­‐  opère(op1,  op2,  expression[i]);    
       empiler(p,  résultat);    
     }  
   }      
 retourner  (dépiler(p));    
}    
 
8  
 Implémenta>on  d’une  pile  
• Avec  une  liste  chainée    
– Ajout/suppression  en  tête  
– Très  facile  
• Avec  un  tableau  
– Sommet  de  la  pile  à  la  fin  
– Ajout/suppression  en  fin  de  tableau  
– Très  facile,  sauf  si  empiler  dans  tableau  plein  

9  
 Type  abstrait  file  (FIFO)  

• Opéra>ons  possibles  
– estVide()  
– ajouterQueue()  
– supprimerTete()  

10  
 Implémenta>on  d’une  file  (FIFO)  

• Avec  une  liste  chainée    

– Ajout  en  tête,  suppression  en  queue  
– Facile  et  efficace  si  on  a  un  pointeur  sur  fin  de  liste    
• Avec  un  tableau  
– Nécessite  des  décalages  dans  le  tableau  …  
– …  ou  pas  si  on  u>lise  un  tableau  circulaire      

11  
Arbres  

12  
 Défini>on  et  vocabulaire  
• Un  arbre  est  un  ensemble  d’éléments  appelés  nœuds  
organisés  par  niveaux  de  façon  hiérarchique  à  par>r  
d’un  nœud  dis>ngué  appelé́  racine    
• Soit  a  un  arbre  et  x  un  nœud  de  a  
– Les  nœuds  reliés  à  x  au  niveau  immédiatement    inférieur  
s’appellent  les  fils  de  x    
– Si  f  est  un  fils  de  x,  x  est  son  père    
– Le  nœud  s’il  existe  immédiatement  à  droite  de  x  et  de  
même  père  que  x  s’appelle  le  frère  (ou  alternant)  de  x    
– Un  nœud  sans  fils  est  une  feuille    
– Le  fils  le  plus  à  gauche  d’un  nœud  s’appelle  le  successeur  
du  nœud    
• On  u>lise  souvent  un  vocabulaire  imagé    
– Père,  grand-­‐père,  oncle,  frère,  pe>t  fils…  
13  
 Défini>on  et  vocabulaire  
• Soit  a  un  arbre  
– Un  sous  arbre  de  a  est  un  arbre  de  racine  un  
nœud  quelconque  de  a    
– Une  branche  de  a  est  une  suite  de  nœuds  reliés  
de  la  racine  à  une  feuille    
– Si  a  est  tel  que  chaque  nœud  a  au  plus  n  fils,  a  est  
dit  n-­‐aire    
– Un  arbre  2-­‐aire  s’appelle  un  arbre  binaire    
– Dans  un  arbre  binaire,  on  parle  de  fils  droit  et  de  
fils  gauche  d’un  nœud    

14  
Définitions, vocabulaire
Défini>on   e t   vocabulaire  
La figure suivante résume l’ensemble de ces
définitions

5.28

15  
 Arbres  n-­‐aires  vs  arbres  binaires  
• Il  y  a  une  rela>on  étroite  entre  arbres  n-­‐aires  et  
binaires,  plus  précisément  tout  arbre  n-­‐aire  peut  
se  représenter  par  un  seul  arbre  binaire  et  la  
correspondance  est  bijec>ve    
• chaque  nœud  x  de  l’arbre  binaire  est  un  nœud  y  
de  l’arbre  n-­‐aire  de  sorte  que    
– Le  fils  gauche  de  y  est  le  fils  gauche  de  x  
– Le  frère  de  y  est  le  fils  droit  de  x    
• L’étude  des  arbres  binaire  est  donc  primordiale    
• Une  liste  est  un  arbre  1-­‐aire  !    

16  
Arbres  n-­‐aires  vs  arbres  binaires  

hLp://en.wikipedia.org/wiki/Binary_tree   17  
Arbres  binaires  

18  
 Défini>on  et  vocabulaire  
• Un  arbre  binaire  est  défini  par  l’équa>on  
récurrente    

B = φ ∪ (Bg , a, Bd )
• Autrement  dit,  un  arbre  binaire  est  soit    
– Vide  
– Soit  formé  d’un  nœud  (racine)  et  de  deux  sous-­‐
arbres  binaires  gauche  et  droit  

19  
 Profondeur  -­‐  Niveau  
• La  profondeur  d’un  nœud  x  est  
le  nombre  de  nœuds  
rencontrés  depuis  la  racine  sur  
l’unique  branche  menant  à  x  
– Profondeur  de  la  racine  =  0  
• Le  niveau  d’un  arbre  est   Profondeur  =  0  
l’ensemble  des  nœuds  se  
trouvant  à  la  même   Profondeur  =  1  

profondeur  
Profondeur  =  3  
20  
 Hauteur  
• La  hauteur  d’un  arbre  est  la  
profondeur  maximum  de  ses  
nœuds  
• Exemple  :    
– Hauteur  =  3  

21  
 Arbres  par>culiers  
• Un  arbre  est  filiforme  si  chaque  
père  n’a  qu’un  fils  
– Un  arbre  filiforme  de  n  nœuds  a  
une  hauteur  de  n-­‐1  
• Un  arbre  est  complet  si  tout  ses  
niveaux  sont  remplis  

22  
 Propriétés  d’un  arbre  binaire  complet  
• Proposi;on  :  un  arbre  complet  de  hauteur  h  a  
2h+1  -­‐1  nœuds  
• Preuve  :  
– Il  y  a  1  nœud  (racine)  au  niveau  0  
– Il  y  a  2  nœuds  au  niveau  1,  4  au  niveau  2…  
– Total  =  1+  2+  3+  …  +  2h  =  2h+1  -­‐1    

23  
 Propriétés  d’un  arbre  binaire  complet  
• Proposi;on  :  un  arbre  complet  de  n  nœuds  est  
de  hauteur  log2(n+1)-­‐1  
• Preuve  :  
– On  u>lise  la  proposi>on  précédente  
– n  =  2h+1  -­‐1  =>n+1=2h+1  …  

24  
 Propriétés  d’un  arbre  binaire  
• Proposi;on  :  pour  tout  arbre  binaire  de  n  
nœuds  et  de  hauteur  h,  on  a    
h +1 ≤ n ≤ 2 h+1 −1
#$log 2 (n)%& ≤ h ≤ n −1
• Preuve  :  pour  n  nœuds,  la  hauteur  max  est  
pour  l’arbre  filiforme,  la  hauteur  min  pour  
l’arbre  complet  

25  
Implémenta>on  d’un  arbre  binaire  
• S’implémente  de  deux  façons  
– Tableau  ou  chainage    
• Tableau  
– Chaque  élément  du  tableau  mémorise  l’élément,  
et  les  indices  des  fils  gauche  et  droit  
– Ges>on  des  indices  «  à  la  main  »  

26  
Implémenta>on  d’un  arbre  binaire  
• Exemple  

Indice   0   1   2   3   4   5   6   7   8   A
Element   F   E   A   D   B   C   G  
Fg   5   4   B C

Fd   8   6   2   1  
D E F

27  
Implémenta>on  d’un  arbre  binaire  
• Chainage  
– Structure  récursive,  comme  pour  les  listes  

structure  nœud  {   structure  arbre  {  

       en>er  element;          nœud  racine;  
           nœud  fg;   }  
           nœud  fd;  
}  

• La  structure  arbre  est  op>onnelle  

– Elle  complique  même  parfois  les  algorithmes!  
28  
 Inser>on/Suppression  de  nœuds    
• Inser>on  
– Pour  simplifier,  on  ajoute  toujours  un  nouveau  
nœud  à  une  feuille     A A

B C B C

D D
A D

A A
B C
B C B C

D D
29  
 Inser>on/Suppression  de  nœuds    
• Suppression  
• Plusieurs  cas  à  considérer  suivant  le  nœud  
qu’on  supprime  
– 0  fils  (facile)  
– 1  fils  (facile)  
– 2  fils  (moins  facile)  
• On  y  reviendra…  

30  
 Parcours  d’un  arbre  
• Parcourir  un  arbre  consiste  à  visiter  tout  ses  
nœuds  avec  une  stratégie  de  parcours  
• 2  familles  de  parcours  
– En  largeur  (breadth  first  search)    
• On  visite  tous  les  nœuds  d’un  niveau  avant  de  passer  
au  suivant  
– En  profondeur  (depth  first  search)  
• On  visite  les  fils  d’un  nœud  avant  de  passer  au  frère  

31  
 Parcours  en  profondeur  
• 3  variantes  suivant  l’ordre  de  visite  du  nœud  
(racine)  
• Préfixé  :  racine,  fg,  fd  
A
• Infixé  :    fg,  racine,  fd  
• PosVixé  :  fg,  fd,  racine   B C

• Exemple  :     D
E
– Préfixé  :  A,  B,  D,  C,  E  
– Infixé  :  D,  B,  A,  E,  C  
– PosVixé  :  D,  B,  E,  C,  A    
32  
 Exemple  :  parcours  infixe  
• Facile  à  écrire  en  récursif    
 
parcours_infixe(nœud  n)  {  
       si  (n  =  NIL)  retourner;    
       parcours_infixe(n.fg);  
       afficher(n.element)  
       parcours_infixe(n.fd);  
 }    
         

33  
 Recherche    
• Comment  savoir  si  un  élément  est  dans  un  
arbre?  
– Il  faut  regarder  tous  les  nœuds    
• Donc  complexité  en  O(n)  L  
– Pas  mieux  qu’une  liste  chainée  ou  qu’un  tableau  
en  vrac  
• Justement,  si  on  ne  meLait  pas  tout  en  vrac  ?  

34  
Arbres  binaires  de  recherche  

35  
 Défini>on    
• Ajout  d’une  propriété  aux  arbres  binaires  
Pour  chaque  nœud  x,  tous  les  éléments  du  sous  arbre  
gauche  (resp.  droit)  ont  des  valeurs  inférieures  (resp.  
supérieurs)  ou  égales  à  celle  de  x.  
• Successeur  
– Le  successeur  de  x  est  le  plus  pe;t  y  tel  que  y  >  x  
• La  recherche  se  fait  par  dichotomie!  

36  
 Cherchez  l’ABR  
• Des  arbres  suivants,  lesquels  sont  des  ABR?  
5   7   5  

2   7   2   5   2   7  

1   3   6   8   1   3   6   8   1   6   8  

5   5   5  

2   9   4   7  

1   3   3   10   1   6   6   8  
 Recherche  
• La  recherche  se  fait  par  dichotomie  
       rechercher(noeud  x,  element  k)  {  
                       si  x  =  NIL  ou    x.element  =  k  
                               alors  retourner  x;  
                       si  k  <  x.element  
                             rechercher(x.fg,k);  
                       sinon  
                             rechercher(x.fd,k);  
         }  

5  

2   7   Rechercher  3:  5  →  2  →  3  
Rechercher  6:  5  →  7  →  6  
1   3   6   8  
 Recherche  -­‐  2  
• Proposi>on  :  la  complexité  de  la  recherche  dans  
un  arbre  binaire  de  recherche  pour  le  pire  des  cas  
est  O(h)  avec  h  hauteur  de  l’arbre  
• Preuve  :  Dans  le  pire  des  cas,  l’élément  à  trouver  
est  sur  une  feuille  de  l’arbre,  il  faut  donc  
parcourir  un  chemin  de  l’arbre  partant  de  la  
racine  jusqu’à  ceLe  feuille,  soit  h  recherches.  
 Inser>on  -­‐  1  
• Permet  d’ajouter  un  nouveau  nœud  à  un  arbre  
• L’inser>on  modifie  la  structure  de  l’arbre  et  doit  donc  
s’assurer  de  la  conserva>on  de  sa  propriété  

5   5  
Inserer(15)  
2   7   2   7  
Inserer(9)  
1   3   6   8   1   3   6   8  

15  

9  
 Inser>on  –  2  
     inserer(arbre  T,  nœud  z)  {  
         y  ←  NIL  
         x  ←  T.racine  
         tant  que  x  ≠  NIL  faire    
                             y  ←  x  
On  cherche  un  nœud  qui  n’a  pas  
                             si  z.clé  <  x.clé     de  fils  pour  y  ajouter  z  
                             alors    x  ←  x.gauche;  
                             sinon  x  ←  x.droit;  
         si  y  =  NIL    
L’arbre  était  en  fait  vide  
         alors  T.racine  ←  z;  
         sinon  si  z.clé  <  y.clé  
                               alors    y.gauche  ←  z;   On  ajoute  z  a  la  «  bonne  »  place  
                               sinon  y.droit  ←  z;  
                   
 Suppression  -­‐  1  
• La  suppression  enlève  un  nœud  à  l’arbre  
• Elle  doit  conserver  la  propriété  de  l’ABR  
5  
5  
2   7  
supprimer(15)  
2   8  

1   3   6   8   Supprimer(7)  
1   3   6   9  

15  

9  

• On  dis>ngue  3  cas  pour  la  suppression  

 Suppression  -­‐  2  
• Suppression  d’un  nœud  sans  fils  (trivial)  

5  
5  
2   7  
supprimer(9)  
2   7  

1   3   6   8  
1   3   6   8  

15  
15  

9  
 Suppression  -­‐  3  
• Suppression  d’un  nœud  avec  un  unique  fils  
(presque  trivial)  

5  
5  
2   7  
supprimer(15)  
2   7  

1   3   6   8  
1   3   6   8  

15  

9  
9  
 Suppression  -­‐  4  
• Suppression  d’un  nœud  ayant  2  fils  (non  trivial)  

5   6  

2   8   Supprimer(5)   2   8  

1   3   6   9   1   3   7   9  

7   15   15  

Successeur  de  5   11   11  

• On  remplace  le  nœud  à  supprimer  par  son  successeur  et  on  

supprime  le  successeur  
 Résumé    
• Nous  avons  étudié  3  opéra>ons  
– Recherche  
– Ajout    
– Suppression  
• Toutes  ont  une  complexité  en  O(h)  avec  h  hauteur  
de  l’arbre  
• Bonne  nouvelle:  un  arbre  complet  de  n  nœuds  à  
une  hauteur  de  log2(n+1)-­‐1…    
• …  et  les  arbres  qu’on  trouve  dans  la  nature?    
 Problème  de  l’équilibrage  
ajouter(5);   ajouter(7);  
ajouter(8);   ajouter(3);  
ajouter(2);   ajouter(6);  
ajouter(7);   ajouter(2);  
ajouter(3);   ajouter(8);   8  
ajouter(6);   ajouter(1);  
ajouter(1);   7  
ajouter(5);  
5   6  

5  
2   7  
3  

2  
1   3   6   8  
1  

• Ces  deux  arbres  con>ennent  les  mêmes  données  

• Mais  leur  hauteur  est  très  différente  
• Il  vaut  mieux  avoir  l’arbre  gauche  (complet)  que  celui  de  
droite  (filiforme)  
 Arbres  équilibrés  
• Un  arbre  est  dit  équilibré  si  pour  chacun  de  ses  
nœuds,  les  sous  arbres  diffèrent  d’au  plus  1  en  
hauteur  
Problème  d’équilibrage  
 Arbres  équilibrés  -­‐  2  
• Pourquoi  avoir  des  arbres  équilibrés?  
• Parce  que  dans  le  pire  des  cas,  la  recherche  est  en  
O(log(n))!  
• Preuve?  
– On  a  vu  que  la  recherche  dans  un  ABR  est  O(h)  avec  h  
hauteur  de  l’arbre  dans  le  pire  des  cas  
– Il  nous  faut  donc  montrer  que  la  hauteur  d’un  arbre  
équilibréé  est  O(log(n))  
 Hauteur  d’un  arbre  équilibré  
• On  va  chercher  le  nombre  minimum  de  nœuds  
(non  feuilles)  nécessaire  pour  construire  un  arbre  
de  hauteur  h  
• Soit  Th  un  arbre  équilibré  minimal  de  hauteur  h  
avec  nh  nœuds.    
• On  a    
T0    =   n0    =  0  

T1    =   n1    =  1  
 Hauteur  d’un  arbre  équilibré  -­‐  2  
• On  considère  Th,  h≥2.  Il  doit  donc  avoir  un  sous  arbre  de  
profondeur  h-­‐1    et  un  autre  de  profondeur  h-­‐1  ou  h-­‐2.    
• Pour  tout  k,  un  arbre  de  hauteur  k    a  un  sous  arbre  de  
hauteur  k-­‐1.  Donc  nk  >  nk-­‐1  
• Supposons  que  les  deux  sous  arbres  de  Th  sont  Th-­‐1  et  Th-­‐1    
– alors  on  pourrait  en  remplacer  un  par  Th-­‐2  et  garder  la  propriété  
d’équilibrage  
– on  aurait  alors  moins  de  nœuds  car  nh-­‐1  >  nh-­‐2  
– notre  arbre  ne  serait  donc  pas  minimal:  CONTRADICTION!  
 Hauteur  d’un  arbre  équilibré  -­‐  3  
• Th  a  donc  a  un  sous  arbre  Th-­‐1  et  un  autre  Th-­‐2  

Th    =   nh    =  nh-­‐1  +  nh-­‐2  +1  

Th-­‐1   Th-­‐2  

• Ça  ressemble  étrangement  à  la  suite  de  Fibonacci!  

• On  montre  (pas  ici)  que    

h+2 h+2
1 ⎛ 1 + 5 ⎞ 1 ⎛ 1 − 5 ⎞
nh = ⎜ ⎟ − ⎜ ⎟ −1
5 ⎜⎝ 2 ⎟⎠ 5 ⎜⎝ 2 ⎟⎠
 Hauteur  d’un  arbre  équilibré  -­‐  3   h+2
⎛ 1 − 5 ⎞ ⎛ 1 − 5 ⎞
• Etant  donne  que    ⎜                    ⎟      <    1      le  terme        ⎜⎜                      ⎟⎟    sera  pe>t    
⎜ ⎟
⎝ 2 ⎠ ⎝ 2 ⎠

• Donc   h+2
1 ⎛ 1 + 5 ⎞
nh + 1 = ⎜ ⎟ + O(1)
5 ⎝ 2 ⎟⎠
⎜
• Comme  nh  nombre  minimal  de  nœuds  pour  un  arbre  
équilibré  de  hauteur  h,  tout  autre  arbre  équilibré  de  
hauteur  h  aura  n  nœuds  tel  que     h + 2
1 ⎛ 1 + 5 ⎞
n + 1 ≥ nh + 1 = ⎜ ⎟ + O(1)
5 ⎝ 2 ⎟⎠
⎜

1
• Ce  qui  donne   h≤ log(n + 1) + O(1) ≈ 1.44 log(n + 1)
1+ 5
log
2
 Complexité  des  opéra>ons  
• Nous  avons  donc  montré  qu’un  arbre  équilibré  compose  
de  n  nœuds  aura  une  hauteur  majorée  par  1.44log(n+1)  

• On  sait  que  les  opéra>ons  d’ajout/recherche/suppression  

dans  un  arbre  dans  le  pire  des  cas  ont  une  complexité  en  
O(h)  

• Conclusion:  Dans  un  arbre  binaire  équilibré  composé  de  

n  noeuds,  les  opéra>ons  d’ajout,  de  recherche  et  de  
suppression  ont  une  complexité  dans  le  pire  des  cas  en  
O(log(n)).  
ABR  équilibrés  

55  
 Arbres  AVL  
• Inventés  par  G.M.  Adelson-­‐Velsky  et  E.M.  
Landis  
– «  An  algorithm  for  the  organiza>on  of  
informa>on  »,  1962  
• Arbre  binaire  de  recherche  auto-­‐équilibrant  
– Plus  facile  d’être  équilibré  si  on  l’est  
régulièrement  
– Après  chaque  opéra>on,  un  rééquilibrage  est  
effectué  si  nécessaire  
 Facteur  d’equilibrage  
• Facteur  d’équilibrage  d’un  noeud  
– On  définit  le  facteur  d’équilibrage  d’un  noeud  
comme  la  différence  de  hauteur  entre  le  sous  arbre  
droit  et  le  sous  arbre  gauche  
• Quelles  sont  les  valeurs  possibles?  
• Pour  des  raisons  de  performance,  les  nœuds  
d’un  AVL  con>ennent  tous  leur  facteur  
d’équilibrage  
– Recalculé  après  chaque  opéra>on  
• Permet  de  déterminer  si  une  opéra>on  de  
rééquilibrage  est  nécessaire  
Exemple  d’AVL  
40   1  

20   1   50   -­‐1  

30   0   45   -­‐1   70   0  

44   0  
 Rota>on  
• La  rota>on  est  une  opéra>on  locale  dans  un  arbre  qui  ne  
modifie  pas  l’ordre  infixe  des  clés  
• On  dis>ngue  2  types  de  rota>ons:  gauche  et  droite  
Rota>on  droite(T,  y)  
y   x  

x   γ   α   y  

α   Rota>on  gauche(T,  x)   β   γ  

β  
• Rota>on  gauche:  on  suppose  que  le  fils  droit  (y)  est  non  NILL.    
– On  fait  pivoter  l’ensemble  autour  du  lien  x-­‐y  
– y  devient  la  nouvelle  racine  du  sous  arbre  
– x  devient  fils  gauche  de  y  
– Le  fils  gauche  de  y  devient  fils  droit  de  x  
 Rota>on  et  facteur  d’équilibrage  
B   0  
A   -­‐2  
• Rota>on  droite  
B   -­‐1   A   0  

Z  

X   Y   X   Y   Z  

D   0  
C   2  
• Rota>on  gauche  
D   1   C   0  

X  

Y   Z   X   Y   Z  
 Double  rota>on  gauche-­‐droite  
A   -­‐2   A   -­‐2  

B   1   B   1  

Z   Z  
C  
0  

X   Y   X  

Y1   Y2  

• On  décompose  le  sous  arbre  droit  de  B  en  un  nœud  et  
ses  2  sous  arbres  
• On  effectue  2  rota>ons,  une  gauche,  puis  une  droite  
 Double  rota>on  gauche-­‐droite  -­‐  2  
A   -­‐2   A   C  

B   1   C  
A  
Z   Z  
C   B   B  
0  
X  
Z  
Y1   Y2   Y1   Y2   Y1   Y2  
X   X  
 AVL  -­‐  Résumé  
• Un  AVL  est  donc  un  ABR  où  l’équilibre  est  
maintenu  après  chaque  opéra>on  
• Nous  avons  vu  l’inser>on,  la  suppression  
fonc>onne  suivant  le  même  principe  
• On  peut  montrer  (pas  ici)  que  
– L’inser>on  nécessite  au  maximum  1  rééquilibrage  
– La  suppression  peut  nécessiter  au  maximum  autant  
de  rééquilibrages  que  la  hauteur  de  l’arbre  
• Il  existe  d’autres  familles  d’arbres  auto  
équilibrants,  par  exemple  les  arbres  Rouge-­‐Noir  
Tris  itéra>fs  

64  
 Introduc>on  
• Trier  consiste  à  ordonner  les  éléments  d’un  
ensemble  suivant  une  rela>on  d’ordre  
• Un  algorithme  de  tri  est  un  algorithme  qui    
– prend  en  entrée  une  série  de  valeurs  (souvent  un  tableau)    
– produit  en  sor>e  une  séquence  de  valeurs  ordonnée  
• Plus  formellement,  un  tri  doit    produire  une  sor>e  
sa>sfaisant  les  2  propriétés  suivantes  
– La  séquence  de  sor>e  est  une  permutation de  la  
séquence  d’entrée    
– Chaque  élément  de  la  séquence  est  plus  grand  que  les  
précédents  
 
 Tri  compara>f  et  tri  en  place  
• Un  tri  compara>f  est  un  tri  qui  n’u>lise  qu’un  opérateur  
binaire  pour  placer  les  éléments    
– En  général  l’opérateur  “inférieur  ou  égal”  
• Cet  opérateur  doit  fournir  un  ordre  total  
– Si  a  ≤  b  et  b  ≤  a    alors  a  =  b  (an>symétrie)  
– Si  a  ≤  b  et  b  ≤  c  alors  a  ≤  c  (transi>vité)  
– a  ≤  b  or  b  ≤  a    pour  tout  a  et  b    
• Pour  trier  un  ensemble,  on  peut  avoir  besoin  d’un  
ensemble  intermédiaire  
– Ex:  trier  un  tableau  en  passant  par  un  ou  plusieurs  tableaux  
intermédiaires  
• Si  un  tri  ne  nécessite  pas  de  placer  plus  d’un  nombre  
nombre  constant  d’éléments  hors  de  l’ensemble  d’entrée,  
il  est  dit  sur place
 Taxonomie  des  tris  
• Dans  The Art Of Computer Programming (Vol 3),  
Donald  E.  Knuth  analyse  25  algorithmes  de  tri  différents  
• Mais  ce  n’est  qu’une  frac>on  de  ce  qui  existe  
• Pourquoi  tant  d’algorithmes?  
– Parce  que  chacun  a  des  avantages  et  des  inconvénients  
– Ce  qui  marche  bien  pour  un  problème  ne  marche  pas  bien  pour  
un  autre  
• Il  n’y  a  donc  pas  un  «  meilleur  »  tri,  il  y  en  a  plusieurs    
– Mais  il  y  en  a  qui  sont  très  mauvais  
 Tri  par  inser>on  ( )  
• Un  tri  simple  consiste  à  séparer  les  données  en  2  
ensembles  :  triées  et  non  triées  
• Le  but  est  de  diminuer  l’ensemble  des  non  triées  au  
profit  des  triées  
• Pour  chacun  des  éléments  non  triés  
– On  prend  le  premier  
– On  le  place  à  la  bonne  posi>on  parmi  les  triés  
Tri  par  inser>on  ( )  
Ensemble  trié   Ensemble  non  trié  

10   3   5   7   8  

10   3   5   7   8  

3   10   5   7   8  

3   5   10   7   8  

3   5   7   10   8  

3   5   7   8   10  
 Ecriture  de  l’algorithme  
• L’algorithme  fonc>onne  sur  chacun  des  
éléments  non  triés  
– On  suppose  qu’ils  sont  dans  un  tableau  
– U>lisa>on  d’une  boucle  pour  
• Prendre  le  premier  élément  non  trié  
– hmmm  pas  trop  difficile  
• Insérer  le  nouvel  élément  à  la  bonne  posi>on  
– Il  faut  trouver  la  bonne  posi>on  et  décaler  les  
autres  
 Inser>on  d’un  élément  dans  un  tableau  trié  
en  place  
• On  u>lise  le  même  tableau  
– On  suppose  que  l’élément  à  insérer  se  trouve  
immédiatement  après  les  éléments  triés  
– On  le  fait  remonter  jusqu’à  la  bonne  posi>on  
– C’est  à  dire  jusqu’à  ce  que  celui  juste  à  côté  soit  plus  
pe>t  que  lui  
• Soit  on  trouve  une  bonne  posi>on  entre  2  
éléments  
• Soit  on  s’arrête  parce  qu’on  a  aLeint  la  limite  du  
tableau  
 Inser>on  d’un  élément  dans  un  tableau  trié  
en  place  

3   5   7   10   8   3   5   7   8   10  

• On  n’u>lise  pas  de  tableau  intermédiaire  

• Complexité  de  l’inser>on  
– En  opéra>ons  :  O(n)  
– En  mémoire  :  O(1)  
 Algorithme  
Tri-­‐Inser>on(A[1..N])  {
     pour  j  ←  2  à  N  {
                   clé  ←  A[j]  
                     i  ←  j-­‐1  
                     tant que  i  >  0  et  A[i]  >  clé  {  
                                             A[i+1]  ←  A[i]  
                                             i  ←  i-­‐1   Inser>on  de  A[j]  dans  la  
séquence  déjà  triée    
                     }
                       A[i+1]  ←  clé  
                  }
 }
 Complexité  –  meilleur  et  pire  cas  
• Meilleur  des  cas:  
– La  boucle  tant que n’effectue  qu’une  comparaison  
– Autrement  dit,  on  a  immédiatement  A[i]  ≤  clé  
– Ce  qui  veut  dire  A[i]  ≤  A[j]  ⇔  A[j-­‐1]  ≤  A[j]  
– Et  donc  le  tableau  est  déjà  trié!  
• Pire  des  cas:  
– La  boucle  tant que  effectue  le  nombre  maximal  de  
comparaisons  
– Elle  ne  s’arrête  que  quand  i=0
– Donc  à  chaque  étape  on  a  A[i]  >  A[j]  ⇔  A[j-­‐1]  >  A[j]  
– Et  donc  le  tableau  est  en  ordre  inverse!  
• Tri  par  inser>on:  
– Meilleur:  tableau  déjà  trié  
– Pire:  tableau  trié  en  ordre  inverse  
 Complexité  du  tri  par  inser>on  
• On  peut  maintenant  procéder  au  calcul  de  la  complexité  
• Pour  un  tableau  de  taille  n
– La  boucle  pour  sera  exécutée  n-1 fois  
– La  bouche  tant que  sera  exécutée  
• 1  fois  pour  chaque  itéra>on  dans  le  meilleur  des  cas  
• j -1  fois  pour  chaque  itéra>on  dans  le  pire,  c’est-­‐à-­‐dire  0, 1, 2, … n-1
• Dans  le  pire  des  cas,  en  notant  T  le  nombre  d’opéra>ons,  on  a        

• En  u>lisant  la  formule  de  la  somme  d’une  suite  arithmé>que:  

• On  en  déduit  les  complexités  suivantes  

– Meilleur  des  cas:  Θ(n)    
– Pire  des  cas:  Θ(n2)
 Complexité  du  tri  par  inser>on  -­‐  2    
• Et  le  cas  moyen?  
• Une  analyse  rigoureuse  est  trop  compliquée  (pour  nous  J)  
• Nous  allons  procéder  avec  intui>on  
• Tout  le  problème  vient  de  savoir  combien  d’éléments  sont  
inférieurs  a  celui  qu’on  veut  insérer  (boucle  tant que)  
• Si  mon  tableau  est  aléatoire,  alors  en  moyenne  j’en  ai  la  moi>é  
(il  faudrait  le  démontrer  rigoureusement)  
• Dans  ce  cas,  le  temps  T(n)  est  de  la  forme  

• Donc  le  cas  moyen  est  en  Θ(n2)    

• Conclusion:  le  tri  par  inser>on  n’est  pas  un  bon  tri  (sauf  pour  
un  ensemble  déjà  trié!)  
 Tri  à  bulle  ( )  
• Ce  tri  u>lise  la  poussée  d’Archimède    
• Toutes  les  clés  ont  le  même  poids,  leur  valeur  indique  leur  
volume  
– Plus  une  clé  a  une  valeur  élevée,  plus  son  volume  est  important,  
moins  elle  est  dense  
– Un  objet  peu  dense  monte  a  la  surface  des  liquides  
– Donc  une  clé  a  valeur  élevée  va  «  remonter  »  a  la  surface  du  tableau    
– Comme  une  bulle  dans  un  liquide  (soda,  bière…)  
• Principe:  
– On  compare  les  clés  K1  et  K2 et  on  permute  les  éléments  si  nécessaire  
– On  recommence  avec  les  clés  K2  et  K3    
• Cet  algorithme  fait  se  déplacer  les  clés  les  plus  grandes  vers  la  
droite  
– L’élément  de  plus  grande  clé  se  retrouvera  donc  en  fin  de  tableau  
– A  la  fin,  le  tableau  sera  trié  
 Tri  à  bulle  ( )  
• Ce  tri  u>lise  la  poussée  d’Archimède    
• Toutes  les  clés  ont  le  même  poids,  leur  valeur  indique  leur  
volume  
– Plus  une  clé  a  une  valeur  élevée,  plus  son  volume  est  important,  
moins  elle  est  dense  
– Un  objet  peu  dense  monte  a  la  surface  des  liquides  
– Donc  une  clé  a  valeur  élevée  va  «  remonter  »  a  la  surface  du  tableau    
– Comme  une  bulle  dans  un  liquide  (soda,  bière…)  
• Principe:  
– On  compare  les  clés  K1  et  K2 et  on  permute  les  éléments  si  nécessaire  
– On  recommence  avec  les  clés  K2  et  K3    
• Cet  algorithme  fait  se  déplacer  les  clés  les  plus  grandes  vers  la  
droite  
– L’élément  de  plus  grande  clé  se  retrouvera  donc  en  fin  de  tableau  
– A  la  fin,  le  tableau  sera  trié  
 Tri  à  bulle    
• On  considère  un  tableau  T  
• Le  tri  a  bulle  consiste  à  faire  remonter  le  plus  grand  
élément  en  fin  de  tableau,  puis  faire  remonter  la  
deuxième  plus  grand  en  avant  dernière  place…  
10   3   1   7   9   3   10   1   7   9   3   1   10   7   9   3   1   7   10   9  

1   3   7   9   10   1   3   7   9   10   3   1   7   9   10   3   1   7   9   10  

• L’élément  le  plus  grand  remonte  vers  la  fin  du  tableau  
comme  une  bulle  d’eau  vers  la  surface  
 Tri  à  bulle  -­‐  Algorithme    
TriBulle(réel  T[1..N])  {  
     pour  (i  de  1  à  N)  {  
     pour  (j  de  1  à  N-­‐i)  {   On  va  traiter  tous  les  
éléments  du  tableau    
Sous  
           si  (T[j]  >  T[j+1])   tableau  
               permuter(T[j],T[j+1])   non  trié    
     }  
     }  
}                                

Complexité  en  Θ(n2)    

 Algorithme  
• Autre  implémenta>on  du  tri  a  bulle  
Tri-­‐Bulle(A)  {
répéter {
permut  ←  faux  
pour i de 1 à N-1 {
si (A[i]  >  A[i+1])  {
                       Échanger(A[i],  A[i+1])  
permut  ←  vrai    
}
}
} tant que (permut  =  vrai)  
}

• Quel  est  le  rôle  de  la  variable  permut?  

 Complexité  du  tri  à  bulle  
• Pour  un  tableau  de  taille  n
– La  boucle  pour  sera  exécutée  n-1 fois  
– La  bouche  répéter  sera  exécutée  
• 1  fois  si  permut  est  faux  immédiatement  
• n-1 fois  si  permut  est  vrai  jusqu’à  la  fin  (pourquoi?)  
• On  en  déduit  donc  
– Meilleur  cas:  tableau  trié  
– Pire  cas:  tableau  en  ordre  inverse  
• Ce  qui  nous  donne  les  complexités  suivantes  
– Meilleur:  Θ(n)
– Pire:  Θ(n2)
– Moyen:  Θ(n2)
 Tri  par  sélec>on  (selec>on  sort)  
• Pour  trier  un  ensemble,  on  cherche  le  plus  grand  
élément  et  on  le  place  en  dernière  posi>on  
• Ensuite  on  cherche  le  deuxième  plus  grand…  
• On  peut  faire  la  même  chose  avec  le  plus  pe>t,  le  
deuxième  plus  pe>t…  
Tri-­‐Selec>on(A)  {  
     pour  i  de  1  à  longueur(A)-­‐1  {  
           min  ←  i;    
             pour  j  de  i+1  à  longueur(A)  {  
                   si  (A[j]  <  A[min])  
                         min  ←  j;    
             }    
             échanger(A[i],  A[min])  
     }    
 }  
 Complexité  du  tri  par  sélec>on  
• L’analyse  de  l’algorithme  montre  qu’il  n’y  a  pas  
vraiment  de  meilleur  cas  pour  cet  algorithme  
– Si  le  tableau  est  déjà  trié,  on  ne  peut  économiser  que  sur  
l’échange  
– Dans  tous  les  cas,  il  faudra  parcourir  le  tableau  et  à  chaque  
fois  le  sous  tableau  correspondant  
• Complexites    
– Meilleur  cas:  Θ(n2)
– Pire  cas:  Θ(n2)
– Moyenne:  Θ(n2)
• C’est  clairement  un  algorithme  à  éviter  
 Bogus sort
• Quelle  est  la  façon  la  plus  idiote  de  trier?  
• On  prend  un  ensemble  
– On  regarde  si  il  est  trié  
– Si  il  nest  pas  trié,  on  le  mélange  aléatoirement...  
• Équivalent  à  trier  un  paquet  de  carte  en  les  
jetant  en  l’air  
• A  priori  pas  très  efficace...  
 Bogus sort
tant que (nonTrie(table)) {
melanger(table);
}

•Quelle  est  la  complexité  de  ce  tri?  

•On  peut  mélanger  un  tableau  en  Θ(n)  
•Tester  si  un  tableau  est  trié  ou  non  se  fait  en  Θ(n)  
•Combien  de  tours  de  boucle?  
 Bogus sort
• Dans  le  meilleur  des  cas,  le  tableau  est  trié  
– Un  unique  tour  de  boucle  
– Donc  pour  l’ensemble  de  l’algorithme  :  Θ(n)  
• Dans  le  pire  des  cas  
– On  ne  trouve  jamais  la  permuta>on  triée  
– L’algorithme  ne  finit  jamais!  
• Et  le  cas  moyen?  
– Supposons  quon  ne  fait  jamais  2  fois  la  même  permuta>on  
– Il  y  a  donc  n! permuta>ons  possibles  
– On  devra  en  tester  la  moi>é  en  moyenne  (...)  avant  de  tomber  sur  la  
bonne    
• Donc  faire  Θ(n!)  tour  de  boucles,  chacun  nécessitant  Θ(n)  
permuta>ons/vérifica>ons    
 Bogus sort
• Complexité  moyenne  
– Θ(n*n!)  
• Résumons  
– Meilleur  cas  :  Θ(n)  
– Pire  cas  :  non  borné  
– Cas  moyen  :  Θ(n*n!)  
• Clairement  un  très  mauvais  tri  
– D’où  le  nom  
Borne  des  tris  compara>fs  

89  
 Problème  du  tri  
• Peut-­‐on  trouver  une  borne  sur  les  tris  en  général?  
• Ques>on  fondamentale  
– Savoir  si  il  existe  une  solu>on  op>male  
• Exemples  de  limites  connues  
– Vitesse  de  la  lumière    
– Mouvement  perpétuel  
– Compression  
– Zéro  absolu  
• On  va  considérer  un  tri  d’un  point  de  vue  
théorique  
 Problème  du  tri  
• Soit  une  séquence  de  nombres  <a1,…,an>
• Un  tri  est  une  permuta>on  <a1’,…,an’> telle que a1’≤a2’≤…
≤an’
• Lorsqu’un  tri  repose  uniquement  sur  des  comparaisons  entre  
les  éléments  d’entrée,  il  est  dit  comparatif.    
• C’est  à  dire  qu’étant  donné  deux  éléments  an et  am on  
effectue  l’  un  des  tests  suivants    
a n < a m, a n ≤ a m, a n = a m, a n ≥ a m, a n > a m

• Peut-­‐on  trouver  une  borne  pour  la  complexité  dans  le  pire  
des  cas?  
 Borne  inférieure  
• Nous  allons  supposer  que  nous  trions  un  ensemble  
d’éléments  dis>ncts  
                         ⇒  pas  de  comparaison  an = am
• On  suppose  que  toutes  les  comparaisons  sont  de  la  
forme  an ≤ am
• Le  tri  étant  une  permuta>on,  nous  allons  étudier  toutes  
les  permuta>ons  possibles  
• Pour  faciliter  nos  réflexions,  nous  allons  u>liser  un  arbre  
de  décision.  
• Un  arbre  de  décision    permet  de  lister  tous  les  choix  
possibles  et  tous  les  résultats  possibles  
 Arbre  de  décision  
• On  considère  une  course  de  chevaux  (C1,C2,C3)  
• Combien  de  combinaisons  possibles  à  l’arrivée  :  
6  
• Lister  toutes  les  combinaisons  
• 2  rela>ons  possibles  
– Arrive  avant  (AV)  ou  arrive  après  (AP)  
• On  fait  un  arbre  
– Les  noeuds  sont  des  couples  de  chevaux    
– Branche  gauche  pour  AV,  branche  droite  pour  AP  
 Arbre  de  décision  
C1:C2  
AV   AP  

C2:C3   C1:C3  
AP  
AV   AP  

C3,C2,C1  
C1,C2,C3   C1:C3   C2:C3  
AP  
AV  

C1,C3,C2   C3,C1,C2   C2,C3,C1   C2,C1,C3  

 Arbre  de  décision  pour  le  tri  
• Arbre  de  décision  pour  le  tri  de  <a1,a2,a3>  
a1:a2  
≤ >

a2:a3   a1:a3  
≤ > ≤ >

a1,a2,a3   a1:a3   a2,a1,a3   a2:a3  

≤ > ≤ >

a1,a3,a2   a3,a1,a2   a2,a3,a1   a3,a2,a1  

• Chacune  des  feuilles  est  une  permuta>on  possible,  une  seule  est  
l’ensemble  trié.    
• Dans  le  pire  des  cas,  il  faut  donc  parcourir  la  branche  la  plus  longue  pour  
aLeindre  la  «  bonne  »  permuta>on  (mais  ça  reste  le  cas  op>mal)    
 Borne  inférieure  
• Combien  d’opéra>ons  devons  nous  effectuer?  
• Autant  que  la  hauteur  de  l’arbre!  

Théorème : Tout arbre de décision qui trie n éléments a

pour hauteur
Ω(n*log(n)).
     Preuve : Il y a n! permutations possibles, donc l’ arbre
doit avoir au moins n! feuilles. Il peut en avoir plus si on
fait plusieurs fois les même permutations...
Quelle relation y’a-t-il entre le nombre de feuilles et la
hauteur d’un arbre? Un arbre binaire de hauteur h a au
moins 2h feuilles
 Borne  inférieure  
Donc
n! ≤ 2h
Ce qui implique h ≥ ln2(n!)
La formule de Stirling donne

En injectant dans la relation précédente on obtient

 Borne  inférieure  -­‐  Conclusion  
• Récapitulons  
– Un  arbre  de  décisions  pour  un  tri  de  n éléments  a  n!  
feuilles  
– Sa  hauteur  est  minorée  par    n*ln2(n)
– Or  un  tri  compara>f  est  un  arbre  de  décision  
– Donc  sa  hauteur  est  aussi  minorée  par  n*ln2(n)
• Mais  que  représente  la  hauteur  pour  le  tri?  
– Si  on  a  de  la  chance,  on  aura  pas  besoin  d’aller  jusqu’à  
la  hauteur  
– C’est  donc  le  pire  cas  
           
 Borne  inférieure  -­‐  Conclusion  
• Qu’avons-­‐nous  montré?  

           Tout tri comparatif doit effectuer au moins

Ω(n* ln2(n)) comparaisons dans le pire des
cas pour trier une séquence de n éléments

• ALen>on,  on  ne  parle  que  des  tris  comparatifs,  il  existe  
d’autres  tris  qui  ont  une  borne  inférieure  différente.  
 Mais  où  sont  les  tris  efficaces?  
• Pour  l’instant,  nos  recherches  sont  décevantes  
• Nous  avons  analysé  des  tris  qui  sont  loin  d’être  
op>maux  
• En  théorie,  on  devrait  pouvoir  s’approcher  de  
Ω(n* ln2(n)) dans  le  pire  des  cas  
• On  en  est  vraiment  loin  avec  Θ(n2)
• Nous  allons  essayer  une  autre  approche:  
– Diviser pour régner (Divide and Conquer)
 Fusion  d’ensembles  triés  
• Soit  A  et  B  deux  ensembles  triés  
• Comment  obtenir  un  ensemble  C=A  U  B  tel  
que  C  soit  trié?  
3   5   7   8   10   3   5   7   8   10   3   5   7   8   10   5   7   8   10  

1   2   4   6   9   2   4   6   9   4   6   9   4   6   9  

1   1   2   1   2   3  
Algorithme?  
Complexité?  
Dépend  de  la  taille  des  deux  ensembles  
Pas  de  différence  entre  pire,  meilleur  et  moyen  
Tout  est  en  Θ(a+b)=  Θ(n)  
 Tri  par  fusion  (merge  sort)  
• U>lise  une  approche  diviser  pour  régner  avec  
une  fusion  
• Cas  trivial  
– Un  ensemble  contenant  0  ou  1  élément  
• Cas  non  trivial  
– Un  ensemble  de  plus  d’un  élément    
– On  divise  l’ensemble  en  deux  sous  ensembles    
– On  les  trie  
– On  fusionne  les  ensembles  triés  
Tri  par  fusion  (merge  sort)  
Tri-­‐Fusion(A[1..N])  {  
     si  1<N    {  
                     q  ←  (N+1)/2  
                     Tri-­‐Fusion(A[1..q])  
                     Tri-­‐Fusion(A[q+1..N])  
                     Fusionner(A[1..q],A[q+1..N])  
             }    
       }  
 Fusionner    
 fusion(A,p,q,r)  {  
       element[1..r-­‐p]  tmp;    
       a  <-­‐  p  
       b  <-­‐  q+1  
       pour  k  de  1  a  longeur(tmp)  {  
On  prend  un  
                 si  ((b>r)  ou  ((a<=q)  et  (A[a]<A[b])))    
élément  du   Boucle  sur  le  
                               tmp[k]  <-­‐  A[a]  
sous-­‐tableau   tableau  
                               a  <-­‐  a+1  
gauche   fusionné  
                 sinon  
                               tmp[k]  <-­‐  A[b]   (final)  
                               b  <-­‐  b+1  
       }  
       pour  k  de  1  a  longueur(tmp)  {  
               A[k+p]  <-­‐  tmp[k]  
       }  
}  
 
104  
 Complexité  du  tri  par  fusion  
• Soit  T(n)  le  temps  pour  trier  un  tableau  de  taille  n  
• Ce  temps  est  composé  de  
– La  phase  de  fusion  en  Θ(n)  
– 2  phases  de  tri  des  2  demi  tableaux  
• Donc    

• Ce  qui  peut  se  représenter  sous  forme  d’arbre    

 Complexité  du  tri  par  fusion  

• Le  nombre  de  fusions  en  Θ(n)  correspondra  à  la  hauteur  de  

l’arbre    
T(n)   une fusion en Θ(n)

T(n/2)   T(n/2)  
deux fusions en Θ(n/2)

T(n/4)   T(n/4)   T(n/4)   T(n/4)  

• Quelle  est  sa  hauteur?  

– A  chaque  changement  de  niveau,  on  divise  le  tableau  par  2  
– Combien  de  fois  peut-­‐on  le  faire  avant  d’aLeindre  des  tableaux  de  taille  
1?  
 Complexité  du  tri  par  fusion  

• Il  faut  trouver  x tel  que    

 

• Donc    

• Nous  avons  donc  une  complexité  de  Θ(n*log2(n))  

 Tri  par  fusion  -­‐  conclusion  
• Il  a  de  très  bonnes  performances  
– Θ(n*log2(n))  
• Son  principal  problème  vient  de  la  
consomma>on  mémoire  
– La  fusion  nécessite  de  passer  par  un  tableau  
intermédiaire  
– Il  existe  des  algorithmes  de  fusion  sans  tableau  
addi>onnel,  mais  ils  sont  en  Θ(n2)    
• On  dit  que  les  nombres  ne  sont  pas  triés  sur  
place  (in  place)  
 Tri  fusion  -­‐  Implémenta>on  
• La  fusion  nécessite  de  passer  par  un  tableau  
intermédiaire  
• Par  contre  la  phase  de  division  peut  se  faire  
sur  le  même  tableau  
– On  travaille  sur  des  sous  tableaux  
– Passage  des  bornes  des  sous  tableaux  en  
paramètre  
 Éviter  la  fusion  
• Le  point  faible  du  tri  fusion  est  la  fusion  qui  
consomme  trop  de  mémoire  
– Ce  n’est  pas  une  opéra>on  simple  
• Il  faut  essayer  de  la  limiter  
• Quel  est  le  cas  de  fusion  le  plus  simple?  
– Tableaux  de  1  case,  déjà  vu,  mais  arrive  seulement  en  
fin  de  tri  
– Tableaux  dont  les  éléments  de  l’un  sont  inférieurs  
aux  éléments  de  l’autre  
1   2   3   4   5  
1   2   3   4   5   6   7   8   9  
6   7   8   9  
 Tri  rapide  
• On  ne  divise  plus  le  tableau  en  2  par>es  égales  
• On  essaie  de  le  par>>onner  de  sorte  que  
– Tous  les  éléments  du  premier  tableau  soient  inférieurs  à  
ceux  du  deuxième  tableau  
• Fonc>onne  comme  le  tri  fusion    
• Mais  il  n’y  a  plus  besoin  de  fusion  
Tri-­‐Rapide(A,p,r)  {  
     si  p<r  {  
                     q  ←  Par>>onner(A,p,r)  
                     Tri-­‐Rapide(A,p,q)  
                     Tri-­‐Rapide(A,q+1,r)  
           }    
       }  
 Par>>onner  
• On  découpe  le  tableau  A[p..r]  en  2  sous  tableaux  
non  vides  A1[p..q]  et  A2[q+1..r]  tels  que  chaque  
élément  de  A1  soit  inférieur  ou  égal  a  chaque  
élément  de  A2    
• Une  fois  les  2  tableaux  triés  la  fusion  est  triviale,  
il  n’y  a  rien  à  faire!  
• Toute  la  difficulté  vient  de  la  par>>on  
• On  commence  par  choisir  un  élément,  le  pivot  
qui  marquera  la  sépara>on  des  2  tableaux  
– Tout  élément  inférieur  au  pivot  ira  a  gauche  
– Tout  élément  supérieur  ira  a  droite  
Par>>onner(A,p,r)  {  
       x  ←  A[p]  
Par>>onner  -­‐  2  
       i  ←  p-­‐1  
       j  ←  r+1  
       tant  que  vrai  {  
             repeter  {  
                       j  ←  j-­‐1  
                 }  jusqu’à  A[j]  ≤  x  
                 repeter  {  
                         i  ←  i+1  
                 }  jusqu’à  A[i]  ≥  x  
             si  i<j    
                   echanger(A,i,j)  
             sinon  
                   retourner  j  
         }  }  
 Par>>onner  -­‐  3  
• Le  principe  est  le  suivant  
– On  considère  que  le  pivot  est  le  premier  
– On  cherche  un  élément  plus  grand  que  le  pivot  en  
partant  du  début  
– On  cherche  un  élément  plus  pe>t  que  le  pivot  en  
partant  de  la  fin  
– On  les  inverse,  ils  sont  alors  à  la  bonne  place  

• La  complexité  est  en  Θ(n)  

• Tout  se  fait  en  place  
 Performance  du  tri  rapide  
pire  des  cas  
• Soit  T(n)  le  temps  pour  trier  un  tableau  de  
taille  n  
• Le  pire  des  cas  arrive  quand  la  par>>on  donne  
un  tableau  de  longueur  n-­‐1  et  un  autre  de  
longueur  1  
• Dans  ce  cas,  on  a                                                                  car            
T(1)= Θ(1)  
• On  en  déduit  que  la  complexité  dans  le  pire  
des  cas  est  Θ(n2)!  
 Performance  du  tri  rapide  
pire  des  cas  
• Dans  quel  cas  un  tel  par>>onnement  peut-­‐il  
arriver?  

• Tableau  déjà  trié  

• Par  comparaison,  le  tri  par  inser>on  prenait      
O(n)  dans  ce  cas  la…  
 Performance  du  tri  rapide  
meilleur  cas  et  cas  moyen  
• Le  meilleur  des  cas  arrive  quand  la  par>>on  
est  équilibré  
• Dans  ce  cas,  la  complexité  est  Θ(n*log2(n))  
• Le  cas  moyen  se  trouve  par  intui>on  
• Si  on  choisit  un  pivot  «  au  hasard  »,  alors  50%  
des  éléments  lui  seront  inférieurs  
• On  aura  donc  une  par>>on  équilibrée  
• Et  une  complexité  en  Θ(n*  log2(n))  
 Tri  rapide  -­‐  conclusion  
• Performances  variables  
– Moyenne:  Θ(n*log2(n))  
– Meilleur:  Θ(n*log2(n))  
– Pire:  Θ(n2)  
• Mais  effectue  un  tri  en  place  
• Tout  le  problème  vient  du  choix  du  pivot  
• Il  existe  plusieurs  techniques  pour  mieux  choisir  un  
pivot  
– Choix  stochas>que:  le  pivot  est  choisi  parmi  tous  les  
éléments  du  tableau  et  non  plus  seulement  le  premier  
– Choix  médian:  le  pivot  est  choisi  comme  le  médian  de  3  
éléments  du  tableau  
 Résumé  sur  les  tris  
Pire Moyen Meilleur

insertion O(n2) O(n2) O(n)

bulle O(n2) O(n2) O(n)

sélection O(n2) O(n2) O(n2)

fusion Θ(n*log2(n)) Θ(n*log2(n)) Θ(n*log2(n))

rapide Θ(n2) Θ(n*log2(n)) Θ(n*log2(n))