IPEIGB AU : 2023/2024

CHAPITRE VI: Manipulation des itérables en python

1. Introduction
Dans ce chapitre, nous allons manipuler des algorithmes sur deux traitements très utiles en
informatique qui sont la recherche et le tri. Nous allons les appliquer pour des itérables en
Python.
2. Les méthodes de recherche
Il y a, essentiellement, deux méthodes de recherche d’un élément dans un itérable (liste,
chaîne de caractères, …) : la recherche séquentielle et la recherche dichotomique.
2.1.Recherche séquentielle
 1ère solution
def appartient(x, L):
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
 2ème solution
def appartient(x, L):
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
 Complexité de la recherche séquentielle
On note que dans le pire des cas, les fonctions appartient et indice parcourent toute la liste
et effectuent donc n comparaisons. Il s’agit donc, d’une complexité linéaire : O(n).
2.2.Recherche dichotomique
Cette méthode s'applique si la liste est déjà trié et s'apparente alors à la technique « Diviser
pour Régner ».
Exemple :
On suppose par exemple que l’on cherche la valeur x = 9 dans la liste a= [1, 3, 5, 6, 9, 12, 14].
La recherche s’effectue ainsi :

Seules trois comparaisons ont été nécessaires pour trouver la valeur. C’est une application du
principe "diviser pour régner".
Le code est :

Sections : MP1, PC1 et T1 1

IPEIGB AU : 2023/2024

def recherche_dichotomique(x, L):

…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………
 Complexité de la recherche dichotomique
La méthode de recherche dichotomique consiste à diviser le problème en deux sous-
problèmes. Il s’agit donc, d’une complexité logarithmique : O(log(n)), où n =len(L).
3. Les méthodes de tri
Si on définit le mot tri selon le dictionnaire, on trouve qu’il s’agit de l’opération consistant à
''répartir en plusieurs classes selon certains critères un ensemble d’éléments''.
3.1.Tri par sélection
 Principe : Le principe du tri par sélection/échange (ou tri par extraction) est d'aller
chercher le plus petit élément pour le mettre en premier, puis de repartir du second
élément et d'aller chercher le plus petit élément du vecteur pour le mettre en second,
etc...Au ième passage, on sélectionne donc l'élément ayant la plus petite clé parmi les
éléments {L[i]...L[n]} et on l'échange avec L[i].

 Exemple : On se propose d’utiliser la méthode de tri par sélection pour trier une liste L
en ordre décroissant. Considérons la liste L contenant les 7 éléments suivants :
L
14 2 47 10 18 13 5
0 1 2 3 4 5 6

Etape 1
- Chercher la valeur maximale dans L (de l’élément numéro 1 à l’élément numéro 7 : cette
valeur étant 47 et son indice est 2).
- Permuter l’élément d’indice 2 avec l’élément d’indice 0.
L 47 2 14 10 18 13 5

0 1 2 3 4 5 6

Etape 2
L 47 18 14 10 2 13 5

0 1 2 3 4 5 6
Remarque :
La liste comporte une partie triée composée de deux premiers éléments et une partie non encore
triée qui comporte le reste des éléments de L.
Etape 3.
L 47 18 14 10 2 13 5

0 1 2 3 4 5 6

Partie triée Partie non triée

Sections : MP1, PC1 et T1 2

IPEIGB AU : 2023/2024

Etape 6 L 47 18 14 13 10 2 5
0 1 2 3 4 5 6
Liste triée
 Code en python : ordre décroissant
def tri_selection(L) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………

3.2. Tri à bulles

 Principe :
Le principe du tri bulle (bubble sort) est de comparer deux à deux les éléments e1 et e2
consécutifs d'une liste et d'effecteur une permutation si e1 > e2. On continue de trier
jusqu'à ce qu'il n'y ait plus de permutation.
 Exemple : On se propose d’utiliser la méthode de tri à bulles pour trier une liste L en
ordre croissant. Considérons la liste L contenant les 7 éléments suivants :

L 14 2 47 10 18 13 5
0 1 2 3 4 5 6
Soit une variable booléenne Echange qu’on initialise à faux et qui revient vrai à chaque fois que
nous réalisons une permutation. Faux
Passage 1 Echange
- On compare 14 et 2. Puisque 14>2, on permute 14 et 2 et on met vrai dans la variable
Echange.
Vrai
L 2 14 47 10 18 13 5
0 1 2 3 4 5 6 Echange
- On compare 14 et 47. Puisque 14<47, on ne fait rien.
Vrai
L 2 14 47 10 18 13 5
0 1 2 3 4 5 6 Echange

- On compare 47 et 10. Puisque 47>10, on permute 47 et 10 et on met vrai dans la variable

Echange.
Vrai
L 2 14 10 47 18 13 5
0 1 2 3 4 5 6 Echange

- On compare 47 et 18. Puisque 47>18, on permute 47 et 18 et on met vrai dans la variable

Echange.

L 2 14 10 18 47 13 5 Vrai
0 1 2 3 4 5 6
Echange

Sections : MP1, PC1 et T1 3

IPEIGB AU : 2023/2024

- On compare 47 et 13. Puisque 47>13, on permute 47 et 13 et on met vrai dans la variable

Echange.

L 2 14 10 18 13 47 5
Vrai
0 1 2 3 4 5 6 Echange
- On compare 47 et 5. Puisque 47>5, on permute 47 et 5 et on met vrai dans la variable
Echange.
Vrai
L 2 14 10 18 13 5 47
0 1 2 3 4 5 6 Echange

N.B :
Dans le passage numéro 2 on travaille sur n-1 éléments

 Code en python : ordre croissant

def tri_bulle(L) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
3.3.Tri par insertion
 Principe : Le principe du tri par insertion est d’insérer à la ième itération le ième élément à
la bonne place.
 Exemple :
On se propose d’utiliser la méthode de tri par insertion pour trier une liste L en ordre croissant.
Considérons la liste L contenant les 7 éléments suivants :
L 2 14 4 3 18 13 5
0 1 2 3 4 5 6
On commence par le deuxième élément puisque si la liste contient un seul élément, il est considéré comme
trié.
Etape 1
- On compare L[1] avec L[0] avec le souci de la garder triée.
- Puisque L[1]>L[0], donc les deux premiers éléments sont déjà en ordre.
L 2 14 4 3 18 13 5
0 1 2 3 4 5 6
Etape 2
- On compare L[2] avec L[1] avec le souci de la garder triée.
- Puisque L[2]<L[1], donc on permute L[2] par L[1]

L 2 4 14 3 18 13 5
0 1 2 3 4 5 6
On passe à l’étape 3 ……et ainsi de suite jusqu'à avoir une liste triée…..

Sections : MP1, PC1 et T1 4

IPEIGB AU : 2023/2024

 Code en python : ordre croissant

def tri_insertion(L) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
3.4.Tri par fusion
 Principe :
Le tri par fusion est une procédure récursive basée sur le principe diviser pour régner.
Partant d’une liste d’éléments à trier, on commence par diviser cette liste en deux sous-
listes, on trie les deux sous-listes puis on fusionne les sous-listes triées. Une liste à un
élément est triviale à trier et forme le cas de base de la procédure récursive.
 Exemple :
Déroulons de tri_fusion [6, 1, 2, 5, 4, 7, 3]
tri_fusion([6, 1, 2, 5, 4, 7, 3])
[6, 1, 2, 5] [4, 7, 3]
tri_fusion([6, 1, 2, 5]) tri_fusion([4, 7, 3])
[6, 1] [2,5] [4] [7, 3]
tri_fusion([6, 1]) tri_fusion([4])
[6] [1] -->[4]
tri_fusion([6]) tri_fusion([7, 3])
-->[6] [7] [3]
tri_fusion([1]) tri_fusion([7])
-->[1] -->[7]

‘’’fusion’’’ de [6] et [1] : [1, 6] tri_fusion([3])

-->[1, 6] -->[3]
tri_fusion([2, 5]) ‘’’fusion’’’ de [7] et [3] : [3, 7]
[2] [5] -->[3, 7]
tri_fusion([2]) ‘’’fusion’’’ de [4] et [3, 7] : [3, 4, 7]
-->[2] -->[3, 4, 7]
tri_fusion([5])
-->[5]
‘’’fusion’’’ de [2] et [5] : [2, 5]
-->[2, 5]
‘’’fusion’’’ de [1, 6] et [2, 5] : [1, 2,
5, 6]
-->[1, 2, 5, 6]

‘’’fusion’’’ de [1, 2, 5, 6] et [3, 4, 7] : [1, 2, 3, 4, 5, 6, 7]

-->[1, 2, 3, 4, 5, 6, 7]

Sections : MP1, PC1 et T1 5

IPEIGB AU : 2023/2024

 Code en python : ordre croissant

def fusion(L1, L2) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………

def tri_fusion(L) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………

3.5. Tri rapide (ou quicksort)

 Principe :
Le tri rapide est une procédure récursive qui consiste à considérer un élément particulier, appelé
pivot, et à placer tous les éléments plus petits que lui à sa gauche, et tous les éléments strictement
plus grands à sa droite. Le pivot est alors à sa place définitive et on recommence l’opération sur
les sous-listes gauche et droit jusqu’à arriver à des listes à trier. Le choix du pivot peut être fait
de manière aléatoire. On fera le tri en place.
 Exemple :
Tri rapide à la main de [7, 3, 6, 4, 2, 5, 1]
- Appel sur L = [7, 3, 6, 4, 2, 5, 1]
pivot = 4, L1 =[3, 2, 1], L2 = [7, 6, 5]
- Appel récursif sur L1 = [3, 2, 1]
pivot = 2, L11 =[1], L12 = [3]
L1 devient : L11 + [2] + L12 = [1, 2, 3]
- Appel récursif sur L2 = [7, 6, 5]
pivot = 6, L21 =[5], L22 = [7]
L2 devient : L21 + [6] + L22 = [5, 6, 7]
L devient : L1 + [4] + L2 = [1, 2, 3, 4, 5, 6, 7]
 Code en python : ordre croissant
import random
def tri_rapide(L) :
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………….

Sections : MP1, PC1 et T1 6

IPEIGB AU : 2023/2024

TD Chapitre VI : Manipulation des itérables en python

EXERCICE 1:
On se propose de trier, par ordre décroissant, une liste L dont ces éléments sont tous distincts,
en utilisant la méthode de tri par comptage.
Le tri par comptage se déroule en deux phases selon le principe suivant :
 1ère phase : Création d’une liste de compteurs.
Chaque élément à trier est comparé à tous les autres afin de déterminer le nombre
d’éléments qui lui sont strictement supérieurs. Les résultats des N comptages sont rangés
dans une liste de compteurs, appelée C.
 2èmephase : Utilisation de la liste de compteurs pour le tri.
Le premier élément de la liste L à trier, est permuté avec l’élément dont le compteur est
égal à 0. Les éléments correspondants dans la liste de compteurs C sont aussi permutés.
Le deuxième élément de la liste L est permuté avec l’élément dont le compteur égal à 1 et
ainsi de suite jusqu’à la fin.
Exemple :
Étape 1 : Étape finale :
Liste à trier : L=[1,-9,0,5,13,22,2,10] L=[22,-9,0,5,13,1,2,10] L=[22, 13, 10, 5, 2, 1, 0, -9]
Liste de compteurs : C=[5, 7,6,3, 1, 0, 4, 2 ] C=[0, 7,6,3, 1, 5, 4, 2 ] C=[ 0, 1, 2, 3, 4, 5, 6, 7]
Travail demandé :
1) Écrire une fonction en python, appelée COMPTAGE(L), permettant de créer et de
retourner une liste de compteurs C à partir d’une liste L dont les éléments sont tous
distincts.
2) Écrire une fonction en python, appelée TRI_COMPTAGE(L), permettant de trier par
ordre décroissant une liste L, selon le principe de tri détaillé précédemment, en utilisant la
fonction COMPTAGE(L) écrite en 1.
EXERCICE 2:
On dispose d’une liste de valeurs réelles à classer par ordre décroissant. Différents algorithmes
de classement peuvent être utilisés parmi lesquels la méthode de TRI à trois dérouleurs que nous
proposons d’écrire.
A. Explication de la méthode :
Si on représente la liste de valeurs par une liste F, le classement sera réalisé au terme
d’une série d’éclatement et de fusion de la liste F.
A-1. Eclatement
L’éclatement de la liste F en deux listes F1 et F2 de même type consiste à parcourir les
éléments de la liste F et de copier alternativement ses éléments vers la liste F1 ou bien la liste F2
en changeant de liste cible chaque fois qu’il y a une rupture de séquence dans la liste F.
Une rupture de séquence se produit, pour un classement dans l’ordre décroissant,
lorsque l’élément courant de la liste est strictement supérieur à l’élément précédent.
A-2. Fusion
La fusion des deux listes F1 et F2 dans une liste F consiste à parcourir les deux listes F1
et F2 et à recopier dans F l’élément le plus grand des deux éléments courants de F1 et F2.

Sections : MP1, PC1 et T1 7

IPEIGB AU : 2023/2024

Lorsqu’une des deux listes est épuisée, il suffit de recopier le reste de la liste non épuisé dans F.
La liste F est obtenue après fusion1 de l’exemple ci-dessous selon les étapes suivantes :
F1[0]>F2[0] donc F[0]F1[0]
F1[1]>F2[0] donc F[1]F1[1]
F1[2]<F2[0] donc F[2]F2[0]
F1[2]<F2[1] donc F[3]F2[1]
F1[2]<F2[2] donc F[4]F2[2]
La liste F2 est épuisé alors on copie les valeurs qui reste (3 Réels) de la liste F1 en partant
de l’élément d’indice 2 vers la liste F en plaçant les valeurs à partir de la position 5 (
F[5]F1[2], F[6]F1[3], F[7]F1[4]).
Exemple :
Soit la liste F = 5 3 -1 2* 50* -10 15* 7

éclatement1 F1 = 5 3 -1 50 -10
F2 = 2 15 7

fusion1 F = 5 3 2 15* 7 -1 50* -10

éclatement2 F1 = 5 3 2 50 -10
F2 = 15 7 -1

fusion2 F = 15 7 5 3 2 50* -1 -10

éclatement3 F1 = 15 7 5 3 2
F2 = 50 -1 -10

fusion3 F = 50 15 7 5 3 2 -1 -10

*
marque une rupture de séquence.
Ainsi dans ce cas, la liste F est classée au bout de trois cycles.
B. Travail demandé

1) Ecrire une fonction python, appelée SAISIE, qui permet de saisir dans N le nombre
d’éléments d’une liste (3  N  1000)
2) Ecrire une fonction python, appelée REMPLIR, qui permet de remplir la liste F par N Réels.
3) Ecrire une fonction python, appelée ECLATE, qui reçoit une liste F et qui l’éclate par la
méthode décrite en A-1 dans deux listes F1 et F2. Pour faciliter le traitement ; on pourra
utiliser une variable booléenne ECL qui prend la valeur True lorsque la liste cible est F1, la
valeur False lorsque la liste cible est F2 et qui change de valeur à chaque rupture de
séquence.
4) Ecrire une fonction python, appelée FUSION, qui reçoit deux listes F1 et F2 et qui les
fusionne dans une liste F en utilisant la méthode décrite en A-2.
5) Ecrire une fonction python, appelé CLASSEMENT qui permet de classer les éléments d’une
liste F par ordre décroissant suivant la méthode décrite en A. et ceci en utilisant les fonctions
décrites en 3) et 4).
6) Ecrire un programme principal permettant de remplir une liste F par N Réels (tel que 3  N 
1000), de classer les réels de la liste F par ordre décroissant et de les afficher dans cet ordre,
en faisant appel aux fonctions décrites précédemment.

Sections : MP1, PC1 et T1 8

IPEIGB AU : 2023/2024

EXERCICE 3:
Le tri par casiers est une méthode de tri très spéciale car elle ne s’applique qu’au tri de valeurs
entières incluses dans un ensemble qui ne comporte pas un grand nombre de valeurs. Elle ne
nécessite aucune comparaison entre les différents éléments.
Principe de la méthode
 Déterminer dans l’ensemble d’éléments stockés dans une liste L à trier, le plus petit
élément MIN et le plus grand élément MAX.
 Construire une liste C de taille MAX-MIN+1 tel que :
o C[0] contient le nombre d’apparition de la valeur MIN dans L ;
o C[1] contient le nombre d’apparition de la valeur MIN+1 dans L ;
o C[k] contient le nombre d’apparition de la valeur MIN+k dans L ;
o C[MAX-MIN] contient le nombre d’apparition de la valeur MAX dans L ;
 Construire la liste LT sous forme triée dans l’ordre croissant en stockant l’élément
MIN+k (C[k] fois) pour k allant de 0 à MAX-MIN

Pour construire la liste C, on procède comme suit :

 Initialiser tous les éléments du C à 0.
 Parcourir l’ensemble des valeurs de L à trier, et pour chaque valeur L[i], incrémenter
l’élément C[L[i]-MIN].
Exemple :
Soit la liste L d’entiers à trier suivant : L=[ 4 , 0 , 1 , 2 , 0 , 0 , 2 , 5 , 1 ]
Le plus petit élément MIN = 0 et le plus grand élément MAX = 5,

La liste C de taille MAX-MIN+1 = 6 est construit comme suit :

Remplissage progressif du C
Indice du liste C 0 1 2 3 4 5
Initialiser tous les éléments du C à 0 C=[ 0 ,0 ,0 ,0 ,0 ,0 ]
4 C=[ 0 ,0 ,0 ,0 ,1 ,0 ]
ELEMENTS

0 C=[ 1 ,0 ,0 ,0 ,1 ,0 ]
1 C=[ 1 ,1 ,0 ,0 ,1 ,0 ]
2 C=[ 1 ,1 ,1 ,0 ,1 ,0 ]
L[i]

0 C=[ 2 ,1 ,1 ,0 ,1 ,0 ]
0 C=[ 3 ,1 ,1 ,0 ,1 ,0 ]
2 C=[ 3 ,1 ,2 ,0 ,1 ,0 ]
5 C=[ 3 ,1 ,2 ,0 ,1 ,1 ]
1 C=[ 3 ,2 ,2 ,0 ,1 ,1 ]

Sections : MP1, PC1 et T1 9

 IPEIGB AU : 2023/2024

Reconstruire l’ensemble des valeurs de L afin de les trier par ordre croissant à partir du C dans
une nouvelle liste LT en stockant l’élément MIN+k C[k] fois pour k allant de 0 à MAX-MIN:
d'après la liste C on a : Remplissage progressif du LT dans l'ordre croissant
Elément 0, nombre de fois 3 LT= [ 0, 0, 0 ]
Elément 1, nombre de fois 2 LT= [ 0, 0, 0, 1, 1, ]
Elément 2, nombre de fois 2 LT= [ 0, 0, 0, 1, 1, 2, 2, ]
Elément 3, nombre de fois 0 LT= [ 0, 0, 0, 1, 1, 2, 2, ]
Elément 4, nombre de fois 1 LT= [ 0, 0, 0, 1, 1, 2, 2, 4 ]
Elément 5, nombre de fois 1 LT= [ 0, 0, 0, 1, 1, 2, 2, 4, 5 ]

Voici la liste finale triée LT=[ 0,0,0,1,1,2,2,4,5]

Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :

1) def SAISIE(msg): qui permet de saisir et de retourner dans un entier N (3  N  100) , le

nombre d’éléments de la liste L (en utilisant le bloc try...except).
2) def REMPLIR(N) : qui permet de remplir et de retourner une liste L par N entiers.
3) def CONSTRUIRE(L) : qui construit et retourne la liste C en utilisant la méthode
décrite ci-dessus.
4) def TRIER(L) : qui retourne la liste LT triée par ordre croissant en utilisant la méthode
de tri par casiers.
5) En utilisant les fonctions déjà définies, écrire le programme principal permettant de :
 Saisir N, un entier positif, non nul (3  N  100).
 Remplir une liste L de taille N par des entiers positifs, non nuls.
 Trier et afficher les entiers par ordre croissant en utilisant la méthode de tri par
casiers.

Sections : MP1, PC1 et T1 10