République Algérienne Démocratique et Populaire Ministère de

l'Enseignement Supérieur et de la Recherche Scientifique Université

Djilali BOUNAAMA Khemis Miliana

Faculté des Sciences et de la Technologie

Département de Mathématiques et d’Informatique

Algorithme de Tri

Réalisé par:

- Horri Taqyeddine
- Zattout Abdelhak
- Mokrani Mohamed

2018-2019

1
 Les algorithmes de tri
Définition

Un algorithme de tri est, en informatique ou en mathématiques, un algorithme qui permet

d'organiser une collection d'objets selon une relation d'ordre déterminée. Les objets à trier sont des
éléments d'un ensemble muni d'un ordre total. Il est par exemple fréquent de trier des entiers selon la
relation d'ordre usuelle « est inférieur ou égal à ». Les algorithmes de tri sont utilisés dans de très
nombreuses situations. Ils sont en particulier utiles à de nombreux algorithmes plus complexes dont
certains algorithmes de recherche, comme la recherche par dichotomie. Ils peuvent également servir
pour mettre des données sous forme canonique ou les rendre plus lisibles pour l'utilisateur.

Principe de fonctionnement

On distingue les algorithmes procédant par comparaisons successives entre éléments, dits
« tris par comparaisons », des algorithmes plus spécialisés faisant des hypothèses restrictives sur la
structure des données à trier (par exemple, le tri par comptage, applicable uniquement si les données
sont prises dans un ensemble borné connu à l'avance).
Les algorithmes de tri par comparaison lisent les entrées uniquement au moyen d'une fonction
de comparaison binaire ou ternaire (lorsque le cas d'égalité est traité différemment). Il existe encore
différents principes de fonctionnement au sein de cette classe : certains algorithmes de tri par
comparaison procèdent par insertions successives, d'autres par fusions, d'autres encore par sélection.

Complexité algorithmique

• La complexité temporelle (en moyenne ou dans le pire des cas) mesure le nombre d'opérations
élémentaires effectuées pour trier une collection d'éléments. C'est un critère majeur pour comparer les
algorithmes de tri, puisque c'est une estimation directe du temps d'exécution de l'algorithme. Dans le
cas des algorithmes de tri par comparaison, la complexité en temps est le plus souvent assimilable au
nombre de comparaisons effectuées, la comparaison et l'échange éventuel de deux valeurs s'effectuant
en temps constant.

• La complexité spatiale (en moyenne ou dans le pire des cas) représente, quant à elle, la
quantité de mémoire dont va avoir besoin l'algorithme pour s'exécuter. Celle-ci peut dépendre, comme
le temps d'exécution, de la taille de l'entrée. Il est fréquent que les complexités spatiales en moyenne et
dans le pire des cas soient identiques. C'est souvent implicitement le cas lorsqu’une complexité est
donnée sans indication supplémentaire.

2
I. Tri fusion
Nom anglais : merge sort - Propriétés : tri interne et externe, stable, ne trie pas sur place

1. Version interne
Le tri fusion fait également partie des algorithmes de tri du type "diviser pour régner". Cet
algorithme partage le tableau en deux sous-tableaux de taille n/2 qu'il trie. Il fusionne ensuite les
résultats des deux sous-tableaux. On retrouve alors les 3 phases suivantes :

Diviser : partager le tableau en deux sous-tableaux de taille n/2. Cette phase est instantanée puisqu'il
suffit de calculer l'indice n/2.

Régner : les sous-tableaux sont traités en appelant récursivement le tri fusion.

Combiner : c'est cette phase qui contient toute la logique de l'algorithme. La fusion de deux sous-
tableaux déjà triés se fait en les parcourant en parallèle et en plaçant systématiquement la plus petite
clé dans le tableau résultat. Pour cela la procédure FUSION crée deux tableaux temporaires pour
stocker les deux sous-tableaux à fusionner. On utilise une sentinelle à la fin de chacun de ces 2
tableaux temporaires pour éviter d'ajouter des tests supplémentaires pour détecter la fin de l'un d'entre
eux dans la procédure de fusion.

1.1. Algorithme issu

3
 1.2. Exemple d'application sur la suite d'entiers (15, 10, 4, 34, 1, 19) :

Sur ce schéma, on représente le déroulement du tri par fusion. Les étapes b, c et d correspondent
aux appels récursifs à la procédure TRI-FUSION. Ensuite les étapes e, f et g correspondent à la
terminaison de la récurions par l'appel à la procédure FUSION.

1.3. Etude de la complexité :

Le tri par fusion est insensible aux données qu'il trie. En effet si on regarde de plus
prèsl'algorithme, on se rend compte que la boucle principale effectue systématiquement le même
nombre d'opérations, quel que soit l'ordre relatif des clés des tableaux L et R. On en déduit donc qu'il
n'y a pas de cas favorable ou défavorable. Toutes les entrées de taille n seront traitées avec un temps
identique.
La procédure FUSION appliquée à un tableau de taille n effectue 2n + 2 affectations et n
comparaisons. Elle est donc en (n) . On a vu que la partition du problème dans
TRI-FUSION est en (1) .

4
 On se ramène donc à la 1r currence suivant :

La complexité temporelle du tri fusion est donc (nlgn) dans tous les cas.
Contrairement au tri rapide, le tri fusion commence par partitionner le problème en deux sous-
problèmes de tailles égales avant d'appliquer une procédure en (n) . On est donc toujoursdans le cas
du partitionnement favorable du tri rapide. Ceci nous assure que le nombre d'étapes de partitionnement
seraminimum.
Toutefois, cet algorithme ne trie pas sur place. Il nécessite un espace
mémoiresupplémentaireen(n).
Pours'enconvaincre,ilsuffitd'envisagerladernièrefusionquidoitêtrefaite.Ellecorrespond à la partition
du tableau initial. On a donc 2 sous-tableaux temporaires de taillen/2.Comme pour le tri rapide, il est
possible d'optimiser le tri fusion en lui substituant n tri par insertion pour les petits tableaux.

2. Version externe
Pour de très nombreuses applications, la quantité de données à trier est bien supérieure à la
capacité mémoire de l'ordinateur. Il faut dans ce cas un algorithme particulier qui va s'appuyer sur les
mémoires secondaires (disques durs ou bandes magnétiques) pour trier. La première contrainte est que
les temps d'accès de ces mémoires secondaires est tellement grand, qu'il n'est pas comparable avec les
temps d'accès et de traitement en mémoire centrale. La complexité de ces algorithmes est donc étudiée
en fonction du nombre d'entrées/sorties plutôt que du nombre d'échanges ou de comparaisons. La
seconde contrainte est lié au type et au nombre de mémoires secondaires. En effet, contrairement à un
disque dur, une bande magnétique ne peut être accéder que séquentiellement.
Nous nous intéresserons ici à une version du tri par fusion utilisée avec des disques durs au sein
des bases de données. Pour une version sur bandes magnétiques.
On suppose qu'on a n clés à trier et qu'on dispose d'un espace en mémoire centrale permettant de
stocker uniquement M clés.
La première étape est de créer des partitions de l'ensemble des clés qui puissent tenir en mémoire
centrale. On lit donc les clés par blocs de taille M. Chaque bloc est trié en mémoire centrale à l'aide
d'un des algorithmes vu précédemment. Il est ensuite réécrit sur le disque pour libérer l'espace
mémoire pour trier les blocs suivants. A la fin de cette première étape,on a donc n/M partitions triées
de taille M. Le coût de cette phase est de n lectures et n écritures.
La seconde étape, comme pour le tri fusion classique, consiste à interclasser les partitions triées.
Pour cela, on lit en parallèle les clés de M-1 partitions et on stocke la clé minimum dans le dernier
espace mémoire afin de l'écrire sur le disque dans la nouvellepartitionrésultant de cette fusion. A la fin
de cette étape, on a donc
n/M(M −1) partitions de taille M(M-1) chacune (sauf éventuellement la dernière). On recommence
cette seconde étape jusqu'àobtenirunepartitionuniquequiseralerésultatfinal.Lecoûtdecetteétapeest
M
également de n lectures et n écriures. Cette étape est répétée environ le coût total en
entrées/sorties est en (nlog n).
Les pistes d'optimisation pour ce tri sont principalement liées à l'utilisation en parallèle de
plusieurs disques / bandes. On n'économise pas forcément en nombre d'entrées / sorties mais en temps.

5
II. Tri par sélection
1. Définition
Le tri par sélection (ou tri par extraction) est un algorithme de tri par comparaison.
Cet algorithme est simple, mais considéré comme inefficace, car il s'exécute en temps quadratique
en le nombre d'éléments à trier, et non en temps pseudo linéaire.

2. Principe
Sur un tableau de n éléments (numérotés de 0 à n-1, attention un tableau de 5 valeurs (5cases) sera
numéroté de 0 à 4 et non de 1 à 5), le principe du tri par sélection est le suivant :
Rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 0 ;
Rechercher le second plus petit élément du tableau, et l'échanger avec l'élément d'indice 1 ;
Continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.

3. Principe de fonctionnement
On distingue les algorithmes procédant par comparaisons successives entre éléments, dits « tris par
comparaisons », des algorithmes plus spécialisés faisant des hypothèses restrictives sur la structure des
données à trier (par exemple, le tri par comptage, applicable uniquement si les données sont prises
dans un ensemble borné connu à l'avance).
Les algorithmes de tri par comparaison lisent les entrées uniquement au moyen d'une fonction de
comparaison binaire ou ternaire (lorsque le cas d'égalité est traité différemment). Il existe encore
différents principes de fonctionnement au sein de cette classe : certains algorithmes de tri par
comparaison procèdent par insertions successives, d'autres par fusions, d'autres encore par sélection.
En l'absence de précisions, on entend habituellement par « algorithme de tri » un algorithme de tri
procédant par comparaisons.

4. Algorithme
Une version maladroite de l'algorithme mais exacte a été fournie
par un groupe d'étudiants elle est dénommée /version 1/. Elle échange physiquement
et systématiquement l'élément frontière Tab[ i ] avec un élément Tab[ j ] dont la valeur est plus petite
(la suite (a1, a2, ... , ai) est triée) :

4.1. Algorithme Tri_Selection /Version 1/

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 Tab[ i ]
pour j de i+1 jusquà n faire// liste non-triée : (ai+1, a2, ... , an)
si Tab[ j ] < Tab[ m ] alors // aj est le nouveau minimum partiel
m¬j;
temp ¬ Tab[ m ] ;
Tab[ m ] ¬ Tab[ i ] ;
Tab[ i ] ¬ temp //on échange les positions de ai et de aj
m¬i;
Fsi
fpour ; fpour
Fin Tri_Selection

6
 4.2. Algorithme Tri_Selection /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

5. Exemple d'application sur la suite d'entiers (5, 4, 2, 3, 7, 1) :

comme 5>4 on mémorise dans m comme 4>2 on mémorise dans m comme 2<3 on ne mémorise pas

comme 2<7 on ne mémorise pas comme 2>1 on mémorise dans m

on échange T[1] et T[6]

L'algorithme ayant terminé l'échange de T[1] et de T[6], il passe à l'itération externe suivante ( i = 2) :

etc…..

6. Complexité
Pour les deux versions 1 et 2 :
Le nombre de comparaisons "si Tab[ j ] < Tab[ m ] alors" est une valeur qui ne dépend que de la
longueur n de la liste (n est le nombre d'éléments du tableau), ce nombre est égal au nombre de fois
que les itérations s'exécutent, le comptage montre que la boucle "pour i de 1 jusquà n-1 faire"
s'exécute n-1 fois (donc une somme de n-1 termes) et qu'à chaque fois la boucle "pour j de i+1 jusquà
n faire" exécute (n-(i+1)+1 fois la comparaison "si Tab[ j ] < Tab[ m ] alors".

7
 La complexité en nombre de comparaison est égale à la somme des n-1 termes suivants (i = 1, ...i
= n-1)C = (n-2) +1 + (n-3) +1 +.....+1+0 = (n-1) + (n-2) +...+1 = n.(n-1)/2 (c'est la somme des n-1
premiers entiers).
La complexité en nombre de comparaison est de de l'ordre de n², que l'on écrit O(n²). donc le
calcul exact est donné par la formule suivante :

Calculons par dénombrement du nombre d'échanges dans le pire des cas(Complexité au pire =
majorant du nombre d'échanges).
Le cas le plus mauvais est celui où le tableau est déjà classé mais dans l'ordre inverse.

6.1. Pour la version 1

Au pire chaque cellule doit être échangée, dans cette éventualité il y a donc autant d'échanges
que de tests.La complexité au pire en nombre d'échanges de la version 1 est de l'ordre de n², que l'on
écrit O(n²).

6.2. Pour la version 2

L'échange a lieu systématiquement dans la boucle principale "pour i de 1 jusquà n-1 faire" qui
s'exécute n-1 fois :
La complexité en nombre d'échanges de cellules de la version 2 est de l'ordre de n, que l'on écrit O(n).
Un échange valant 3 transferts (affectation) la complexité en transfert est O(3n) = O(n).

7. Présentation des résultats

Le tri par sélection est l’un des tris les plus instinctifs. Le principe est que pour classer n
valeurs, il faut rechercher la plus grande valeur et la placer en fin de liste, puis la plus grande valeur
dans les valeurs restante et la placer en avant dernière position et ainsi de suite...
Considérons un tableau à n éléments. Pour effectuer le tri par sélection, il faut rechercher dans ce
tableau la position du plus grand élément. Le plus grand élément est alors échangé avec le dernier
élément du tableau. Ensuite, on réitère l’algorithme sur le tableau constitué par les (n-p) premiers
éléments où p est le nombre de fois où l’algorithme a été itéré. L’algorithme se termine quand p= (n-
1), c’est à dire quand il n’y a plus qu’une valeur à sélectionner ; celle ci est alors la plus petite valeur
du tableau.

Exemple

Grandes étapes de l’évolution du tableau au fil de l’algorithme. En bleu, les valeurs déja traitées.

5 3 1 2 6 4
5 3 1 2 4 6
4 3 1 2 5 6
2 3 1 4 5 6
2 1 3 4 5 6
1 2 3 4 5 6

8
III. Les outils d’implémentation
Nous avons utilisons java comme langage de programmation pour programmer les algorithmes de tri
(tri par fusion et tri par sélection).

Java:

Java est un langage de programmation orienté objet créé par James Gosling et Patrick Naughton,
employés de Sun Microsystems, avec le soutien de Bill Joy (cofondateur de Sun
Microsystems en 1982), présenté officiellement le 23 mai 1995 au SunWorld.
La société Sun a été ensuite rachetée en 2009 par la société Oracle qui détient et maintient
désormais Java.
La particularité et l'objectif central de Java est que les logiciels écrits dans ce langage doivent être très
facilement portables sur plusieurs systèmes d’exploitation telsque Unix, Windows, Mac
OS ou GNU/Linux, avec peu ou pas de modifications, mais qui ont l'inconvénient d'être plus lourd à
l'exécution (en mémoire et en temps processeur) à cause de sa machine virtuelle. Pour cela,
divers plateformes et frameworks associés visent à guider, sinon garantir, cette portabilité
des applications développées en Java.

NetBeans:

NetBeans est un environnement de développement intégré (EDI), placé en open source par Sun en
juin 2000 sous licence CDDL (Common Development and Distribution License) et GPLv2. En plus de
Java, NetBeans permet la prise en charge native de divers langages tels le C, le C++, le JavaScript, le
XML, le Groovy, le PHP et le HTML, ou d'autres (dont Python et Ruby) par l'ajout de greffons. Il
offre toutes les facilités d'un IDE moderne (éditeur avec coloration syntaxique, projets multi-langage,
refactoring, éditeur graphique d'interfaces et de pages Web).

IV. Architecture d’implémentation

Les méthodes et les classes qui nous utiliser est :
a) Pour le premier algorithme (tri par sélection) :
On a une seule classe qui s’appelle tri_sélection.
On a une seule statice méthode qui s’appelle triSelection.
On a une seule méthode pré définir qui s’appelle length pour calculer langeure de le tableau.

b) Pour le premier algorithme (tri par fusionner) :

On a une seule classe qui s’appelle tri_fusionner.
On a une statice méthode qui s’appelle triFusion(int tableau[]).
On a une statice méthode qui s’appelle triFusion(int tableau[],int deb,int fin).
On a une statice méthode qui s’appelle fusion(int tableau[],int deb1,int fin1,int fin2).
On a une seule méthode pré définir qui s’appelle length pour calculer langeure de le tableau.

9
10