Méthodes 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 un ordre déterminé. Les objets à trier font donc partie d'un ensemble muni d'une relation d'ordre. Les ordres les plus utilisés sont l’ordre numérique et l'ordre lexicographique.

​

Source : Wikipédia

I- Tri à bulles :

Principe :

Comparaison 2 à 2 des éléments adjacents

et échange s'ils ne sont pas ordonnés. Le programme s'arrête lorsqu'on parcours la liste sans faire d'échange

Comme les bulles, les plus grands éléments remontent en fin de liste

​

Exercice :

Ecrire la fonction triBulles(ls) qui permet de trier les éléments de la liste ls en utilisant la méthode de tri à bulles

I- Tri à bulles :

def triBulles (ls):

echange= True

while echange==True :

echange=False

for i in range(0,len(ls)-1) :

if(ls[i]>ls[i+1]):

ls[i],ls[i+1] = ls[i+1], ls[i]

echange=True

�

II- Tri par sélection :

Principe :

• Recherche du plus petit élt du tableau et échange avec le premier élt
• Recherche du plus petit élt du tableau entre les positions 2 et n-1 et échange avec le second élt
• ...
• Recherche du plus petit élt entre les positions n-2 et n-1 et échange avec l'élt en position n-2

​

Exercice :

Ecrire la fonction triSelection(ls) qui permet de trier les éléments de la liste ls en utilisant la méthode de tri par sélection.

​

Tri par sélection :

​

def triSelection (L):

for i in range(0,len(L)-1) :

pmin= i

for j in range(i+1,len(L)) :

if L[j] < L [pmin] :

pmin= j

if pmin!= i :

L[i],L [pmin] = L[pmin], L[i]

return L��

III- Tri par insertion :

Principe :

• La liste étant trié jusqu'à l'élt i-1,
• insérer l'élément i à sa place parmi les i premiers éléments

​

Exercice :

Ecrire la fonction tri_Insertion(ls) qui permet de trier les éléments de la liste ls en utilisant la méthode de tri par insertion.

​

III- Tri par insertion :

def tri_Insertion(T) :

n=len(T)

for i in range(1,n):

x=T[i]

j=i

while j>0 and T[j-1]>x :

T[j]=T[j-1]

j=j-1

T[j]=x

return T

IV- 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 �L12=[3, 4, 14] �L1=L11 + pivot + L12 = (2,3, 4, 14)

L21=[23, 38, 18] �L22=[45] �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)

�

V- 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:]))