Tri par tas

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 ${\displaystyle n}$^e élément a pour enfants les éléments ${\displaystyle 2n}$ et ${\displaystyle 2n+1}$ si l'indexation se fait à partir de 1 (${\displaystyle 2n+1}$ et ${\displaystyle 2n+2}$ si l'indexation se fait à partir de 0). Si le tableau n'est pas de taille ${\displaystyle (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).

Il en découle que la racine du tas (le premier élément) contient la valeur maximale (resp. minimale) de l'arbre. Le tri est fondé sur cette propriété.

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 ${\displaystyle n}$ sont les éléments d'indices ${\displaystyle 2n}$ et ${\displaystyle 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. Pour la suite, nous considérons que l'on trie par ordre croissant.

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 ${\displaystyle A=A[1]}$ dont les deux sous-arbres (${\displaystyle A[2]}$ et ${\displaystyle 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 et de droite à gauche. On commence donc par les sous-arbres « élémentaires » — contenant deux ou trois nœuds, donc situés en bas de l'arbre. La racine de ce tas est donc la valeur maximale du tableau. Puis 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 a donc ainsi placé la valeur la plus haute en fin de tableau (donc à sa place), et l'on n'y touche plus. Puis on tamise la racine pour créer de nouveau un tas, et on répète l'opération sur le tas restreint jusqu'à l'avoir vidé et remplacé par un tableau trié.

Application de l'algorithme.

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
         j := n+1
      fin si
   fin tant que
fin fonction

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

À la fin de la fonction triParTas 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.

Cet algorithme permet de trier sur place les éléments d'un tableau en un temps de l'ordre de ${\displaystyle n\log n}$, où ${\displaystyle n}$ est le nombre d'éléments à trier. La complexité entre le meilleur des cas et le pire des cas ne varie que d'un facteur constant[1]. 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.

• 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.

• (en) Illustration dynamique du tri par tas

• Portail de l'informatique théorique