1 Algorithme de recherche dans une liste 2 Tri par insertion

Informatique
TD/ TP 4.1
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 (L1,1)
True
True
itération
init
1
2
3
4
5
itération
init
1
2
3
4
5
v
2
3
1
n
5
5
5
5
s
False False False True
c
0
T[c]
s
0
1
2
2
3
1
False False False True
2) Comparer les 2 algorithmes en terme de complexité temporelle 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 dichotomie et une liste contenant les entiers 0 à 4 qui
renvoie True si 1 est dans la liste. Combien d'itérations sont nécessaires pour obtenir ce résultat.
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
init
1
2
3
4
5
T[k]
T[2] : 2 T[1] :1
g
0
0
1
d
4
2
1
k
4//2=2
2//2=1
1//2=0
2 itérations nécessaire (3 au pire) pour 5 éléments
4) Comparer cet algorithme en terme de complexité temporelle et en mémoire avec les 2 premiers
algorithmes.
C(n) = k itérations tel que = 1 (k divisions par 2 sont nécessaires pour aboutir à 1 seul élément) soit
=
= 2. log
dans le pire des cas (1 absent de la liste ou situé à l'indexe 0 de L2).
2 Tri par insertion
5) 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-1] = [t[0], t[1]…t[n-2]] (qui est trié)
Lycée Jules Ferry Cannes
Page 1 sur 3
TSI1
Informatique
TD/ TP 4.1
Tri par insertion
6) 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,5,3,1,4]
On insère t[3] = 1 dans t[0 : 3]
t=[2,5,3,1,4]
On insère t[4] = 4 dans t[0 : 4]
t=[2,5,3,1,4]
A chaque étape, l’insertion de t[i ] provoque la modification du sous-tableau t[0 : i ] : on décale certains
éléments pour placer t[i ].
On fait des décalages vers la droite tant que l’élément t[j ] rencontré est supérieur à la valeur que l’on
veut insérer.
7) 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 31 à droite t = [7; 10; 21; 31; 31;45; 8; 1]
On décale la valeur 21. à droite t = [7; 10; 21; 21; 31;45; 8; 1]
On place la valeur 11
t = [7; 10; 11; 21; 31;45; 8; 1]
8) La liste initiale est-elle triée après l'exécution de la fonction ? Justifier votre réponse.
Oui la liste initiale est triée en fin de fonction car il s'agit d'un alias dans la fonction.
Si on souhaite que la liste passée en entrée ne soit pas modifiée par la fonction, il faut refaire une
affectation de la liste passée en entrée en début de fonction de tri :
T = T[0:len(T)-1]
T n'est plus alors un alias de la liste passée en entrée mais une liste contenant les valeurs de la liste
passée en entrée.
9) Ecrire les instructions faisant appel à la bibliothèque numpy et qui permettent de récupérer les
valeurs du fichier four.txt sous forme d'un tableau four.
mes1 = genfromtxt ( 'four.txt', delimiter='\t')
10) Ecrire une fonction rapidite qui admet les mesures mes en entrées et qui renvoie en sortie le
temps de réponse à 5%. Pour cela, on scrutera la valeur de la grandeur four à partir du dernier
instant de mesure jusqu'à ce que la grandeur s atteigne 95% de sa valeur finale ou 105% de sa
valeur finale.
Lycée Jules Ferry Cannes
Page 2 sur 3
TSI2
Informatique
TD/ TP 4.1
Tri par insertion
11) Ecrire une fonction ecart qui détermine l'écart maximum entre 2 mesures successives de la
grandeur physique four.
12) Ecrire une fonction valeurs qui admet les mesures et une valeur x en entrées. Cette fonction
renvoie les instants où l'écart entre x et les valeurs de températures sont inférieures à l'écart
maximum e constaté entre 2 températures successives (l'écart e est obtenu par la fonction
portant ce nom; l'algorithme de recherche est l'algorithme while avec la comparaison abs(xT[c])<e pour signifier l'égalité des flottants oùT est la liste des températures).
Lycée Jules Ferry Cannes
Page 3 sur 3
TSI2