Méthodes de tri: Cours 2

IV- Tri par fusion :

Principe :
Le tri fusion est un algorithme de tri basé sur la
technique algorithmique diviser pour régner.
L'opération principale de l'algorithme est la
fusion, qui consiste à réunir deux listes triées en
une seule.
Principe :
Le principe de cet algorithme tend à adopter une
formulation récursive :

On découpe les données à trier en deux parties

plus ou moins égales
On trie les 2 sous-parties ainsi déterminées
On fusionne les deux sous-parties pour retrouver
les données de départ
Implémentation :
L'implémentation de cet algorithme repose
essentiellement en 2 fonctions :

Fusion :Permet de fusionner deux listes

triées de telle sorte que la liste résultante la
soit aussi.
triFusion : Une fonction récursive qui
assure le découpage de la liste et l'appel de la
fonction de fusion.
 Fonction fusion :
def fusion(L1, L2):
res = []
ind1, ind2 = 0, 0
while ind1 < len(L1) and ind2 < len(L2):
if L1[ind1] <= L2[ind2]:
res.append(L1[ind1])
ind1 += 1
else:
res.append(L2[ind2])
ind2 += 1
Fonction fusion :
if ind1!=len(L1):
res+=L1[ind1:]
if ind2!=len(L2):
res+=L2[ind2:]
return res
Fonction triFusion :
def triFusion(ls):
if len(ls) <= 1:
return ls
moitie = len(ls) // 2
return fusion( triFusion(ls[:moitie]), triFusion(ls[moitie:]))
V- Tri rapide :
Principe :
L’algorithme de tri rapide, "quick sort", est un
algorithme fondé sur la méthode de conception
diviser pour régner; Son principe consiste à séparer
l’ensemble des éléments en deux parties.
Pour effectuer la séparation, une valeur pivot est
choisie au hasard. Les valeurs sont réparties en
deux ensembles suivant qu’elles sont plus grandes
ou plus petites que le pivot. Ensuite, les deux
ensembles sont triés séparément, suivant la même
méthode.
IV- Tri rapide :
Exemple :
Soit la liste :
L = [ 4, 23, 3, 42, 2, 14, 45, 18, 38, 16 ]
Prenons comme pivot la dernière valeur
pivot = 16
Nous obtenons donc :
L1 = [4, 14, 3, 2]
L2 = [23, 45, 18, 38, 42]
A cette étape voici l'arrangement de L :
L = L1 + pivot + L2 = [4, 14, 3, 2, 16, 23, 45, 18, 38, 42]
 En appliquant la même démarche au deux sous-listes : L1
(pivot=2) et L2 (pivot=42)
[4, 14, 3, 2, 16, 23, 45, 18, 38, 42]
nous obtenons :
L11=[ ] liste vide L21=[23, 38, 18]
L12=[3, 4, 14] L22=[45]
L1=L11 + pivot + L12 = (2,3, 4, 14) L2=L21 + pivot + L22 = (23, 38, 18, 42, 45)
Etapes tri rapide sur [a..b] :

1. Partition [a..b] renvoie pivot & [a..b] =

[x .. pivot']+[pivot]+[pivot'' .. y]
2. Tri Rapide sur [pivot'' .. y]
3. Tri Rapide sur [x .. pivot']
Fonction partitionner :
def partitionner(T,premier,dernier) :
p=T[dernier]
j=premier
for i in range(premier,dernier) :
if T[i]<=p :
T[i],T[j]=T[j],T[i]
j=j+1
T[dernier],T[j]=T[j],T[dernier]
return j
Fonction triRapide :
def triRapide(T,premier,dernier) :
if premier < dernier :
pivot=partitionner(T,premier,dernier)
triRapide(T,premier,pivot-1)
triRapide(T,pivot+1,dernier)