Cours d`informatique PC

Chapitre 1
Algorithmes de tri élémentaires
Le tri de données constitue un des problèmes fondamentaux de l’algorithmique. On considère une liste
de données, auxquelles sont attachées des clés. On cherche à trier ces données en fonction des clés (par
exemple, trier une liste d’élèves par ordre alphabétique, ou par ordre de moyennes...).
Nous nous placerons pour simplifier dans le cas où la clé est la donnée elle-même.
1.1 Tri par sélection
1.1.1 Principe du tri par sélection
Considérons une liste `de longueur n. Supposons que la plage `[0..i[
– soit triée
– contienne les iplus petits éléments de la liste
(on initialise avec i= 0).
On sélectionne, dans la plage `[i..n[, le plus petit élément, que l’on permute avec `i
`0`i−1`i`∗`n−1
· · · · · · · · ·
permutation
partie triée
Figure 1.1 – Tri par sélection : les ipremiers éléments sont déjà placés
1.1.2 Programmation
Commençons par écrire une fonction qui détermine l’indice du plus petit élément d’une liste entre les
positions iet j:
1def ch er ch e_ ind _m in (l ,i , j ):
2""" re nvoie l ’ indice du plus petit é lé ment de la plage l[i .. j [ """
3imin = i
4for kin range ( i +1 , j ):
5if l[ k] < l[ imin ]:
6imin = k
7return( imin )
Nous pouvons maintenant écrire la fonction de tri :
1def tr i_ se le cti on ( l ):
2""" trie la liste l par l ’ algorithm e du tri sé lection .
3La fonctio n modifie la liste l et ne renvoie rien """
1

2Chapitre 1. Algorithmes de tri élémentaires
4n = len(l)
5for iin range (n -1):
6imin = c her ch e_ in d_m in (l ,i , n )
7l[i ], l[ imin ] = l[ imin ], l [i]
Rappelons que, lors de l’écriture d’un algorithme, on doit être en mesure du justifier sa terminaison
et sa correction.
La terminaison est ici évidente car on utilise une boucle inconditionnelle (boucle for), qui se termine
toujours (contrairement au cas d’une boucle while).
Pour justifier la correction de l’algorithme (il fait bien ce pour quoi il a été conçu), démontrons que
la propriété suivante est vraie :
«À l’issue du passage d’indice idans la boucle, la plage `[0..i + 1[ est triée et elle contient les i+ 1
plus petits éléments.»
– Lors du premier passage dans la boucle, on identifie le plus petit élément du tableau, que l’on place
en tête (par permutation de deux éléments). À l’issue de ce passage d’indice i= 0, la plage `[0..1[
est triée (elle contient un unique élément) et elle contient les i+ 1 = 1 plus petits éléments.
– Supposons que la propriété soit vraie après le passage d’indice i. Lors du passage d’indice i+ 1, on
détermine le plus petit élément de la plage `[i+ 1..n[(qui est par hypothèse supérieur à tous les `k
pour k6i), que l’on échange avec celui d’indice i+1. À l’issue de ce passage d’indice i+ 1, la plage
`[0..i + 2[ est encore triée et elle contient les i+ 2 plus petits éléments.
Par récurrence finie, la propriété est encore vérifiée après le dernier passage, i.e. celui d’indice i=n−2.
À l’issue de ce passage, la plage `[0..n −1[ est donc triée, et elle contient les n−1plus petits éléments de
la liste. Par suite, le dernier élément `n−1est supérieur à tous les précédents, donc la totalité de la liste
est triée.
Remarque 1. Une telle propriété (que nous avons démontrée par récurrence) est appelée un invariant de
boucle. C’est en général en exhibant un tel invariant que l’on prouve la correction des algorithmes.
1.1.3 Stabilité
Lorsque les données à trier sont distinctes des clés utilisées pour trier la liste (par exemple, un élève
n’est pas égal à sa moyenne), on peut s’intéresser à ce qui arrive à deux éléments ayant la même clé (deux
élèves ayant la même moyenne) : après le tri, ces deux éléments sont-ils dans la même position relative
l’un par rapport à l’autre qu’avant le tri ? Lorsque c’est le cas, on dit que le tri est stable.
La stabilité d’un tri est un élément intéressant lorsque l’on veut trier des données suivant un critère
prioritaire, puis un critère secondaire. Par exemple, si les données sont des couples (nom, prénom), on
peut chercher à trier par nom (critère prioritaire) puis, en cas d’égalité des noms, par prénom (critère
secondaire). Si l’on dispose d’un tri stable, on peut réaliser ce tri de la façon suivante :
– commencer par trier selon le critère secondaire ;
– trier ensuite selon le critère prioritaire.
Les données seront alors triées selon le critère prioritaire. En cas d’égalité des clés associées (le nom dans
notre exemple), les données seront rangées, après ce second tri, dans le même ordre qu’après le premier
tri, i.e. classées selon le critère secondaire (le prénom).
Le tri par sélection n’est pas stable : par exemple, si les données sont A,Bet C, et que les clés attachées
sont 1,1et 0(ce que l’on notera pas A1,B1,C0), le tri par sélection transforme la liste [A1, B1, C0]en
[C0, B1, A1](les éléments Aet B, de même clé, ont été permutés).
1.1.4 Complexité
Lorsque l’on cherche à évaluer la complexité d’un algorithme, on distingue en général la complexité
– spatiale (l’espace mémoire qui est nécessaire pour exécuter l’algorithme) ;
– temporelle (le temps nécessaire à son exécution).
Nous n’étudierons ici que la complexité temporelle des algorithmes.
Il est évidemment impossible de dire quelle durée prendra l’exécution d’un algorithme : cela dépend en
particulier de la vitesse de la machine sur lequel il est exécuté. Pour évaluer cette complexité temporelle,
nous chercherons à compter le nombre d’opérations élémentaires effectuées par l’algorithme. Ceci est en
général impossible à faire de façon exacte, aussi simplifions-nous le problème en choisissant de compter
uniquement les opérations «significatives». On cherche par ailleurs à obtenir une estimation asymptotique

1.2. Tri par insertion 3
de ce nombre plutôt qu’un décompte exact. Ainsi, on parlera d’algorithme linéaire (resp. quadratique,
exponentiel) lorsque le nombre de ces opérations significatives varie linéairement (resp. comme le carré,
l’exponentielle) de la taille nde la donnée à traiter.
Dans le cas du tri, on évalue la complexité d’un algorithme en comptant le nombre de comparaisons
effectuées entre les éléments de la liste.
– La fonction cherche_ind_min, appelée avec les arguments iet j, effectue j−i−1comparaisons.
Appelée avec les arguments iet n, elle en effectue n−i−1.
– Chaque passage dans la boucle indexée par ide la fonction tri_selection effectue donc n−i−1
comparaisons. Comme ivarie de 0àn−2, il y a au total
C(n) =
n−2
X
i=0
(n−i−1) =
n−1
X
k=1
k=n(n−1)
2comparaisons.
Nous avons donc démontré le
Théorème
La complexité du tri par sélection est quadratique :
C(n) = O(n2).
Un tel algorithme est en général considéré comme peu efficace. Si la taille de la liste est multipliée pas
deux, le temps nécessaire à son tri est lui multiplié par quatre. De plus, si la liste est déjà triée (ce que
l’on peut tester par un simple parcours de liste, qui ne nécessite que n−1comparaisons), il n’y a rien de
plus à faire, alors que le coût de cet algorithme est quand même, dans ce cas particulier, quadratique.
Remarque 1. Même si la complexité quadratique est considérée comme mauvaise, il existe des problèmes
pour lesquels il n’existe pas d’algorithme performant. Par exemple, pour un algorithme de complexité
équivalente à 2n(complexité exponentielle), multiplier la taille des données pas 2 revient à élever aux
carré le nombre d’opérations à effectuer ! De tels algorithmes sont totalement inefficaces, sauf pour de
très petites valeurs de n(le temps de calcul nécessaire à traiter un problème dépasse rapidement l’âge de
l’univers...). En ce qui concerne le tri, nous verrons d’autres algorithmes plus performants que celui du
tri par sélection.
1.2 Tri par insertion
1.2.1 Principe du tri par insertion
C’est le tri du joueur de cartes qui reçoit ses cartes une à une. Le premier élément constitue une liste
triée à lui tout seul. On compare ensuite le deuxième élément au premier pour savoir si on l’insère avant
ou après le premier. À la kème itération, on insère le k+ 1ème élément dans la liste, déjà triée, des k
premiers éléments.
`0`i−1`i`k−1`k`n−1
Figure 1.2 – Tri par insertion : insérer `kà sa place et décaler les éléments
1.2.2 Programmation
1def tr i_ in se rti on ( l ):
2""" trie la liste l par l ’ algorithm e du tri insertion .

4Chapitre 1. Algorithmes de tri élémentaires
3La fonctio n modifie la liste l et ne renvoie rien """
4n = len(l)
5for kin range (1 , n ):
6a_placer = l[k ]
7i = k -1
8while i >= 0 and a _pl ace r < l [i ]:
9l[i +1] = l [i ]
10 i = i - 1
11 l[i +1] = a _place r
Terminaison du programme :
– la boucle for se termine ;
– la boucle while aussi : même si on ne trouve aucun indice itel que `isoit strictement supérieur
à l’élément à placer, idiminue strictement à chaque étape donc finira par devenir négatif, ce qui
terminera la boucle. Remarquons d’ailleurs que l’ordre dans lequel les conditions sont écrites n’est
pas anodin : on vérifie d’abord que i>0,puis on lit l’élément dans la case d’indice i(si on faisait le
contraire, on risquerait de tenter de lire le contenu de la case d’indice −1, ce qui provoquerait une
erreur).
Démontrons maintenant la correction, en démontrant que la propriété «après le passage d’indice k
dans la boucle for, la sous-liste `[0..k + 1[ est triée».
– C’est vrai avant le premier passage (ce qui correspond à «après le passage d’indice k= 0) car la
liste `[0..1[ comporte un seul élément donc est triée.
– Supposons la propriété vraie après le passage d’indice k−1et vérifions qu’elle l’est encore après le
passage d’indice k. Pour cela, il faut vérifier que notre mécanisme d’insertion fonctionne bien. Il est basé
sur une boucle while, qui a deux causes possibles d’arrêt :
– soit on trouve un indice i>0tel que a_placer < `i. À cet instant, l’élément en position k−1a été
reculé à la position k, . . . et l’élément en position i+ 1 a été reculé en position i+ 2. La position
i+ 1 est donc libre, et c’est celle dans laquelle il faut insérer l’élément.
– soit on n’a trouvé aucun tel élément et on s’arrête parce que i=−1. Lors du passage précédent
dans la boucle, l’élément situé en position 0 a été reculé en position 1 ; il faut insérer l’élément en
position 0.
Dans tous les cas, en sortie de la boucle while, c’est bien en position i+ 1 qu’il faut insérer l’élément. À
l’issue du passage d’indice k, la propriété est encore vraie.
Par récurrence, elle l’est encore à l’issue du passage d’indice n−1: la liste est alors triée.
Remarque 1. À la différence du tri par sélection, le tri par insertion est stable : un élément de clé cne
peut passer devant un autre élément que si cet autre est de clé c0> c. Deux éléments de même clé ne
sont jamais permutés.
1.2.3 Complexité
À la différence du tri par sélection, la complexité n’est pas la même pour toutes les listes de taille n.
Nous allons étudier la complexité Cmin(n)dans le meilleur des cas et la complexité Cmax(n)dans le pire
des cas (toujours en nous intéressant au nombre de comparaisons effectuées entre éléments du tableau).
Dans le meilleur des cas, chaque élément `k(k>1) est comparé à son prédécesseur et reste à sa place
car `k>`k−1. Ce cas se produit lorsque le tableau est déjà trié ; la complexité est alors linéaire :
Cmin(n) = n−1.
Dans le pire des cas, chaque élément `k(k>1) est comparé à ses kprédécesseurs et est finalement
inséré en tête de liste. Ce cas se produit lorsque la liste est initialement triée à l’envers. La complexité
est alors quadratique :
Cmax(n) =
n−1
X
k=1
k=n(n−1)
2.
Retenons :

1.3. Complexité minimale d’un algorithme de tri 5
Théorème
Les complexités du tri par insertion sont, dans le meilleur et dans le pire des cas :
Cmin(n) = O(n)(linéaire) et Cmax (n) = O(n2)(quadratique).
1.3 Complexité minimale d’un algorithme de tri
Remarque 1. Ce dernier paragraphe n’est pas à votre programme ; il est inséré à titre d’information.
Les deux algorithmes de tri que nous avons étudiés ont une complexité Cmax(n)en O(n2). Peut-on faire
mieux ? Oui : nous étudierons dans le prochain chapitre un algorithme dont la complexité maximale vérifie
Cmax(n)∈O(nlog n). Cet algorithme est optimal au sens suivant :
Théorème
Un algorithme de tri procédant par comparaisons entre les clés des éléments à trier a, au mieux, une
complexité Cmax(n)∈O(nlog n).
La preuve utilise la notion d’arbre de décision.
1.3.1 Arbres binaires
Un arbre binaire est un ensemble de nœuds, organisés de la façon suivante :
– un nœud et un seul n’est pointé par aucune flèche : c’est la racine de l’arbre ;
– de certains nœuds (appelés nœuds internes) partent une flèche gauche et une flèche droite, pointant
chacune sur un nœud (ce sont les fils du nœud interne) ;
– des autres nœuds (appelés feuilles) ne part aucune flèche.
Cette structure est utilisée pour représenter des données. Elle contient de l’information, stockée dans
les feuilles et les nœuds internes (ce sont les étiquettes de l’arbre) et dans les flèches (ce sont les labels de
l’arbre).
Exemple 1. Voici un exemple d’arbre binaire.
A
B
1
C
D
3
E
4
2
Figure 1.3 – Un exemple d’arbre binaire
Cet arbre est formé de deux nœuds internes, étiquetés Aet C, et de trois feuilles (étiquetées B,D
et E). Le nœud Aest la racine de l’arbre ; le sous-arbre pointé par la flèche de label 1est le fils gauche
du nœud A; le sous-arbre pointé par la flèche de label 2est son fils droit. Ces deux sous-arbres ont pour
père le nœud A.
La hauteur d’un arbre est la longueur (i.e. nombre de flèches) maximale d’un chemin allant de la
racine à une feuille.
Exemple 2. L’arbre représenté sur la figure 1a une hauteur égale à 2.
Remarque 1. Un arbre de hauteur na donc au moins n+ 1 feuilles (cas où chaque fils gauche est une
feuille par exemple) et au plus 2nfeuilles (cas où tous les nœuds, sauf ceux du « bas », ont 2 fils).