Transcript TP 2: listes

DUT Info
Structures de donn´ees et algorithmes fondamentaux
2014–2015
TP 2: listes
Anthony Labarre
A la fin du TP, vous enverrez par e-mail un fichier nomm´
e GROUPE_NOM_TP2.py
(par exemple : A DUPONT TP2.py). Veillez `
a bien respecter la structure d’un
programme Python, comme pr´
esent´
ee dans le fichier modele.py.
L’objectif de ce TP est de comparer les performances des algorithmes de recherche et
de tris vus au cours aux m´ethodes d´ej`a existantes en Python. Pour ce faire, on construit
des graphiques donnant la croissance du temps d’ex´ecution des m´ethodes concern´ees en
fonction de la croissance de la taille des donn´ees, en prenant bien soin cette fois-ci
d’effectuer des moyennes.
Exercice 1. Recherche d’un ´
el´
ement
Le but de l’exercice est de comparer en pratique les performances de la recherche classique
et de la recherche dichotomique. La g´en´eration de listes pouvant parfois ˆetre longue, on
effectuera un certain nombre de recherches diff´erentes sur la mˆeme liste, et on affichera
le temps total d’ex´ecution a` l’utilisateur.
1. Ecrivez une fonction listeAleatoireTriee(n) qui utilise la fonction random()
pour renvoyer une liste tri´ee de n r´eels. Cette fonction doit ˆetre en O(nf (·)), o`
u
f (·) est le temps d’ex´ecution de la fonction random().
2. Impl´ementez les deux algorithmes de recherche vus au cours.
3. On veut `a pr´esent ´evaluer la croissance du temps moyen sur p ex´ecutions du temps
mis par les deux algorithmes en pratique. Compl´etez votre programme de mani`ere
a` ce qu’il construise une liste tri´ee al´eatoire de k ´el´ements pour chaque valeur de
k entre 1 et n, et effectue p recherches dans cette liste avec chaque m´ethode. Vous
pouvez choisir n et p, ou demander ces valeurs a` l’utilisateur, mais ´evitez dans un
premier temps de d´epasser 1000 pour n et 200 pour k.
4. Afin de visualiser la croissance de ces fonctions, compl´etez vos programmes pour
qu’il utilise la fonction tracer du TP 1 et dessine la liste des temps moyens
de recherche pour les deux m´ethodes (les moyennes sont donc calcul´ees sur p)
ex´ecutions.
5. Python propose deux m´ethodes pour savoir si un ´el´ement est dans une liste :
l’op´erateur in, qui renvoie True si l’´el´ement est dans la liste (utilisation : x in
T), et la m´ethode index(), qui donne la position de x dans T si x s’y trouve (utilisation : T.index(x)). Comparez ces m´ethodes aux autres comme dans la question
pr´ec´edente, en produisant un graphique contenant les quatre courbes.
Attention : T.index(x) provoque une exception si x ne se trouve pas dans la liste
T. Pour ´eviter les plantages, utilisez le bloc d’instructions suivant (les explications
arriveront plus tard dans le cours de programmation) au lieu de T.index(x) :
Page 1 sur 3
DUT Info
1
2
3
4
5
Structures de donn´ees et algorithmes fondamentaux
essai = None
try:
essai = T.index(x)
except: # x pas dans T
pass
2014–2015
6. Au vu des r´esultats, serait-il intelligent de v´erifier qu’une liste est tri´ee avant de
lancer une recherche ? Pourquoi ?
Exercice 2. Tris
On a vu au cours trois algorithmes de tris : le tri bulle, le tri par insertion et le tri par
s´election.
1. Donnez la complexit´e de chacun de ces algorithmes de tri, en justifiant vos r´eponses.
2. A votre avis, lequel de ces algorithmes sera le moins performant en pratique ?
Pourquoi ?
3. V´erifiez vos r´eponses exp´erimentalement en suivant le plan ci-dessous :
(a) Ecrivez une fonction listeAleatoire(n) renvoyant une liste de n r´eels al´eatoires entre 0 et 1.
(b) Compl´etez votre programme de mani`ere `a g´en´erer des graphiques comme dans
l’exercice 1 : cette fois, on g´en`ere p listes al´eatoires de k r´eels pour chaque
valeur de k entre 1 et n, et on trie chacune de ces listes a` l’aide des trois
algorithmes de tris. Vous pouvez choisir n et p, ou demander ces valeurs `a
l’utilisateur, mais ´evitez dans un premier temps de d´epasser 100 pour n et 200
pour k.
(c) Ces r´esultats correspondent-ils a` vos pr´evisions ? Pourquoi ?
Exercice 3. Progression
Il est souvent utile d’informer l’utilisateur d’un programme de l’´evolution de la tˆache en
cours. Pour ce faire, on peut afficher une barre de progression, ou le pourcentage de travail
d´ej`a effectu´e. Il est n´ecessaire de savoir que Python utilise un buffer pour l’affichage, qui
stocke les donn´ees `a ´ecrire plutˆot que de les ´ecrire directement. Vous aurez besoin dans
cet exercice de vider ce buffer afin de r´ealiser vos affichages correctement ; ceci peut se
faire grˆace a` la fonction stdout.flush() (sans param`etre), disponible apr`es avoir r´ealis´e
l’import from sys import stdout.
1. Ecrivez un programme qui simule une barre de progression en r´ealisant l’affichage
suivant :
|======...===|
L’affichage devra ˆetre progressif, c’est-`a-dire qu’on rajoutera des = a` ce qu’on aura
d´ej`a affich´e au fur et a` mesure que la tˆache s’ex´ecute et ce jusqu’`a ce qu’on atteigne
la fin. Le programme demandera un entier n a` l’utilisateur, qui correspondra au
nombre de = a` afficher. Utilisez la fonction sleep() du module time pour simuler
une activit´e.
2. Compl´etez votre programme pour qu’il simule ´egalement un pourcentage de progression en affichant 1 %, 2 %, etc. Chaque affichage doit remplacer le pr´ec´edent
Page 2 sur 3
DUT Info
Structures de donn´ees et algorithmes fondamentaux
2014–2015
sur la mˆeme ligne. Pour ce faire, vous pouvez utiliser le caract`ere ’\b’, qui permet
d’effacer le caract`ere pr´ec´edent. Utilisez la fonction sleep() du module time pour
simuler une activit´e.
3. Essayez a` pr´esent de r´ealiser cet affichage de pourcentages en fin de ligne, comme
dans l’exemple ci-dessous :
T´
el´
echargement en cours ... 17 %
Votre programme se comporte-t-il comme pr´evu ? Dans le cas contraire, modifiez
votre fonction pour qu’elle produise le comportement attendu.
Exercice 4. Terminez les exercices du TP 1 que vous n’auriez pas finis.
Page 3 sur 3