Tri par tas

Le tri par tas est un algorithme de tri par comparaisons.

Cet algorithme est de complexité asymptotiquement optimale, c'est-à-dire qu'il est de complexité proportionnelle à $n\ \log \ n$ où $n$ est la longueur du tableau à trier ; il n'y a pas de pire des cas en $O(n^{2})$ comme avec le tri rapide. On démontre qu'aucun algorithme de tri par comparaison ne peut avoir de complexité asymptotiquement meilleure.

Par ailleurs, cet algorithme est en place, c'est-à-dire qu'il ne nécessite pas l'allocation d'une zone mémoire supplémentaire en plus de celle contenant les données d'entrée.

L'inconvénient majeur de ce tri est sa lenteur en moyenne comparée au tri rapide. En effet, le tri par tas est environ deux fois plus lent dans la plupart des cas.

Principe

L'idée qui sous-tend cet algorithme consiste à voir le tableau comme un arbre binaire. Le premier élément est la racine, le deuxième et le troisième sont les deux descendants du premier élément, etc. Ainsi le $n$ ^e élément a pour enfants les éléments $2n$ et $2n+1$ . Si le tableau n'est pas de taille $(2^{n}-1)$ , les branches ne se finissent pas toutes à la même profondeur.

Dans l'algorithme, on cherche à obtenir un tas, c'est-à-dire un arbre binaire vérifiant les propriétés suivantes (les deux premières propriétés découlent de la manière dont on considère les éléments du tableau) :

la différence maximale de profondeur entre deux feuilles est de 1 (i.e. toutes les feuilles se trouvent sur la dernière ou sur l'avant-dernière ligne) ;
les feuilles de profondeur maximale sont « tassées » sur la gauche.
chaque nœud est de valeur supérieure (resp. inférieure) à celles de ses deux fils, pour un tri ascendant (resp. descendant).

Comme expliqué plus haut, un tas ou un arbre binaire presque complet peut être stocké dans un tableau, en posant que les deux descendants de l'élément d'indice $n$ sont les éléments d'indices $2n$ et $2n+1$ (pour un tableau indicé à partir de 1). En d'autres termes, les nœuds de l'arbre sont placés dans le tableau ligne par ligne, chaque ligne étant décrite de gauche à droite.

Une fois le tas de départ obtenu, l'opération de base de ce tri est le tamisage, ou percolation, d'un élément, supposé le seul « mal placé » dans un arbre qui est presque un tas. Plus précisément, considérons un arbre $A=A[1]$ dont les deux sous-arbres ( $A[2]$ et $A[3]$ ) sont des tas, tandis que la racine est éventuellement plus petite que ses fils. L'opération de tamisage consiste à échanger la racine avec le plus grand de ses fils, et ainsi de suite récursivement jusqu'à ce qu'elle soit à sa place.

Pour construire un tas à partir d'un arbre quelconque, on tamise les racines de chaque sous-tas, de bas en haut (par taille croissante) et de droite à gauche.

Pour trier un tableau à partir de ces opérations, on commence par le transformer en tas. On échange la racine avec le dernier élément du tableau, et on restreint le tas en ne touchant plus au dernier élément, c'est-à-dire à l'ancienne racine. On tamise la racine dans le nouveau tas, et on répète l'opération sur le tas restreint jusqu'à l'avoir vidé et remplacé par un tableau trié.

Pseudo-code

On fait l'hypothèse que l'arbre est un tableau indexé entre 1 et longueur. arbre[i] désigne le i-ème élément de ce tableau.

fonction tamiser(arbre,nœud,n): {descend arbre[nœud] à sa place, sans dépasser l'indice n}
  k:=nœud
  j:=2k
  tant que j<=n
    si j<n et arbre[j]<arbre[j+1]
      j:=j+1
    fin si
    si arbre[k]<arbre[j]
      échanger arbre[k] et arbre[j]
      k:=j
      j:=2k
    sinon
      terminer
    fin si
  fin tant que
fin fonction

fonction tri_par_tas(arbre,longueur):
  pour i:=longueur/2 a 1
    tamiser(arbre,i,longueur)
  fin pour
  pour i:=longueur a 2
    échanger arbre[i] et arbre[1]
    tamiser(arbre,1,i-1)
  fin pour
fin fonction

À la fin de la fonction tri_par_tas le tableau arbre est trié suivant l'ordre croissant. Il suffit d'inverser les opérateurs de comparaison pour obtenir un tri dans l'ordre décroissant.

Analyse

Cet algorithme permet de trier sur place les éléments d'un tableau en un temps de l'ordre de $n\ \log _{2}\ n$ dans le pire des cas, où $n$ est le nombre d'éléments à trier. L'étape la plus coûteuse de l'algorithme est la seconde boucle, c'est-à-dire l'extraction des éléments du tas. La première étape, consistant à construire le tas, est effectuée en temps linéaire en n.

Les principaux atouts de cette méthode sont la faible consommation mémoire et l'efficacité, optimale étant donné qu'on ne fait aucune hypothèse sur la nature des données à trier.

Amélioration possible

Quand le tableau est déjà trié, le tri par tas le mélange d'abord avant de le retrier. L'algorithme Smoothsort a pour but de pallier cet inconvénient.

À la fin du tri par tas, pour les 15 derniers éléments environ, l'algorithme effectue plusieurs fois de suite les mêmes inversions, ce qui est inutile. On peut à la place arrêter l'algorithme quand il n'y a plus beaucoup d'éléments et passer à un autre. Les données qui restent sont à peu près triées à l'envers. On peut donc, par exemple, retourner les données restantes (avec une inversion du 1^er et du dernier, du 2^e et de l'avant-dernier etc.) puis effectuer un tri par insertion.

implémentation

Implémentation en c#

  
   class Tri
       {
           private static void Echange(ref int a, ref int b)
           {
               int swap = a;
               a = b;
               b = swap;
           }


           private static void Tamiser(int[] arbre, int noeud, int n)
           {
               int k = noeud;
               int j = 2 * k;

               while (j <= n)
               {
                   if ((j < n) && (arbre[j] < arbre[j + 1]))
                       j++;

                   if (arbre[k] < arbre[j])
                   {
                       Tri.Echange(ref arbre[k], ref arbre[j]);
                       k = j;
                       j = 2 * k;
                   }
                   else
                       break;
               }
           }

           public static void TriParTas(int[] arbre)
           {
               for (int i = arbre.Length - 1; i >= 0; i--)
                   Tri.Tamiser(arbre, i, arbre.Length - 1);

               for (int i = arbre.Length - 1; i >= 1; i--)
               {
                   Tri.Echange(ref arbre[i], ref arbre[0]);
                   Tri.Tamiser(arbre, 0, i - 1);
               }
           }
       }

Implémentation en Pascal

  
        uses wincrt;
        const Max = 100;
        type tab= array[1..Max] of integer;

        procedure Fill(var T : tab; n : integer);
        var i : integer;
        begin
        randomize;
                  for i:=1 to n do
                  t[i] := random(n);
        end;

        procedure Show(var T : tab; n : integer);
        var i : integer;
        begin
             for i:=1 to n do
             write(t[i],' ');
        writeln;
        end;

        procedure Permut(var x : integer; var y : integer);
        var inter : integer;
        begin
        inter := x;
        x := y;
        y := inter;
        end; 

        procedure TriTasCroissant(var t : tab; n : integer);
        var i , j , HeapSize : integer;
        begin
             for i:=1 to n do
             begin
             j := i;
             {la séquence t[1], ... t[i-1] est considéré comme un tas
             remonter t[i] dans sa bonne place ==> t[1],..t[i] }
                      while((j div 2> 0)and(t[j div 2] < t[j]))do
                      begin
                      Permut(t[j], t[j div 2]);
                      j := j div 2;
                      end;
             end;
             for i:=1 to n do
             begin
             HeapSize := n-i+1;
             Permut(t[1],t[HeapSize]);
             j := 1;
                    while( (2*j < HeapSize)and ( (t[2*j]  > t[j])or((2*j+1 < HeapSize)and(t[2*j+1] > t[j]))))do
                    begin
                         if((2*j+1 < HeapSize)and(t[2*j] < t[2*j+1]))then
                         begin
                         Permut(t[j],t[2*j+1]);
                         j := 2*j+1;
                         end
                         else
                         begin
                         Permut(t[j], t[2*j]);
                         j := 2*j;
                         end;
                    end;
             end;
    end;

    var t : tab;

    begin
    Fill(T,20);
    Show(T,20);
    TriTasCroissant(T,20);
    Show(T,20);
    end.

Lien externe

Code de Tri par Tas

Modèle:Algorithme de tri