Essalhi najlaa 2020-2021 CPGE-CASA

3.Recherche et tri dans un tableau

I. Introduction
En algorithmique, un tableau est une suite de valeurs stockées dans des cases mémoire contiguës. On
représente graphiquement, par exemple, le tableau contenant la suite de valeurs entières 3, 7, 42, 1, 4, 8,
12 de la manière suivante :

En python, un tableau est représenté par une liste (Exemple : [3,7,42,1,4,8,12]).

Dans tout ce qui suit on ne traite que des tableaux dont les les éléments sont de même type.
II. Recherche d’une valeur dans un tableau
1. Recherche séquentielle
Principe : Parcourir le tableau et faire la comparaison de chaque élément avec la valeur recherchée d’une
manière séquentielle, jusqu’à la rencontrer.
Implémentation en python

Remarques
- Dans un algorithme de recherche séquentielle on peut bien sûr renvoyer l’indice d’occurrence de
la valeur recherchée dans le tableau. Pour cela on peut remplacer la ligne 6 dans le programme précédent
par les lignes suivantes :

- En général, on remarque bien que dans un algorithme de recherche séquentielle, on peut aller
jusqu’à faire n comparaisons dans le cas où la valeur recherchée n’existe pas dans le tableau ou elle se
trouve dans la dernière position, avec n la taille du tableau qui peut être très grande ce qui rend
l’algorithme séquentiel très couteux.
2. Recherche dichotomique
Principe : La recherche d’un élément dans un tableau peut être réalisée de manière plus efficace lorsque
le tableau est trié : on coupe le tableau en deux par le milieu et on détermine si la valeur x doit être
Essalhi najlaa 2020-2021 CPGE-CASA

recherchée dans la moitié gauche ou droite. En effet, il suffit pour cela de la comparer avec la valeur
centrale. Puis, on répète le processus sur la portion sélectionnée. Autrement dit :
- On calcule m l’indice du milieu du tableau
- On compare x avec t[m] : si x =T[m], on retourne l’indice m
si x>T[m], on cherche x dans la partie droite
si x<T[m], on cherche x dans la partie gauche

t[j]<t[m] t[j]>t[m]

…. t[m]

0 m-1 m m+1 n-1

Exemple : on cherche la valeur 9 dans le tableau t suivant : [3, 5, 9, 12, 14, 17, 21, 25, 31 ]
- On cherche l’indice m= (0 + 8)/2 tel que
3 5 9 12 14 17 21 25 31
t[m] est la valeur centrale: m=4 et t[4]=14
0 1 2 3 4 5 6 7 8

- On compare 9 et 14: 9<14 donc on

3 5 9 12 14 17 21 25 31
recommence la recherche dichotomique dans le
0 1 2 3 4 5 6 7 8
sous tableau t [:4] : m= (0 + 3)/2 = 1 et
t[1]=5,
- 9>5 donc on recommence sur le sous tableau 3 5 9 12 14 17 21 25 31
t [2:4] : m= (2 + 3)/2 = 2 et t[2]=9 donc on 0 1 2 3 4 5 6 7 8

arrête la recherche et on envoie l’indice d’occurrence 2 ou « True »

Implémentation en python

Remarques
- Le tableau passé en paramètre à la fonction rech_dichotomique(x,t) doit être un tableau trié
 Essalhi najlaa 2020-2021 CPGE-CASA

III. Tri d’un tableau

Le tri d’un tableau est un problème important de l’algorithmique. En effet, plusieurs problèmes dans ce
domaine nécessitent un prétraitement des données en exécutant un algorithme de tri ce qui rend leurs
solutions faciles à concevoir et plus efficaces.
Nous présentons trois algorithmes de tri. Ils sont valables pour n’importe quel type d’éléments, pourvu
qu’il soit muni d’un ordre total.
Dans la suite du cours, On suppose qu’on trie des tableaux, dans l’ordre croissant et on note N le nombre
d’éléments à trier.
1. Tri par sélection :
Principe : Pour un tableau t de « n » éléments (numéroté de 0 à n-1), à chaque étape « i » pour i allant
de « 0 » jusqu'à « n-2 » il faut :
• Trouver (sélectionner) et mémoriser l’indice du minimum de la partie du tableau comprise entre les indices
« i» et « n-1» inclus (le sous tableau t [i : n]) ;
• Permuter le minimum trouvé avec l’élément de l’indice « i ».

Exemple : soit le tableau [8,3,4,6,1,2,5,7]

Étape 0 : 8 3 4 6 1 2 5 7
1 3 4 6 8 2 5 7
Étape 1 : 1 3 4 6 8 2 5 7
1 2 4 6 8 3 5 7
Étape 2 : 1 2 4 6 8 3 5 7
1 2 3 6 8 4 5 7
Étape 3 : 1 2 3 6 8 4 5 7
1 2 3 4 8 6 5 7
Étape 4 : 1 2 3 4 8 6 5 7
1 2 3 4 5 6 8 7
Étape 5 : 1 2 3 4 5 6 8 7
1 2 3 4 5 6 8 7
Étape 6 : 1 2 3 4 5 6 8 7
1 2 3 4 5 6 7 8
Fin : 1 2 3 4 5 6 7 8
Implémentation en python
Essalhi najlaa 2020-2021 CPGE-CASA

2. Tri par insertion

Principe : On insère successivement chaque élément du tableau dans la séquence triée formée par les
éléments du tableau d'indices strictement inférieurs. C’est souvent ce que l’on fait quand on trie un jeu de
cartes ou un paquet de copies.
En effet, pour un tableau de taille « n », à chaque étape i, avec i=1, 2, …, n-1 :
• la partie du tableau T[0 : i] est supposée déjà triée par ordre croissant ;
• on décale vers la droite les éléments de T[0 : i] tant qu'ils sont supérieurs à T[i] ;
• puis on insère l’élément T[i] dans sa bonne position.

Exemple : [8,3,4,6,1,2,5,7]
Etape1 8 3 4 6 1 2 5 7
3 8 4 6 1 2 5 7
Etape2 3 8 4 6 1 2 5 7
3 4 8 6 1 2 5 7
Etape3 3 4 8 6 1 2 5 7
3 4 6 8 1 2 5 7
Etape4 3 4 6 8 1 2 5 7
1 3 4 6 8 2 5 7
Etape5 1 3 4 6 8 2 5 7
1 2 3 4 6 8 5 7
Etape6 1 2 3 4 6 8 5 7
1 2 3 4 5 6 8 7
Etape7 1 2 3 4 5 6 8 7
1 2 3 4 5 6 7 8
Implémentation en python
Essalhi najlaa 2020-2021 CPGE-CASA

3. Tri à Bulle :
Principe : faire remonter à chaque étape le plus grand élément du tableau à trier, comme les bulles d’air
remontent à la surface de l’eau. On procède alors par des permutations répétées d’éléments contigus qui
ne sont pas dans le bon ordre.
Autrement dit : Pour chaque i de n-1 à 1
• A l’étape i, on parcourt le sous tableau [: i+1] et si deux éléments consécutifs sont en désordre, on les
échange.
• On est assuré en fin d’un passage d’avoir placé le plus grand élément du sous tableau [:i+1] à sa place
définitive d’indice i.

Exemple :
Liste : 8 3 4 6 1 2 5 7
Étape 1 : 3 8 4 6 1 2 5 7
3 4 8 6 1 2 5 7
3 4 6 8 1 2 5 7
3 4 6 1 8 2 5 7
3 4 6 1 2 8 5 7
3 4 6 1 2 5 8 7
3 4 6 1 2 5 7 8
Étape 2 : 3 4 6 1 2 5 7 8
3 4 6 1 2 5 7 8
3 4 1 6 2 5 7 8
3 4 1 2 6 5 7 8
3 4 1 2 5 6 7 8
Essalhi najlaa 2020-2021 CPGE-CASA

3 4 1 2 5 6 7 8
Étape 3 : 3 4 1 2 5 6 7 8
3 1 4 2 5 6 7 8
3 1 2 4 5 6 7 8
3 1 2 4 5 6 7 8
3 1 2 4 5 6 7 8
Étape 4: 1 3 2 4 5 6 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
Étape 5: 1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
Étape 6: 1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
Etape 7: 1 2 3 4 5 6 7 8
Fin : 1 2 3 4 5 6 7 8
Implémentation en python :