Tris

Data Sorting

1. Problème

Entrée:
L une liste d’éléments dans un ensemble ordonné.

Sortie
Une liste triée contenant les mêmes éléments que L

2. Tri par comparaison

A. Tri par sélection

Stratégie: Pour trier dans l’ordre croissant

• Sélectionne le minimum des éléments à trier

• On le met en premiere position dans la liste triée

• On le supprime des elements à trier

Exemple:

L = [2, 4, 5, 3, 1]

Puis on trie la liste suivante :

L = [1, 4, 5, 3, 2]

L = [1, 2, 5, 3, 4]

L = [1, 2, 3, 5, 4]

Alors :

• On suppose que les plus petits éléments sont triés à leur place dé nitive

• On trie les n-k éléments:

1. On récupère l’indice du minimum i > k-1

2. On échange le terme d’indice i avec le terme d’indice k (i.e le (k+1)eme

terme)

3. On itère n-1 fois

Le tri est en place car la fonction modi e la liste

Le tri est stable c’est à dire les positions de deux éléments égaux ne sont pas modi ées.

Le tri se termine est la boucle se répète un nombre limite de fois et que minimum termine aussi.

Correction: On prouve un invariant de boucles par récurrence.

1
fi
fi
fi
Complexité:

O(n)

Si l’entrée est de taille n alors l’algorithme e ectue un nombre d’opérations élémentaires donné
par n:

∃K, n bOp ≤ Kn

N-1 itérations, N+2 a ectations

Donc (n + 1)(n + 2) = n 2 + n − 2

Donc O(n 2 )

Rigoureusement:

À la i ieme

B. Tri par insertion

Principe :

- Suppose que les i premiers élements sont triées

- On insere le (i+1) eme elements à sa place

Propriété:

- En place

- Stable

Complexité: O(n 2) car pour placer le (i+1)eme élément

On fait au maximum i comparaison et i échanges

n−1
2i = O(n 2)

∑
Et on répète pour les n élements de la liste.
i=0

2
ff
ff
3. Tris récursifs

DIVISER POUR RÉGNER

Principe:

- Diviser: on sépare le problème en deux

- Régner: Résoudre les deux problèmes

- Combiner: On combine les deux solutions pour obtenir la solution au problème initial

A. Tri Fusion

Stratégie

- D: On coupe la liste en deux listes de même taille

- R: On trie ces listes

- C: On fusionne ces listes

Fonction Fusion

Entrées: L1,L2 2 listes triées.

Sortie: L triée contenant les éléments de L1 et L2

Complexité: n1 + n 2 a ectations, au pire n1 + n 2 − 1 comparaisons (on pioche dans L1 puis L 2),

au mieux min(L1, L 2 ). Donc linéaire O(n) à n = n1 + n 2

Programme:

def tri_fusion(L):

if len(L) <= 1:

return L

else:

L1 = L[:len(L)//2]

L2 = L[len(L)//2:]

return fusion[tri_fusion(L1), tri_fusion(L2)]

Le slicing crée de nouvelles listes, le tri n’est pas en place (on a ajouté n cases mémoires).

Le tri est stable (on privilégie L1 dans fusion)

Soit n=len(L): C(n) la complexité de tri fusion sur une liste de taille n.

n n n n
C(n) = O(n) + 2.C( ) = 2(2C( ) + o( )) + O(n) = 8C( ) + 3o(n)

2 4 2 8
Et C(0) = C(1) = 2

Si n= 2k
Pas
C(n) = 2kC(1) + kO(n) = 2n + log2(n)O(n)
RIGOUREUX

D’après le théorème de la complexité des algorithmes récursifs: C(n) = O(n . log(n))

B. Tri rapide (QuickSort)

def partition(L,g,d):

pivot = L[g]

m = g

for i in range(g+1,d):

3
ff
 if L[i] < pivot:

m += 1

if i > m:

L[i], L[m] = L[m], L[i]

if m > g:

L[m], L[g] = L[g], L[m]

return m

def tri_rapide(L):

def aux(g,d):

if g < d-1

m = partition(L,g,d)

aux(g,m)

aux(m+1,d)

aux(O,len(L))

partition(L, o, len(L)) renvoie l’indice de l’élément pivot tel que après l’algorithme, les
éléments d’indices i < m sont inférieurs au pivot. Et les éléments d’indice i > m sont
supérieurs au pivot

A la n, le pivot est bien placé. Les indices g et d permettent de ne pas recopier la liste
a n que le tri soit en place. Il n’est pas stable.

Complexité de partition:

d − g − 1 comparaisons (tous les elements sont comparées au pivot).

Au mieux: aucun échange

Au pire: d − g − 1 échanges (si pivot est le plus grand)

Au total, dans le pire cas: 2(d − g − 1) i.e linéaire en la taille de la liste qu’on parcours.

Complexité de tri-rapide:
Dans le pire cas: on obtient une liste de taille d − g − 1et une de taille 0

n
k = O(n 2)

∑
k=0
d−g−1
Dans le meilleur cas: 2 listes de taille , si n = len(L) et C(n) est la complexité de
2
n−1 n−1
tri rapide sur L: C(n) = C(⌊ ⌋) + C(⌈ ⌉)

2 2

aux(g,m) aux(n+1,d)

D’après le théorème de la complexité des algorithmes DPR, O(nlog(n))

On veut calculer la complexité moyenne (on ajoute des probabilités)

E(X ) ∼+∞ 2nlog(n)

Sélection Sélection du Stable En place O(n 2 ) où n = len(L)

minimum

Insertion On insère le k eme Stable En place O(n 2 ) où n = len(L)

element parmi les
k − 1 premiers
triés

4
fi
fi
Bulle On échange un Stable En place O(n 2 ) où n = len(L)
élément et son
voisin si celui-ci
plus grand que ce
dernier

Fusion DPR: on coupe en Stable (si il Pas en place O(nlog(n))

2, on trie, on privilégie la liste 1)
fusionne

Quicksort DPR: on coupe en Pas stable En place O(nlog(n)) en

2 / pivot
moyenne

Les plus petits / les O(n 2 ) au pire

plus grand

Tri par tas O(nlog(n))