1 Algorithme de recherche dans une liste

TD/ TP 4.1 (Correction
Informatique
de la partie TD)
Tri par insertion
1 Algorithme de recherche dans une liste
1) Compléter l'évolution des variables dans les tableaux suivants pour l'appel des fonctions avec les
entrées L1 et 1. Inscrire aussi en dessus des tableaux l'instruction correspondant à la fonction ainsi
que la valeur retournée en console.
>>> recherchef
(L1,1)
>>> recherchew
True
(L1,1)
True
itération
v
init
s
False
1
2
3
2
3
1
4
5
itération
n
init
1
2
3
5
5
5
5
c
0
0
1
2
2
3
1
Fals Fals True
e
e
T[c]
s
False
4
5
Fals Fals True
e
e
2) Comparer les 2 algorithmes en terme de complexité temporelle dans le pire des cas et en mémoire.
C(n) = n boucles dans le pire des cas et C(n)=1 boucle dans le meilleur des cas
(pour les 2 algorithmes).
recherchew nécessite une variable en plus, ce qui n'est pas significatif car cela
est indépendant de n.
3) Proposer une instruction avec la fonction recherche_dichotomique du cours 4.1 et une liste L2
contenant les entiers 0 à 4 qui renvoie True si 0 est dans la liste. Quelle doit être la condition sur la
liste L2 pour son utilisation avec la fonction recherche_dichotomique. Combien d'itérations
sont nécessaires pour obtenir ce résultat (tracer le tableau d'évolution des variables)?
L2=[0,1,2,3,4]
# liste triée obligatoire pour l'algorithme de dichotomie
print('dichotomie avec', L1, 'renvoie :', dichotomie (L2,1)).
Evolution des variables : les valeurs sont dans l'ordre de modification dans la
boucle.
itération
k
init
T[k]
g
0
d
4
1
4//2=2
2
0
2
2
3
4
5
2//2=1 1//2=0
1
0
0
0
1
0
2 itérations nécessaire (3 au pire) pour 5 éléments
4) Comparer cet algorithme en terme de complexité temporelle (nombre d'itérations dans le pire des cas)
et en mémoire avec les 2 premiers algorithmes pour une liste à 5 éléments.
Taille mémoire similaire (2 ou 3 variables)
Complexité dans le pire des cas : dichotomie : 3 (< log2(5)+1)
Complexité dans tous les cas du for : 5 itérations
Lycée Jules Ferry Cannes
Page 1 sur 2
while : 5
TSI1
Informatique
TD/ TP 4.1
Tri par insertion
2 Tri par insertion
On donne les algorithmes suivant
Algorithme Tri par insertion
Entrées : liste T (tableau de n nombres; n≥ 2)
Sortie : liste T triée par ordre croissant
Pour i de 1 à n-1 faire
x←T[i]
j← i
Tant que j> 0 et T[j-1] > x faire
T[j] ←T[j-1]
j← j-1
Fin Tant que
T[j] ←x
Fin Pour
Renvoyer T
Fin de Tri par insertion
def Tri_insertion (T):
# Entrée : liste T de n nombres (n≥ 2)
# Sortie : liste T triée par ordre croissant
n = len(T)
for i in range(1,n): # tri de T
x = T[i]
j = i # j : position triée pour x
while j>0 and T[j-1] > x :
T[j] = T[j-1]
j=j-1
T[j] = x
return T
5) Convertir l'algorithme donné sous forme de pseudo code en une fonction Tri_insertion en python.
6) Compléter la description suivante en décrivant la dernière itération.
partant d’un tableau t de taille n ≥ 2 :
on insère t[1] dans le sous-tableau t[0 : 1] = [t[0]]
on insère t[2] dans le sous-tableau t[0 : 2] = [t[0], t[1]] (qui est trié)
…
on insère t[n-1] dans le sous-tableau t[0:n-2] = [t[0], t[1]…t[n-2]] qui est trié
7) Compléter le tableau suivant qui décrit l'évolution du tri par l'algorithme Tri_insertion.
Sur le tableau t = [5; 2; 3; 1; 4], l’algorithme est :
t=[5,2,3,1,4]
On insère t[1] = 2 dans t[0 : 1]
t=[2,5,3,1,4]
On insère t[2] = 3 dans t[0 : 2]
t=[2,3,5,1,4]
On insère t[3] = 1 dans t[0 : 3]
t=[1, 2,3,5,4]
On insère t[4] = 4 dans t[0 : 4]
t=[1,2,3,4,5]
8) Compléter le tableau suivant décrivant l'effet de l'algorithme. Préciser la séquence de l'algorithme
qui produit les décalages vers la droite.
Soit t = [7, 10, 21, 31, 45, 11, 8, 1] (de longueur n = 8).
Pour insérer la valeur t[5] = 11 dans t[0 : 5] = [7, 10, 21, 31, 45].
On stocke la valeur 11 ailleurs t = [7, 10, 21, 31, 45,11, 8,1]
On décale la valeur 45 à droite t = [7, 10, 21, 31, 45,45, 8, 1]
On décale la valeur … à droite t = [7, 10, 21, 31, 31, 45,
On décale la valeur …. à droite
On place la valeur….
Lycée Jules Ferry Cannes
8, 1]
t = [7, 10, 21, 21, 31, 45, 8, 1]
t = [7, 10, 11, 21, 31, 45, 8, 1]
Page 2 sur 2
TSI2