1 Algorithme de recherche dans une liste

Informatique
TD / TP 4.1
Tri par insertion
1 Algorithme de recherche dans une liste
On donne les 2 fonctions suivantes :
def recherchef (T,x):
# Entrées : élément x et liste T
# Sortie : s=True si x dans T et False sinon
s = False
# s : Faux par défaut
for v in T:
if v==x :
s = True
return s
def recherchew (T,x):
# Entrées : élément x et liste T
# Sortie : s=True si x dans T et False sinon
n = len (T)
s = False
# s : Faux par défaut
c=0
# initialisation de l'indexe
while (c<n and s==False):
if T[c]==x :
s = True
c = c+1
return s
L1=[2, 3, 1, 0, 4]
1) Compléter l'évolution des variables dans les tableaux suivants pour l'appel des fonctions avec les
entrées L1 et 0. Inscrire aussi en dessus des tableaux l'instruction correspondant à la fonction ainsi
que la valeur retournée en console.
>>> recherche…………..
……………………………..
itération
init
1
2
v
s
3
4
5
>>> recherche…………..
……………………………..
itération
init
1
2
n
False
c
3
4
5
0
T[c]
s
False
2) Comparer les 2 algorithmes en terme de complexité temporelle dans le pire des cas et en mémoire.
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)?
itération
k
init
T[k]
g
0
d
4
1
2
2
0
2
2
1
1
0
1
3
4
5
0
0
0
0
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 4
while : 5
TSI2
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]
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.
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,
Lycée Jules Ferry Cannes
Page 2 sur 4
8, 1]
TSI2
Informatique
TD/ TP 4.1
On décale la valeur …. à droite
On place la valeur….
Tri par insertion
t = [7, 10, 21, 21, 31, 45, 8, 1]
t = [7, 10, 11, 21, 31, 45, 8, 1]
On récupère des mesures à partir d'un logiciel de simulation ou d'une mesure expérimentale.
Le fichier est constitué de 2 colonnes :
-
la première colonne est constituée des instants t,
-
la deuxième colonne est constituée de la consigne (échelon de température),
-
la troisième colonne est constituée des valeurs mesurées dans un four (on suppose que la durée
d'acquisition est suffisante pour que la sortie se soit stabilisée autour de sa valeur finale égale à la
dernière valeur de température et que la mesure démarre au lancement de l'échelon).
Figure 1 : Extrait du fichier four.txt
Figure 2 : Relevés
du fichier four.txt
des
temps
1
2
3
4
5
6
7
…
Consigne
0
9.988 9.988 9.988 9.988 9.988 9.988 -
Temperature
0
0.0910000000000011
0.183
0.183
0.0609999999999999
0.0609999999999999
0.0609999999999999
mesures
Vous trouverez en annexe (fin du document) une liste de fonctions numpy pour les tableaux.
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.
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.
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(x-T[c])<e pour signifier
l'égalité des flottants oùT est la liste des températures).
Ressources : Damien Broizat
Lycée Jules Ferry Cannes
Page 3 sur 4
TSI2
Informatique
TD/ TP 4.1
Tri par insertion
ANNEXE : Tableaux avec la bibliothèque numpy
Pour importer les bibliothèques sans préfixe (certaines fonctions nécessitent néanmoins le préfixe np; np
est le raccourci défini par défaut par la bibliothèque):
from numpy import *
Remarque : à la différence des variable dans python, les éléments contenus dans les tableaux numpy
sont typés (float ou int16 ou int64…)
Créer un vecteur ligne à partir des valeurs
v=array([1, 2, 3])
Créer un vecteur colonne à partir des valeurs
v=array([[1],[2],[3]])
Créer un tableau à 2 dimensions à partir des valeurs
M=array([[1,2,3],[4,5,6]])
Accéder au dernier élément, et l'avant dernier
v[0]
M[0,1]
v[-1], v[-2]
Dimensions d'un tableau
M.shape
Extraire la 2ème ligne ou 2ème colonne
M[1,:] ou M[:,1]
Accéder à un élément
Extraire une portion de tableau (2 premières colonnes) M[:,0:2]
Extraire des éléments d'un tableau par leurs indices
M[0,(2,1)]
Séquence équirépartie d'entiers
range(1,11)
Séquence équirépartie quelconque
arange(0,10.1,0.1)
Tableau de zéros à 2 lignes et 3 colonnes
(float : facultatif)
Tableau de uns à 2 lignes et 3 colonnes
(float : facultatif)
zeros((2,3),float)
ones((2,3),float)
Copier un tableau dans une autre variable
w=v.copy()
Multiplication élément par élément
v*w
Maximum et minimum d'un tableau
v.max(0), v.min(0)
Indice i du maximum
v.argmax(0)
Produit matriciel
dot(v,w)
Transposée
M.transpose()
Résolution de système matriciel M.X=Y
linalg.solve(M,Y)
Tableau à partir d'un fichier texte 'fichier.txt' dont les
valeurs en colonne sont délimitées par des tabulations M = np.genfromtxt('fichier.txt', delimiter='\t')
Lycée Jules Ferry Cannes
Page 4 sur 4
TSI2