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

BCP ST 1BInformatique 2015-2016
TD 6 : Algorithmes de tri. Recherche d’un mot dans un texte.
Le d´ebut de ce TD est la correction du TD 5.
1) Trier les valeurs d’une liste.
Vous avez eu diff´erentes id´ees pour trier les valeurs d’une liste de nombres. J’essaye ici de traduire ici vos id´ees.
a) La m´ethode la plus souvent pr´esent´ee est la m´ethode par recherche du minimum (ou du maximum).
(Florian, Alexia, Christelle ...)
# Une premi`ere 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=[] # on part d’une liste vide
for i in range(n): # autant de boucles que de valeurs
k=mini(L) # k est une position du minimum
S+=[L[k]] # on ajoute `a S la valeur du minimum
L=L[:k]+L[k+1:] # on supprime le minimum `a la position k
return S
# Une autre version avec des m´ethodes.
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´erifier 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:] # on notera les crochets autour de L[k]
return S
1

# Une autre version avec des m´ethodes.
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´ethodes).
def tri_Julie(L): def tri_Julie(L):
S=[L[0]] S=[L[0]]
for k in range(1,len(L)): for k in range(1,len(L)):
i=len(S)-1 i=len(S)-1
while i>=0 and L[k]<S[i]: while i>=0 and L[k]<S[i]:
i-=1 i-=1
S=S[:i+1]+[L[k]]+S[i+1:] S=S.insert(i+1,L[k])
return S 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 ˆetre capable de simuler l’ex´ecution de ces diff´erentes 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
c) Tri `a bulles.
Version de L´ea.
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´elior´ee.
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´e de Python.
2

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 ˆetre capable de simuler l’ex´ecution de ces diff´erentes 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´eliorer cet algorithme, en particulier pour des listes peu d´esordonn´ee.
Avez-vous une id´ee ?
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`eres.
a) Ecrire une fonction Python qui permet de dire si oui ou non un mot est dans un texte.
La sp´ecification 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´epondre `a la question pr´ec´edente avec la contrainte :
on ne compare jamais des chaines de caract`eres de plus d’un caract`ere.
Autrement dit :
- Vous avez uniquement droit aux comparaisons : T[i]==M[j].
- On s’interdit T[1:5]==’ABCD’ o`u T[1:5]==M
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Quelques exercices.
1) Faire une fonction en Python qui fusionne deux listes tri´ees.
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´eels.
b) Ecrire un algorithme permettant de trouver une valeur dans une liste pr´ealablement tri´ee.
On essayera d’ˆetre plus efficace que lorsque ce qui a ´et´e vu en classe pour une liste non tri´ee. On justifiera
que l’algorithme est plus efficace.
c) Traduire les deux algorithmes pr´ec´edents en fonctions Python.
d) Expliquer comment v´erifier, avec des tests, que la deuxi`eme fonction est plus efficace que la premi`ere.
Indication :
pour calculer le temps d’ex´ecution d’un programme on peut utiliser la fonction time du module time.
3) L(0, ..., n −1) d´esigne une liste de nlistes de r´eels,
Ecrire une fonction Python permettant de trier les listes de Ldans l’ordre croissant de leur premi`ere 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