BCPST 1B Informatique 2015-2016 TD 6 : Algorithmes de tri

BCP ST 1B Informatique
2015-2016
TD 6 : Algorithmes de tri. Recherche d’un mot dans un texte.
Le début de ce TD est la correction du TD 5.
1) Trier les valeurs d’une liste.
Vous avez eu différentes idées pour trier les valeurs d’une liste de nombres. J’essaye ici de traduire ici vos idées.
a) La méthode la plus souvent présentée est la méthode par recherche du minimum (ou du maximum).
(Florian, Alexia, Christelle ...)
# Une première fonction permettant de trouver la position du
# minimum d’une liste"
def mini(L):
m=L[0]
k=0
for i in range(len(L)):
if L[i]<m:
m=L[i]
k=i
return k
def tri_min(L):
n=len(L)
S=[]
for i in range(n):
k=mini(L)
S+=[L[k]]
L=L[:k]+L[k+1:]
return S
#
#
#
#
#
on part d’une liste vide
autant de boucles que de valeurs
k est une position du minimum
on ajoute à S la valeur du minimum
on supprime le minimum à la position k
# Une autre version avec des méthodes.
def tri_min(L):
n=len(L)
S=[]
for i in range(n):
k=mini(L)
S.append(L[k])
L.pop(k)
return S
Un question pour vérifier que vous avez compris :
Si on utilise cette fonction pour trier une liste de longueur 100, combien de fois le programme va-t-il faire
la comparaison ”L[i]<m” dans la fonction mini ?
b) Tri par insertion. (Algorithme au programme)
Version de Marion.
def tri_marion(L):
S=[L[0]]
for k in range(1,len(L)):
i=0
while i<len(S) and L[k]>S[i]:
i+=1
S=S[:i]+[L[k]]+S[i:]
return S
# on notera les crochets autour de L[k]
1
# Une autre version avec des méthodes.
def tri_marion(L):
S=[L[0]]
for k in range(1,len(L)):
i=0
while i<len(S) and L[k]>S[i]:
i+=1
S.insert(i,L[k])
return S
Versions de Julie (sans ou avec des méthodes).
def tri_Julie(L):
S=[L[0]]
for k in range(1,len(L)):
i=len(S)-1
while i>=0 and L[k]<S[i]:
i-=1
S=S[:i+1]+[L[k]]+S[i+1:]
return S
def tri_Julie(L):
S=[L[0]]
for k in range(1,len(L)):
i=len(S)-1
while i>=0 and L[k]<S[i]:
i-=1
S=S.insert(i+1,L[k])
return S
Une version plus efficace avec une seule liste.
def tri_insertion(L):
n=len(L)
for i in range(1,n):
x=L[i]
j=i
while j>0 and L[j-1]>x:
L[j]=L[j-1]
j=j-1
L[j]=x
return L
Vous devez être capable de simuler l’exécution de ces différentes fonctions sur l’exemple suivant :
25
46
13
16
18
17
19
31
81
42
c) Tri à bulles.
Version de Léa.
def tri_bulle(L):
n=len(L)
for i in range(n-1):
for j in range(1,n-1):
if L[j-1]>L[j]:
L[j],L[j-1]=L[j-1],L[j]
return L
Un version améliorée.
def tri_bulle(L):
n=len(L)
for i in range(n-1):
for j in range(1,n-i):
if L[j-1]>L[j]:
L[j],L[j-1]=L[j-1],L[j]
return L
Une version sans l’affectation simultané de Python.
2
35
57
38
26
19
17
31
71
12
19
10
def tri_bulle(L):
n=len(L)
for i in range(n-1):
for j in range(1,n-i):
if L[j-1]>L[j]:
a=L[j]
L[j]=L[j-1]
L[j-1]=a
return L
Vous devez être capable de simuler l’exécution de ces différentes fonctions sur l’exemple suivant :
25
46
13
16
18
17
19
31
81
42
35
57
38
26
19
17
31
71
12
19
10
On peut encore améliorer cet algorithme, en particulier pour des listes peu désordonnée.
Avez-vous une idée ?
Vous pouvez voir sur le site : interstices.info une animation permettant de visualiser le fonctionnement
de tous ces algorithmes. (Googliser : interstices algorithme de tri)
2) Recherche d’un mot dans une chaı̂ne de caractères.
a) Ecrire une fonction Python qui permet de dire si oui ou non un mot est dans un texte.
La spécification de cette fonction sera :
def testliste((T,M):
"""str,str -> bool
renvoie si oui ou non le mot M est dans le texte T"""
b) Pour ceux qui vont plus vite, si vous avez fait a) en moins de 10 mn.
Répondre à la question précédente avec la contrainte :
on ne compare jamais des chaines de caractères de plus d’un caractère.
Autrement dit :
- Vous avez uniquement droit aux comparaisons : T[i]==M[j].
- On s’interdit T[1:5]==’ABCD’ où T[1:5]==M
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Quelques exercices.
1) Faire une fonction en Python qui fusionne deux listes triées.
Exemple : en partant des listes L1 = [1, 5, 6, 8, 9] et L2 = [2, 5, 10] on veut que la fonction sorte la liste .
[1, 2, 5, 5, 6, 8, 9, 10]
2)
a) Rappeler un algorithme de recherche d’une valeur dans une liste de nombres réels.
b) Ecrire un algorithme permettant de trouver une valeur dans une liste préalablement triée.
On essayera d’être plus efficace que lorsque ce qui a été vu en classe pour une liste non triée. On justifiera
que l’algorithme est plus efficace.
c) Traduire les deux algorithmes précédents en fonctions Python.
d) Expliquer comment vérifier, avec des tests, que la deuxième fonction est plus efficace que la première.
Indication :
pour calculer le temps d’exécution d’un programme on peut utiliser la fonction time du module time.
3) L(0, ..., n − 1) désigne une liste de n listes de réels,
Ecrire une fonction Python permettant de trier les listes de L dans l’ordre croissant de leur première composante.
Exemple En partant de la liste L = [[5, 6, 4], [3, 5], [7, 56, 5, 3], [1, 2]] on veut que la fonction retourne la liste
[[1, 2], [3, 5], [5, 6, 4], [7, 56, 5, 3]]
3