1 Algorithme de tri rapide (quick sort) 2 Compréhension de l

Informatique TD/ TP 4.2 Tri rapide (quick sort)
Lycée Jules Ferry Cannes Page 1 sur 2 TSI2
On se propose ici d’implémenter l’algorithme de tri rapide ("quick sort") étudié en cours.
1 Algorithme de tri rapide (quick sort)
L'algorithme suivant permet d'effectuer le tri en choisissant comme pivot le premier élément de la liste
Pseudo code
Algorithme de tri_rapide(L)
n nombre d'élément de L
Si n  1 alors
renvoyer L
Sinon
G1 liste vide
G2 liste vide
p extraire l'élément d'indice 0 de L
\ en le retirant de L
Pour tous les éléments e de L faire
Si e  p faire
ajouter e à G1
Sinon
ajouter e à G2
Fin Si
Fin Pour
renvoyer G1 + [ p ] + G2
Fin Si
Fin Algorithme tri_rapide
1) Ecrire ci-dessus en python la fonction tri_rapide(L) qui traduit l'algorithme en pseudo-code de tri
rapide (quick sort).
2) Démontrer la correction de l'algorithme en utilisant l'invariant de boucle énoncé dans le cours "Les
listes de longueurs inférieures ou égales à k sont triées".
2 Compréhension de l'algorithme
3) Dérouler étape par étape l’algorithme de tri rapide du tableau t = [8, 2, 4, 23, 15, 17, 0, 1]. On
complètera pour cela l'arbre des appels récursifs dans lequel on utilisera la notation tr() pour
évoquer l'appel à la fonction tri_rapide(). Le respect de l'ordre des valeurs dans les partitions est
impératif dans la liste d'entrée de tr(). On indiquera dans le rectangle inférieur droit de chaque
appel le pivot qui sera utilisé et qui est retiré des éléments à trier. Les listes vides (Gr1 ou Gr2) ne
sont pas représentées.
tr(t)
tr([2,4,0,1])
tr([0,1]) tr([1])
tr([4])
tr([23,15,17]) tr([15,17]) tr([17])
8
2
23
0
1
4
1
5
17
Python :
def tri_rapide(L) :
n = len(L)
if n<=1 :
return L
else :
G1 = []
G2 = []
p = L.pop(0)
for e in L :
if e<=p :
G1.append(e)
else : #
G2.append(e)
return tri_rapide(G1) + [p] +
tri_rapide(G2)
Gr1
Gr2
Gr1
Gr2
Gr2
Gr1 Gr2

Informatique TD/ TP 4.2 Tri rapide (quick sort)
Lycée Jules Ferry Cannes Page 2 sur 2 TSI2
4) Même question que précédemment mais avec la liste quasi-triée t=[0,1,2,4,8,15,17,23]
5) Même question que précédemment mais avec la liste quasi-triée t=[0,1,2,4,8,15,23,17] pour un
pivot pris à la médiane de la liste (comme dans le cours)
6) Conclure sur le choix du pivot probablement le plus rapide sur des listes quasi-triées.
3 Implémentation de l'algorithme
7) Copier le fichier TP4_2tri_rapide.py dans vos documents puis l'ouvrir avec Spyder.
8) Recopier dans votre cours l'algorithme correspondant et vérifier si votre traduction de la 1
ère
question était correcte.
9) Modifier la fonction tri_rapide afin de choisir aléatoirement le pivot (on pourra importer la fonction
randint de la bibliothèque random et utiliser la fonction randint(a,b), qui choisit aléatoirement un
entier dans [a, b] ATTENTION le dernier indice est inclus),
10) Afin d'évaluer l'effet de cette modification d'algorithme avec une liste triée de 1000 éléments (cela
correspond donc sensiblement à une liste presque triée) sur la durée d'exécution, on pourra
importer la fonction time du paquet time.
La fonction time() ainsi importée renvoie le temps en seconde.
En faisant la différence entre le temps après l'exécution et celui avant l'exécution, on peut
déterminer le temps mis par l'algorithme en seconde.
11) On pourra aussi comparer les temps nécessaires au tri rapide sur une liste quasi triée selon le
choix du pivot (premier élément, médian, aléatoire et dernier élément).
position du pivot 1
er
indice médian aléatoire dernier indice
durée
(en s)
n=1000  0.13 n=1000  0.01
n=10000 0.04
n=10
6
6
n=1000 0.01
n=10000 0.1
n=1000  0.13
12) Comparer avec la durée nécessaire au tri d'une liste de 1000 éléments triés avec la méthode de
tri par insertion vue lors du TP précédent  0.01 et 0.5s sur une liste croissante avec 106
termes.
13) Vérifier si les durées observées sont compatibles avec les complexités étudiées en cours
(quadratique dans le pire des cas ; quasi-linéaire dans le meilleur des cas ; quasi-linéaire en
moyenne sur des listes aléatoires)
tr(t) tr([1,2,4,8,15,23,17]) tr([2,4,8,15,23,17]) tr([23])
tr(t)
tr([0,1,2,4])
tr([0,1]) tr([0])
tr([4])
tr([15,23,17]) tr([15,17]) tr([15])
0
1
2
23
8
2
23
1
4
17
15
0