ALGORITHMES DE

TRI ET COMPLEXITE
Ing corneille M. HOUNSOUNOU
Corneille.hounsounou@fast.uac.bj
95 44 38 56
Objectif

Les algorithmes de tri permettent la compréhension de notions fondamentales en

informatique.
Dans la vraie vie, les algorithmes de tris, en particulier ceux d’aujourd’hui, sont déjà
implémentés dans les langages de haut niveau.

Mais un beau jour tu vas débarquer en entretien de façon nonchalante en te disant que
tu sais tout. Et là, on va te demander d’implémenter un tri fusion. Tu vas te sentir
seul à regarder l’écran et ne plus savoir quoi faire.
Tri à bulles (bubble sort)
Le tri à bulles est de loin le plus simple de tous les algos de tri. D’ailleurs c’est pour
ça qu’il est super lent et quasiment jamais utilisé. Mais c’est un classico. Si tu le connais
pas, c’est pas normal.
La logique est simple:
• On passe sur chaque élément du tableau et on le compare à son voisin de droite.
• Si le voisin de droite est plus petit alors les deux éléments permutent, car
l’élément le plus petit devrait être à gauche.
• On fait autant de passe que nécessaire jusqu’à que tout le tableau soit trié.
 La condition d’arrêt étant le fait qu’aucune permutation n’ait été nécessaire dans une
passe.
Démontration
ALGO
Algorithme Tri_a_Bulles
 local:   i , j , n, temp Π Entiers naturels
 Entrée : Tab Π Tableau d'Entiers naturels de 1 à n éléments
 Sortie : Tab Π Tableau d'Entiers naturels de 1 à n éléments
début
 pour i de n jusquà 1 faire // recommence une sous-suite (a1, a2, ... , ai)
  pour j de 2 jusquà i faire // échange des couples non classés de la sous-suite
   si Tab[ j-1 ] > Tab[ j ] alors // aj-1et aj non ordonnés
     temp ¬ Tab[ j-1 ] ;
     Tab[ j-1 ] ¬ Tab[ j ] ;
     Tab[ j ]  ¬ temp //on échange les positions de aj-1et aj
   Fsi
  fpour
 fpour
Fin Tri_a_Bulles
Tri par insertion (Insertion sort)
Le tri par insertion fait également partie des algorithmes de tri les plus simples à comprendre et à

utiliser. Et comme souvent, sa simplicité vient avec le prix d’une mauvaise performance sur de

larges séquences de données. On est toujours sur un algorithme assez lent avec beaucoup de

données, mais efficace sur peu.

Tri par insertion (Insertion sort)

La logique de cet algorithme est, je trouve, très intuitive.

• On passe sur chacun des éléments à trier et on l’insère directement à la place

où il devrait être.
• Pour faire cette insertion, on va simplement comparer l’élément courant avec
chaque élément déjà trié sur la gauche.
Démonstration
ALGO
Algorithme Tri_Insertion
 local:   i , j , n, v Π Entiers naturels
 Entrée : Tab Π Tableau d'Entiers naturels de 0 à n éléments
 Sortie : Tab Π Tableau d'Entiers naturels de 0 à n éléments
{ dans la cellule de rang 0 se trouve une sentinelle chargée d'éviter de tester dans la boucle tantque ..
faire si l'indice j n'est pas inférieur à 1, elle aura une valeur inférieure à toute valeur possible de la liste
}
début
 pour i de2 jusquà n faire// la partie non encore triée (ai, ai+1, ... , an)
     v ¬ Tab[ i ] ;  // l'élément frontière : ai
     j ¬ i ;        // le rang de l'élément frontière
      Tantque Tab[ j-1 ] > v faire//on travaille sur la partie déjà triée (a1, a2, ... , ai)
              Tab[ j ]  ¬ Tab[ j-1 ]; // on décale l'élément
                j ¬ j-1;                 // on passe au rang précédent 
      FinTant ;
      Tab[ j ]  ¬ v //on recopie ai dans la place libérée
  fpour
Fin Tri_Insertion
Tri fusion (merge sort)

Le tri fusion est un algorithme de la grande famille des algorithmes “

diviser pour régner“. Il est légèrement plus complexe que les algorithmes

précédents, mais son efficacité est redoutable ! En particulier sur de grandes

séquences de données.
Tri fusion (merge sort)

Cet algorithme de tri a une logique un peu plus complexe.

• On va commencer par diviser le tableau en deux éléments égaux.

• On va recommencer la même chose jusqu’à atteindre un seul élément par
séparation.
• Ensuite, on va refusionner les éléments séparés de façon récursive en les triant à
chaque niveau.

C’est en comparant et permutant les éléments niveau par niveau qu’on construit
un nouveau tableau trié !
Démonstration
Démonstration
Algorithme Tri_fusion  /Version 2/
 local:   m, i , j , n, temp Π Entiers naturels
 Entrée : Tab Π Tableau d'Entiers naturels de 1 à n éléments
 Sortie : Tab Π Tableau d'Entiers naturels de 1 à n éléments début
 pour i de 1 jusquà n-1faire // recommence une sous-suite 
  m ¬ i ; // i est l'indice de l'élément frontière ai = Tab[ i ]
  pour j de i+1 jusquà n faire// (ai+1, a2, ... , an) 
   si Tab[ j ] <  Tab[ m ] alors // aj est le nouveau minimum partiel
     m ¬ j ; // indice mémorisé
   Fsi
  fpour;
  temp ¬ Tab[ m ] ;
  Tab[ m ] ¬ Tab[ i ] ;
  Tab[ i ]  ¬ temp //on échange les positions de ai et de aj
 fpour
Fin Tri_Selection
Tri rapide (quick sort)

Le tri rapide (quicksort), ou tri pivot, fait aussi partie de la famille des algorithmes

“diviser pour régner”. Lui aussi utilise donc de la récursivité et sa logique est un peu

plus complexe. Comme le tri fusion, il est cependant grandement utilisé dans les

langages modernes.
Tri rapide (quick sort)

Son fonctionnement est centré autour du concept du pivot.

On va choisir un élément dans le tableau et on va décréter que cet

élément est le pivot pour une itération sur le tableau. Y’a différente façon de choisir un pivot,

on ne va pas rentrer là-dedans, aujourd’hui le pivot sera toujours le dernier élément du tableau.
Tri rapide (quick sort)

Une fois qu’on a ce pivot, on va créer un sous tableau.

• Toutes les valeurs plus basses que ce pivot vont à gauche de ce sous-tableau.
• Le pivot au milieu de ce sous-tableau.
• Toutes les valeurs plus grandes que ce pivot vont à droite.
Démonstration
ALGO
fonction Partition( G , D : entier )  résultat : entier 
Local : i , j ,  piv , temp : entier 
début
     piv  ¬  Tab[D];
     i  ¬ G-1;
     j  ¬ D;
     repeter Algorithme TriRapide( G  , D : entier );
        repeter  i ¬  i+1 jusquà Tab[i] >= piv; Local :  i : entier 
        repeter  j ¬  j-1 jusquà Tab[j] <= piv; début
        temp ¬  Tab[i];  si D > G alors
        Tab[i] ¬  Tab[j];     i ¬ Partition( G , D );
        Tab[j] ¬  temp    TriRapide( G , i-1 );
     jusquà j <= i;    TriRapide( i+1 , D );
     Tab[j] ¬  Tab[i];
 Fsi
     Tab[i] ¬  Tab[d];
     Tab[d] ¬  temp;
FinTRiRapide
     résultat ¬  i
FinPartition
Merci pour l’attention

A VOS CLAVIERS