Tri par tas ( heap sort)

Toujours environ deux fois plus lent que le tri rapide, c'est-à-dire aux alentours de O(nlogn), il est donc intéressant de l'utiliser si l'on soupçonne que les données à trier seront souvent des cas quadratiques pour le tri rapide. Te tri par tas est un algorithme de tri par comparaisons. Cet algorithme est de complexité asymptotiquement optimale.

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

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^ième élément a pour enfants les éléments 2n et 2n + 1. Si le tableau n'est pas de taille 2ⁿ, les branches ne se finissent pas tout à fait à 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é.

On fait l'hypothèse que 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

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