Chap.6 Algorithmes de Tri Et Recherche Dichotomique (Mise À Jour)

Différents types de tri
Plan
• Objectifs
• Tri par Sélection
• Tri à Bulles
• Tri par Insertion
• Recherche dichotomique
Objectifs
A la fin de ce chapitre, l'étudiant sera capable de :
• Appliquer les algorithmes de tri ( sélection, à bulles , insertion ) sur
les tableaux.
• Appliquer le principe de la recherche dichotomique pour chercher un
élément dans un tableau.

Tri par Sélection
Principe
Le tri par sélection est un algorithme de tri par comparaison.
Soit T un tableau de n entiers.
1). Pour chaque entier i ( 1 < = i <= n-1 ), on parcourt les éléments T[i] pour retenir
l'indice k du minimum (le plus petit).
2). On place au rang i le plus petit des éléments ( T[i], T[i+1] ..... T[n-1] ) en échangeant
T[i] et T[k].
Code C de l'algorithme tri par sélection
for (i=0;i<n-1;i++)
{
min=i ;
for (j=i+1;j<n;j++) // Recherche du minimum en commençant à partir de l'indice i+1
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
Exemple d'exécution
Soit le tableau T suivant composé de 5 entiers :
T n=5
2 6 5 0 3
indices 0 1 2 3 4
for (i=0;i<n-1;i++)
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
T n=5
2 6 5 0 3
indices 0 1 2 3 4
for (i=0;i<n-1;i++) 1ère itération i = 0

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 6<2?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 5<2?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 0<2?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
0<2?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3 < 0?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
Soit le tableau T suivant composé de 5 entiers : Permutation
3 < 0?
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3 < 0?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j; Le minimum est à la 1ère position
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 5 < 6?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i
for (i=0;i<n-1;i++) 2ème itération i = 1
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
5 < 6?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
2 < 5?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
2 < 5?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3 < 2?
T n=5
0 6 5 2 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3 < 2?
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min
T n=5
0 2 5 6 3
indices 0 1
i 2 3 4
for (i=0;i<n-1;i++) 3 ème itération i = 2

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 6 < 5?
T n=5
0 2 5 6 3
indices 0 1
i 2 3 4

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 3< 5?
T n=5
0 2 5 6 3
indices 0 1
i 2 3 4

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3< 5?
T n=5
0 2 5 6 3
indices 0 1
i 2 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3< 5?
T n=5
0 2 5 6 3
indices 0 1
i 2 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
3< 5?
T n=5
0 2 3 6 5
indices 0 1
i 2 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min
T n=5
0 2 3 6 5
indices 0 1 2
i 3 4

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
min 5< 6?
T n=5
0 2 3 6 5
indices 0 1 2
i 3 4

{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
5< 6?
T n=5
0 2 3 6 5
indices 0 1 2
i 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
5< 6?
T n=5
0 2 3 6 5
indices 0 1 2
i 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j;
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
5< 6?
T n=5
0 2 3 5 6
indices 0 1 2
i 3 4
min
{
min=i ;
for (j=i+1;j<n;j++)
{
if (T[j]<T[min])
min=j; Le tableau est trié par ordre croissant
}
tampon=T[i];
T[i]=T[min];
T[min]=tampon;
}
Tri à bulles
Principe
Soit T un tableau d'entiers. Le tri à bulles consiste à :
1). Comparer, deux à deux, les éléments consécutifs d'un tableau ( T[i] et T[i+1]).
2). Effectuer une permutation si T[i] > T[i+1].
3). On continue de trier jusqu'à ce qu'il n'y ait plus de permutation.

Code C de l'algorithme tri à Bulles
do
{
permut = 0; // initilement pas de permutation
for( i = 0 ; i < n-1 ; i++ )
{
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1; // on a fait une permutation
}
}
}
while (permut == 1);
T n=5
2 6 5 0 3
indices i 0 1 2 3 4
do
{ 2 > 6?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
{ 1ère itération de la boucle do .. while
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 6 5 0 3
indices i 0 1 2 3 4
do
{
permut = 0; 6 > 5?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Soit le tableau T suivant composé de 5 entiers Permutation
:
T n=5
2 6 5 0 3
indices i 0 1 2 3 4
do
{
permut = 0; 6 > 5?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Soit le tableau T suivant composé de 5 entiers Permutation
:
T n=5
2 5 6 0 3
indices i 0 1 2 3 4
do
{
permut = 0; 6 > 5?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 6 0 3
indices i 0 1 2 3 4
do
{ 6> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 6 0 3
indices i 0 1 2 3 4
do
{ 6> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 6 3
indices i 0 1 2 3 4
do
{ 6> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 6 3
indices i 0 1 2 3 4
do
{ 6> 3?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 6 3
indices i 0 1 2 3 4
do
{ 6> 3?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 3 6
indices i 0 1 2 3 4
do
{ 6> 3?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1]; Le plus grand élément se trouve à la dernière case du tableau
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 2> 5?
for( i = 0 ; i < n-1 ; i++ )
{ 2ème itération de la boucle do .. while
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 5 0 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 0?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Soit le tableau T suivant composé de 5 entiersPermutation
:
T n=5
2 5 0 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 0?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Soit le tableau T suivant composé de 5 entiersPermutation
:
T n=5
2 0 5 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 0?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 0 5 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 3?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 0 5 3 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 3?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 0 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 3?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 0 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 6?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
2 0 3 5 6
indices i 0 1 2 3 4
do
{ 2> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Exemple d'exécution Permutation
T n=5
2 0 3 5 6
indices i 0 1 2 3 4
do
{ 2> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
Exemple d'exécution Permutation
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{ 2> 0?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{ 2> 3?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 3> 5?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 6?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i];
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5> 6?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
aux = T[i]; permut = 0
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 0> 2?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 2> 3?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{ 3>5?
permut = 0;
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5>6?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
}
}
T n=5
0 2 3 5 6
indices i 0 1 2 3 4
do
{
permut = 0; 5>6?
for( i = 0 ; i < n-1 ; i++ )
if ( T [i] > T [i+1] )
{ // permutation
T[i] = T[i+1];
T[i+1] = aux ;
permut = 1;
}
Le tableau est trié par ordre croissant
}
}
Tri par insertion
Principe
Soit T un tableau d'entiers. Le tri par insertion consiste à :
1). L'élément à la position 0 est dans sa bonne place.
2). On commence à partir du second élément ( qui se trouve à la position = 1)
3). à l'étape i, on cherche la bonne position de l'élement T[i] dans le sous tableau trié de 0
à i-1.
Code C de l'algorithme tri par insertion
for (i=1;i<n;i++)
{
tmp = T[i]; // mémoriser T[i] dans une variable tmp
j = i;
// décaler vers la droite les éléments de T[0]..T[i-1] qui sont plus grands que tmp en
// partant de T[i-1]
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
T n=5
2 6 5 0 3
indices 0 1
i 2 3 4
for (i=1;i<n;i++) tmp i=1

{ 6
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
2 6 5 0 3
indices 0 1
i 2 3 4
for (i=1;i<n;i++) tmp

{ 6
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp )) while (( 1>0 ) && (2 > 6 ) ) -->
{ FAUX
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp )) while (( 2 > 0 ) && (6 > 5 ) ) --> VRAI
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
2 6 5 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 5 ;
j
T n=5
2 6 6 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 5 ;
j
T n=5
2 6 6 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp )) while (( 1 > 0 ) && (2 > 5 ) ) --> FAUX
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 5 ;
j
T n=5
2 6 6 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[1] = 5 ;
j
T n=5
2 5 6 0 3
indices 0 1 2 3 4
i
{ 5
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[1] = 5 ;
T n=5
2 5 6 0 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
2 5 6 0 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
2 5 6 0 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j=2;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 6 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j=2;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 6 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j=2;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 6 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j=2;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 6 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j=1;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp )) while (( 1 > 0 ) && (2 > 0 ) )
{
T[j] = T[j-1]; {
j--; T[1] = T[0];
} j=0;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 5 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[1] = T[0];
} j=0;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 2 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[1] = T[0];
} j=0;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 2 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[1] = T[0];
} j=0;
T[j] = tmp; }
} T[j] = 0 ;
j
T n=5
2 2 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp )) while (( 0 > 0 ) && ) --> FAUX
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[0] = 0;
j
T n=5
2 2 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[0] = 0;
j
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i
{ 0
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[0] = 0;
j
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1];
j--;
}
T[j] = tmp;
}
j
T n=5
0 2 5 6 3
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[4] = T[3];
} j = 3;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 6 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[4] = T[3];
} j = 3;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 6 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[4] = T[3];
} j = 3;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 6 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[j] = 3;
j
T n=5
0 2 5 6 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[j] = 3;
j
T n=5
0 2 5 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j= 2;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j= 2;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[3] = T[2];
} j= 2;
T[j] = tmp; }
}
T[j] = 3;
j
T n=5
0 2 5 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--;
} }
T[j] = tmp;
} T[j] = 3;
j
T n=5
0 2 3 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
{
T[j] = T[j-1]; {
j--; T[2] = T[1];
} j= 1;
T[j] = tmp;
} }
T[2] = 3;
j
T n=5
0 2 3 5 6
indices 0 1 2 3 4
i

{ 3
tmp = T[i];
j = i;
while(j > 0 && (T[j-1] > tmp ))
{
T[j] = T[j-1];
j--;
} Le tableau est trié par ordre croissant
T[j] = tmp;
}
Recherche Dichotomique
Objectif :
Chercher une valeur X dans un tableau T trié.
Principe :
1). Chercher le milieu du tableau T.
2). Comparer X avec T[milieu] :
• Si x < T[milieu] : chercher X dans la 1ère moitié du tableau ( entre (T[0] et T[milieu-1])).
• Si x > T[milieu] : chercher X dans la 2ème moitié du tableau (entre (T[milieu+1] et T[N-1])).
3). On continue le découpage jusqu’à un sous tableau de taille 1.
Code C de l'algorithme Recherche dichotomique
trouve = -1; debut = 0 ; fin = n-1 ;

while ((trouve == -1)&&(debut <= fin ))
{
milieu = (debut + fin)/2;
if (T[milieu] > X )
fin=milieu - 1;
else if (T[milieu] < X)
debut = milieu + 1;
else
trouve=1;
Exemple d'exécution X 0
T
-1 0 2 4 5 6 9 n=7
0 1 2 3 4 5
fin
debut
T
-1 0 2 43 5 6 9 n=7
0 1 2 3 4 5
fin
debut
milieu
T
-1 0 2 43 5 6 9 n=7
0 1 2 3 4 5
fin
debut
milieu
0 < 4 --> chercher dans le sous tableau commençant de l'indice 0 jusqu'à l'indice 2
T
-1 0 2 3 5 6 9 n=7
0 1 2 3 4 5
fin
debut
T
-1 00 2 3 5 6 9 n=7
0 1 2 3 4 5
fin
debut
milieu
T
-1 00 2 3 5 6 9 n=7
0 1 2 3 4 5
fin
debut
milieu
0 = milieu --> trouve = 1

Conclusion
• Dans ce chapitre, nous avons appliqué 3 variantes d'algorithmes de tri sur des tableaux unidimentionnels.
• Les algorithmes de tri que nous avons présentés sont:
 Tri par sélection
 Tri à bulles
 Tri par sélection
• La recherche d'un élément peut se faire en appliquant le principe de la recherche séqentielle.
• Elle peut se faire aussi avec le principe de la recherche dichotomique . Dans ce cas, le tableau doit être trié.

Chap.6 Algorithmes de Tri Et Recherche Dichotomique (Mise À Jour)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap.6 Algorithmes de Tri Et Recherche Dichotomique (Mise À Jour)

Transféré par

Droits d'auteur :

Formats disponibles

Différents types de tri

• Tri par Sélection

• Tri par Insertion

A la fin de ce chapitre, l'étudiant sera capable de :

• Appliquer les algorithmes de tri ( sélection, à bulles , insertion ) sur

• Appliquer le principe de la recherche dichotomique pour chercher un

élément dans un tableau.

Le tri par sélection est un algorithme de tri par comparaison.

Soit T un tableau de n entiers.

for (i=0;i<n-1;i++) 1ère itération i = 0

for (i=0;i<n-1;i++) 3 ème itération i = 2

for (i=0;i<n-1;i++) 3 ème itération i = 2

for (i=0;i<n-1;i++) 3 ème itération i = 2

for (i=0;i<n-1;i++) 4 ème itération i = 3

for (i=0;i<n-1;i++) 4 ème itération i = 3

Soit T un tableau d'entiers. Le tri à bulles consiste à :

2). Effectuer une permutation si T[i] > T[i+1].

3). On continue de trier jusqu'à ce qu'il n'y ait plus de permutation.

Soit T un tableau d'entiers. Le tri par insertion consiste à :

1). L'élément à la position 0 est dans sa bonne place.

2). On commence à partir du second élément ( qui se trouve à la position = 1)

for (i=1;i<n;i++) tmp i=1

for (i=1;i<n;i++) tmp

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=4

for (i=1;i<n;i++) tmp i=5

Chercher une valeur X dans un tableau T trié.

trouve = -1; debut = 0 ; fin = n-1 ;

0 = milieu --> trouve = 1

• Les algorithmes de tri que nous avons présentés sont:

 Tri par sélection

 Tri par sélection

• La recherche d'un élément peut se faire en appliquant le principe de la recherche séqentielle.

Vous aimerez peut-être aussi