TP 8 : méthodes de tris PTSI 2023/2024

I Tri par bulle :

I.1 Description générale de l’algorithme
Tant qu’il existe un couple d’éléments consécutifs qui n’est pas dans le bon ordre, parcourir la liste
en échangeant les éléments consécutifs qui ne sont pas dans le bon ordre.

E XEMPLE 1. On donne l’exemple ci-dessous :

3 4 8 1 7 2 9 5 liste de départ
3 4 1 7 2 8 5 9 8 et 9 se déplacent vers la droite
3 1 4 2 7 5 8 9 4, 7 et 8 remontent
1 3 2 4 5 7 8 9 3, 4 et 7 remontent
1 2 3 4 5 7 8 9 liste triée

I.2 Description plus détaillée

I On commence par parcourir la liste L de longueur n en comparant deux par deux les éléments
successifs de L, si L[k] > L[k+1] alors on permute ces deux éléments.
I Ainsi lorsque k aura parcouru les valeurs de 1 à n-1, L[n] contiendra le plus grand élément de
L!
I Il reste à réitérer le procédé sur L pour k allant de 1 à n-2, puis de 1 à n-3, etc...

1. Expliquer l’affirmation selon laquelle à la fin de la première itération le plus grand élément de la
liste est en dernière position.

I.3 Programmation
1. Écrire une fonction Python tri-bulle qui prend en entrée une liste L et qui la trie par la méthode
précédente.

P OINT COURS : L ISTE DE NOMBRES ALÉATOIRES

Le module Python numpy.random dispose de plusieurs commande pour générer des nombres
"aléatoirement" les deux principales étant numpy.random.randint pour générer des entiers
et numpy.random.rand() pour générer des flottants :
# Générer un tableau de 12 entiers entre -10 et 87 (exclu) :
numpy.random.randint(-10,87,12)
# Générer un tableau de 15 flottants entre 0 et 1 :
numpy.random.rand(15)
2. Effectuer des tests de votre fonction sur des listes de nombres générées aléatoirement à l’aide de
la fonction randint du module numpy.random. Vous comparerez vos résultats avec ceux de la
méthode sort de Python.
3. Voyez-vous une amélioration possible de votre fonction ?

I.4 Tests de vitesse

P OINT COURS : M ESURE DE TEMPS D ’ EXÉCUTION

Le module Python time permet d’effectuer des mesures de temps à l’aide de diverses com-
mandes. Nous utiliserons :

time.perf_counter()

de la manière suivant pour mesurer le temps d’exécutions d’une série d’instruction :

t1 = time.perf_counter()
Instructions
t = t1-time.perfcounter()

et la variable t contient alors le temps écoulés en seconde pour exécuter Instructions.

1) Programmer alors un test de temps de votre fonction qui mesurer le temps nécessaire au tri de
N=1000 listes d’entiers de longueur l = 20 générées aléatoirement à l’aide de np.random.randint.
2) Comparer ce temps à celui de la fonction sort de Python.

II Tri par comptage :

II.1 Principe de l’algorithme
On veut trier une liste L qui contient des nombres entiers de 0 à p
L’idée est de compter le nombre d’occurrences de chaque nombre dans la liste à trier puis ayant stocker
ces nombres, de les utiliser pour créer une version triée de la liste.

II.2 Description détaillée

La liste à trier est L et elle est composée d’entier entre 0 et p.
I On crée un tableau C de p+1 valeurs, initialisé avec des 0.
I On traverse L et on compte le nombre de fois où chaque élément est présent en incrémentant le
tableau C à l’indice de l’élément.
I Ensuite on balaie le tableau C et on copie autant de fois une valeur qu’elle apparait dans C
E XEMPLE 2. Si L = [1, 5, 6, 5, 5, 6, 3], on peut compter :
0 1 2 3 4 5 6
0 1 0 1 0 3 2
On a donc : C = [0, 1, 0, 1, 0, 3, 2] et on obtient le tableau trié : T = [1, 3, 5, 5, 5, 6, 6]
II.3 Programmation
1. Programme une fonction python triCompt qui prend en entrée une liste d’entier naturel L et qui
exécute l’algorithme précédent pour créer une version triée de L que vous nommerez out. La liste
contenant le nombre d’occurrences des éléments de L sera notée tmp.
2. La encore faire des tests sur des listes aléatoires d’entier naturel en comparant vos résultats avec
ceux de la méthode sort.

II.4 Tests de vitesse

1. Effectuer à nouveau un test de vitesse sur des listes aléatoires d’entiers entre 1 et 1000. Vous prendrez
des listes de longueur 100 et vous ferez N=1000 tests pour comparer les résultats des trois méthodes :
tri_bulle, tri_compt et sort
2. Répéter les comparaison précédentes pour des longueurs de listes allant de 50 à 500 (avec un pas de
50) et représenter les temps d’exécutions des trois fonctions sur un même graphique.