1 Algorithme de recherche dans une liste

Informatique Cours 4.1 Tri par insertion
Lycée Jules Ferry Cannes Page 1 sur 4 TSI2
Le tri des listes est un des éléments qui permet d'accéder aux données rapidement.
Exemple de requêtes possibles sur des listes triées :
- rechercher si un élément est dans un tableau (recherche d'un mot dans une liste de mots clefs pour
les métadonnées de pages internet),
- déterminer la médiane d’une liste de nombres (exemple : dans un concours, déterminer la note qui
départage les candidats en deux groupes de même effectif),
- sélectionner une sous-liste d’éléments consécutifs (exemple : afficher seulement les relevés
temporels compris entre l'instant 1s et l'instant 2s),
1 Algorithme de recherche dans une liste
1.1 Recherche dans une liste non triée
Algorithme Recherche de x dans L
Entrées : élément x et liste L
Sortie : s=Vrai si x est dans L et Faux sinon
n  Nombre d'éléments de L
s  Faux
c  0
Tant que (c < n et s=Faux) Faire
Si L[c]=x alors
s  Vrai
c  c+1
Fin tant que
Renvoyer s
Fin de l'algorithme Recherche de x dans L
def recherche (L,x):
# Entrées : élément x et liste L
# Sortie : s=True si x dans L et False sinon
n = len (L)
s = False # s : Faux par défaut
c = 0 # initialisation de l'indexe
while (c<n and s==False):
if L[c]==x :
s = True
c = c+1
return s
Appel de la fonction recherche:
>>> liste = [0,2,1]
>>> recherche (liste,2)
True
Complexité
Dans le pire des cas, l'élément n'est pas présent dans la liste, la complexité temporelle correspond à
C(n)=n
Pour les algorithmes de recherche dans une liste non triée on a une complexité linéaire
(comptée en nombre d'itérations).

Informatique Cours 4.1 Tri par insertion
Lycée Jules Ferry Cannes Page 2 sur 4 TSI2
1.2 Complexité dans une liste triée
Algorithme Recherche dichotomique[2]
Entrées : élément x et liste L
Sortie : s=Vrai si x est dans L et Faux sinon
n  Nombre d'éléments de L
g  0
d  n-1
Tant que g d Faire
k  (g+d) div 2
Si L[k]<x Alors
g  k+1
Sinon :
Si L[k]>x Alors
d  k
Sinon :
d  k
g  k
Fin Si
Fin Tant que
Si L[g]=x Alors
s  True
Sinon
s  False
Fin Si
Renvoyer s
Fin de Recherche dichotomique
def Recherche_dichotomique (L,x):
# Entrée : liste L, x élément cherché
# Sortie : s=True si x dans L et False sinon
n=len(L)
g=0 # premier indice de L : 0
d=n-1 # dernier indice de L : n-1
while g!=d:
k=(g+d)//2 # dichotomie
if L[k]<x: # x est à droite du milieu
g=k+1
else:
if L[k]>x: # x est à gauche du milieu
d=k
else: # x est au milieu
g=k
d=k
if L[g]==x: # Affectation de la sortie
s=True
else:
s=False
return s
Appel de la fonction Recherche_dichotomique :
>>> liste_triee=[0,1,2]
>>> Recherche_dichotomique(liste_triee,2)
True
Complexité : Dans le pire des cas, l'élément n'est pas présent dans la liste. Si m est le nombre d'éléments
restants après k itérations : jusqu'à m=1. Complexité itérations.
Pour un algorithme de recherche dichotomique, on a une complexité logarithmique
(comptée en nombre d'itérations).
1.3 Conclusion
Pour le traitement de grandes quantités de données (base de donnée internet, relevés à haute fréquence,
résultats de calculs par éléments finis…), l'algorithme a un impact important sur les durées de traitement.
Exemple pour  pages trouvées, un moteur de recherche internet met 0,5 s.
Pour une durée unitaire d'opération de 10ns si n= données :
- Un algorithme linéaire conduit à une durée de traitement de 10s.
- Un algorithme logarithmique    conduit à une durée de traitement de 300ns
Pour afficher rapidement des données nombreuses, il est donc indispensable de trier les données avant les
requêtes.
2 Tris
2.1 Principe du tri
On se donne un tableau t, dont les éléments t[0]; t[1]; t[2]; …; t[n - 1] sont comparables.
Les t[i] peuvent être : des entiers, des flottants, des lettres de l’alphabet…
Un tableau t est trié par ordre croissant si : t[0]  t[1] … t[n-1]:
Exemple : si t = ['C','A','T','A, 'Z','U','M'], on veut transformer t en t0 = ['A','A', 'C','M','T','U', 'Z']

Informatique Cours 4.1 Tri par insertion
Lycée Jules Ferry Cannes Page 3 sur 4 TSI2
Trois algorithmes sont au programme : le "tri par insertion", le "tri rapide" et le "tri fusion".
D’autres algorithmes hors programme existent : "tri par sélection", "tri à bulles" . . .
Chacun de ces tris se base sur une suite de comparaisons d’éléments.
Mais ces différents algorithmes ne sont pas équivalents, ils ont des complexités différentes, c’est-à-dire que
certains nécessitent plus de comparaisons d’éléments que d’autres, ou plus d’affectations.
2.2 Tri par insertion
On insère successivement chaque élément dans l’ensemble des éléments déjà triés.
Ce tri s’effectue en place : pas besoin de créer un autre tableau que celui que l’on trie.
Le coût en mémoire est constant.
Algorithme Tri par insertion
Entrées : liste T (tableau de n nombres; n 2)
Sortie : liste T triée par ordre croissant
nnombre d'éléments de T
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
Appel de la fonction Tri_insertion :
>>> liste=[5, 8, 3, 2, 9]
>>> Tri_insertion (liste)
[2, 3, 5, 8, 9]
def Tri_insertion (T):
"""Entrée liste T à n nombres (n 2)
Sortie : liste T triée (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] # remonterdroite
j = j - 1
T[j] = x
return T
Terminaison
Chaque boucle while se termine puisque le variant de boucle j est initialement strictement positif puis
décrémenté à chaque itération, éventuellement jusqu'à la valeur 0.
Correction[1]
L'invariant de la boucle for "P(i) : la liste T[0:i] est triée" permet de prouver la
correction de l'algorithme.
- Initialisation : i=1  T[0:1] contient un seul élément qui est donc trié.
- Récurrence : On suppose que P(i) est vraie, montrons que P(i+1) est vraie.
3 2
i=1, x=8
tout remontex en 0
T[0]=5<x 8 en 1
i=2, x=3
tout remontex en 0
i=3, x=2
T[4]=8<x  9 en 5
i=4, x=9

Informatique Cours 4 Tri par insertion
Lycée Jules Ferry Cannes Page 4 sur 4 TSI2
Si P(i) est vraie alors  !  ! "   # $ %!   # $ !, de plus x=T[i]
• si  # $ ! &   #! alors on sort de la boucle while et la proriété P(i+1) est vraie sans
itération sur j :  !  ! "   # $ %!   # $ !  &   #!
• si  # $ !  & alors on réalise des itérations avec le while tant que :
o soit T[j-1] & et dans ce cas on obtient la liste
 !  ! "   ' $ !
(
)
)
)
)
)
)
)
)
*
)
)
)
)
)
)
)
)
+
,-./01,23-145678
  '! &   '  !  "   #!
(
)
)
)
)
)
)
*
)
)
)
)
)
)
+
5,93-47823-145678
 P(i+1) est vraie,
o soit j=0 et dans ce cas tous les éléments sont remontés (donc triés) et plus grand
que x : &   !  %! "   # $ !   #!
(
)
)
)
)
)
)
)
)
)
)
)
*
)
)
)
)
)
)
)
)
)
)
)
+
5,93-47823-145678105:6,84;506,
 P(i+1) est vraie.
- Correction : la valeur qui met fin à la boucle for est i=n. On a alors P(n) vraie : la liste T[0:n] est triée
et contient les n éléments de T donc la liste T est triée.
Complexité (en temps)
On rappelle les différentes étapes de tri sur la liste [5,8,3,2,9]
Nombre de comparaisons effectuées pour trier par insertion un tableau de longueur n :
• en tout, on fait n - 1 insertions (celle de t[1], t[2] … t[n - 1]).
• pour chaque insertion de t[i ] dans t[0 : i ], on fait
- 1 comparaison dans le meilleur des cas (déjà trié):
o Est-ce que t[i ] > t[i - 1] ?
- i comparaisons dans le pire des cas (trié en sens inverse):
o Est-ce que t[i ] > t[i - 1] ?
o Est-ce que t[i ] > t[i - 2] ?
…
o Est-ce que t[i ] > t[0] ?
o Est-ce qu’on est arrivé en bout de liste ?
Total : 1 + … + 1 = n - 1 comparaisons dans le meilleur cas (liste triée).
1 + … + i + … + n-1 = < $ =
>-?@A>@
 < $ =
-
B
< C D
-
E
comparaisons dans le pire des cas
(liste triée en sens inverse).
Le tri par insertion a donc une complexité quadratique (en O(n²)), donc médiocre.
Néanmoins le tri par insertion reste un des algorithmes les plus performants lorsque la liste est
presque triée : complexité linéaire.
Ressources :
[1] T. Audibert et A. Oussalah, Informatique : Programmation et calcul scientifique en Python et Scilab. Ellipses.
[2] P. Beynet, « IPT-2 ». UPSTI.
meilleur
cas
pire
cas
comparaisons
n n²/2
affectations
n n²/2
3 2