Recherche et tri dans un tableau

Les algorithmes de recherche et de tri dans un tableau

I. Recherche dans un tableau :

Il existe deux façons pour chercher un élément dans un tableau :

- La recherche séquentielle : appelée aussi (recherche linéaire ou recherche par

balayage) est un algorithme pour trouver une valeur dans une liste. Elle consiste
simplement à parcourir les éléments du tableau les uns après les autres, jusqu'à ce que
l'élément soit trouvé, ou que toutes les cases aient été lues. Elle est aussi appelée.

- La recherche dichotomique : La recherche dichotomique, ou recherche par

dichotomie, est un algorithme de recherche pour trouver la position d'un élément dans
un tableau trié.

a. La recherche séquentielle :

Ecrire un algorithme (puis sa traduction en C) qui recherche dans un tableau A une valeur VAL
entrée au clavier. Afficher la position de VAL si elle se trouve dans le tableau, sinon afficher
un message correspondant. La valeur POS qui est utilisée pour mémoriser la position de la
valeur dans le tableau, aura la valeur -1 aussi longtemps que VAL n’a pas été trouvée.

Solution Algorithmique :

Algorithme Recherche_Seq_Tab
Constantes
Dim = 100
Types
Tab : tableau[1..Dim] d'entiers
Variables
A : Tab
i, n, val,pos : Entier
Début
Répéter
Ecrire ("Donner le nombre d'éléments : ")
Lire(n)
Jusqu'à (n>=1 ET n<=Dim)
Ecrire ("Remplissage du tableau A : ")
Pour i de 1 à n faire
Ecrire ("A[",i,"]= ")
Lire(A[i])
FinPour
Ecrire (" Valeur à chercher : ")
Lire (val)
Ecrire ("Tableau Donné A : ")
Pour i de 1 à n faire
Ecrire (A[i]," ")
FinPour
i1

Réalisé par : Bassem Boughzala (ISET RADES) Page 1/11

Recherche et tri dans un tableau

pos  -1
TantQue (i<=n ET pos = -1) faire
Si A[i] = val alors
Pos  i
FinSi
i  i +1
FinTantQue
Si pos = -1 alors
Ecrire (" La valeur recherchée ne se trouve pas dans le tableau. ")
Sinon
Ecrire ("La valeur ",val," se trouve à la position ", pos)
Finsi
Fin

Solution en C :

#include <stdio.h>
#include <stdlib.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
int N; /* dimension */
int I; /* indice courant */

/* Saisie des données */

do
{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}
while(N<1 || N>50);
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", &A[I]);
}
printf("Elément à rechercher : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donné : \n");
for (I=0; I<N; I++)
printf("%d\t ", A[I]);
printf("\n");
/* Recherche de la position de la valeur */
POS = -1;
for (I=0 ; (I<N)&&(POS==-1) ; I++)
if (A[I]==VAL)

Réalisé par : Bassem Boughzala (ISET RADES) Page 2/11

Recherche et tri dans un tableau

POS=I;
/* Edition du résultat */
if (POS==-1)
printf("La valeur recherchée ne se trouve pas dans le tableau.\n");
else
printf("La valeur %d se trouve à la position %d. \n",
VAL, POS);
system("pause");
}

b. La recherche dichotomique :

Principe de la recherche dichotomique :

- Comparer le nombre recherché à la valeur au milieu du tableau.
- S’il y’a égalité ou si le tableau est épuisé, arrêter le traitement avec un message
correspondant.
- Si la valeur recherchée précède la valeur actuelle du tableau, continuer la recherche
dans le demi tableau à gauche de la position actuelle.
- Si la valeur recherchée suit la valeur actuelle du tableau, continuer la recherche dans le
demi tableau à droite de la position actuelle.

Remarque : le tableau doit être trié.

Ecrire un algorithme (puis sa traduction en C) qui permet de chercher une valeur dans un
tableau en utilisant la recherche dichotomique.

Solution algorithmique :

Algorithme Recherche_dicho_Tab
Constantes
Dim = 100
Types
Tab : tableau[1..Dim] d'entiers
Variables
A : Tab

Réalisé par : Bassem Boughzala (ISET RADES) Page 3/11

Recherche et tri dans un tableau

i, n, val, pos, inf, mil, sup : Entier

Début
Répéter
Ecrire ("Donner le nombre d'éléments : ")
Lire(n)
Jusqu'à (n>=1 ET n<=Dim)
Ecrire ("Remplissage du tableau A : ")
Pour i de 1 à n faire
Ecrire ("A[",i,"]= ")
Lire(A[i])
FinPour
Ecrire (" Valeur à chercher : ")
Lire (val)
Ecrire ("Tableau Donné A : ")
Pour i de 1 à n faire
Ecrire (A[i]," ")
FinPour
inf  1
sup  n
pos  -1
TantQue (inf<=sup ET pos = -1) faire
mil  (inf + sup)/2
Si val <A[mil] alors
sup  mil -1
Sinon
Si val >A[mil] alors
inf  mil +1
Sinon
Pos  mil
FinSi
FinSi
FinTantQue
Si pos = -1 alors
Ecrire (" La valeur recherchée ne se trouve pas dans le tableau. ")
Sinon
Ecrire ("La valeur ",val," se trouve à la position ", pos)
Finsi
Fin

Solution en C :

#include <stdio.h>
#include <stdlib.h>
void main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
int N; /* dimension */

Réalisé par : Bassem Boughzala (ISET RADES) Page 4/11

Recherche et tri dans un tableau

int I; /* indice courant */

int INF, MIL, SUP; /* limites du champ de recherche */

/* Saisie des données */

do
{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}
while(N<1 || N>50);
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", &A[I]);
}
printf("Elément à rechercher : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donné : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Initialisation des limites du domaine de recherche */
INF=0;
SUP=N-1;
/* Recherche de la position de la valeur */
POS=-1;
while ((INF<=SUP) && (POS==-1))
{
MIL=(SUP+INF)/2;
if (VAL < A[MIL])
SUP=MIL-1;
else if (VAL > A[MIL])
INF=MIL+1;
else
POS=MIL;
}

/* Edition du résultat */
if (POS==-1)
printf("La valeur recherchée ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve à la position %d. \n",
VAL, POS);
system("pause");
}

Réalisé par : Bassem Boughzala (ISET RADES) Page 5/11

Recherche et tri dans un tableau

II. Les algorithms de tri :

Il existe plusieurs méthodes de tri parmi lesquelles on peut citer :
- tri par sélection
- tri à bulle
- tri par insertion
- tri par fusion
- tri shell
- tri rapide (quick sort).
- Etc.

a. Tri par sélection :

1. Principe : le tri par sélection (ou tri par extraction) est un algorithme de tri très efficace
sur des petites entrées (quelques valeurs). Son principe est le suivant :

- Chercher l’indice du plus petit élément du tableau T[1..N] et permuter l’élément

correspondant avec l’élément d’indice 1.
- Chercher l’indice du plus petit élément du tableau T[2..N] et permuter l’élément
correspondant avec l’élément d’indice 2.
- …
- Chercher l’indice du plus petit élément du tableau T[N-1..N] et permuter l’élément
correspondant avec l’élément d’indice (N-1).

2. Trace de l’exécution :
Indice : 1 2 3 4 5 6
Tableau initial 6 4 2 1 5 3

Après la 1ère itération 1 4 2 6 5 3

Après la 2ème itération 1 2 4 6 5 3

Après la 3ème itération 1 2 3 6 5 4

Après la 4ème itération 1 2 3 4 5 6

Après la 5ème itération 1 2 3 4 5 6

3. Algorithme :

Algorithme Tri_Par_Selection
Constantes
Taille = …
Types
Tab = Tableau[1..Taille] de Type_Eléments
Variables
T : Tab
I, J, POS, N : entier

Réalisé par : Bassem Boughzala (ISET RADES) Page 6/11

Recherche et tri dans un tableau

Temp : Type_Eléments
Début
Répéter
Ecrire("Donner la valeur de N : ");
Lire (N)
Jusqu'à (N>=1 ET N<=Taille)
(************* Remplissage du tableau *****************)
Pour I de 1 à N faire
Ecrire("T[",I,"] = ",I);
Lire (T[I])
FinPour
(************Tri par sélection du minimum **************)
Pour I de 1 à N-1 faire
POS  I
Pour J de I+1 à N faire
Si T[J] < T[POS] alors
POS  J
FinSi
FinPour
Temp  T[I]
T[I]  T[POS]
T[POS]  Temp
FinPour
(******** affichage des éléments du tableau après le tri *******)
Pour I de 1 à N faire
Ecrire(T[I]," ");
FinPour
Fin

4. Traduction en C :

#include<stdio.h>
#include<stdlib.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int N; /* dimension */
int I; /* rang à partir duquel A n'est pas trié */
int J; /* indice courant */
int AIDE; /* pour la permutation */
int PMIN; /* indique la position de l'élément */
/* minimal à droite de A[I] */

/* Saisie des données */

do
{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}

Réalisé par : Bassem Boughzala (ISET RADES) Page 7/11

Recherche et tri dans un tableau

while((N<1)||(N>50));
for (J=0; J<N; J++)
{
printf("Elément %d : ", J);
scanf("%d", &A[J]);
}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (J=0; J<N; J++)
printf("%d ", A[J]);
printf("\n");

/* Tri du tableau par sélection directe du minimum. */

for (I=0; I<N-1; I++)
{
/* Recherche du minimum à droite de A[I] */
PMIN=I;
for (J=I+1; J<N; J++)
if (A[J]<A[PMIN]) PMIN=J;
/* Echange de A[I] avec le maximum */
AIDE=A[I];
A[I]=A[PMIN];
A[PMIN]=AIDE;
}

/* Edition du résultat */
printf("Tableau trié :\n");
for (J=0; J<N; J++)
printf("%d ", A[J]);
printf("\n");
system("pause");
}

b. Tri à Bulles :

1. Principe : appelé aussi (tri par propagation) est un algorithme de tri qui consiste à faire
remonter progressivement les plus grands éléments d'un tableau, comme les bulles d'air
qui remontent à la surface d'un liquide. La méthode de tri à bulles consiste à répéter le
traitement suivant :
- Parcourir les éléments du tableau de 1 à (N-1). Si l'élément i est supérieur à
l'élément (i+1) alors on les permute.
- Le programme s'arrête lorsqu'aucune permutation n'est réalisable après un
parcours complet du tableau.

2. Trace d'exécution :
Indice : 1 2 3 4 5 6
Tableau Initial 6 4 2 1 5 3

1ère itération 4 6 2 1 5 3

Réalisé par : Bassem Boughzala (ISET RADES) Page 8/11

Recherche et tri dans un tableau

1ère itération 4 2 6 1 5 3
1ère itération 4 2 1 6 5 3

1ère itération 4 2 1 5 6 3

1ère itération 4 2 1 5 3 6

2ème itération 2 4 1 5 3 6

2ème itération 2 1 4 5 3 6

2ème itération 2 1 4 3 5 6

3ème itération 1 2 4 3 5 6

3ème itération 1 2 3 4 5 6

4ème itération 1 2 3 4 5 6

3. Algorithme :
Algorithme Tri_à_Bulles
Constantes
Taille = …
Types
Tab = Tableau[1..Taille] de Type_Eléments
Variables
T : Tab
I, N : entier
Temp : Type_Eléments
Echange : booléen
Début
Répéter
Ecrire("Donner la valeur de N : ");
Lire (N)
Jusqu'à (N>=1 ET N<=Taille)
(************* Remplissage du tableau *****************)
Pour I de 1 à N faire
Ecrire("T[",I,"] = ",I);
Lire (T[I])
FinPour
(**************** Tri à Bulles ***********************)
Répéter
Echange  Faux
Pour I de 1 à N-1 faire
Si T[I] > T[I+1] alors
Temp  T[I]
T[I]  T[I+1]
T[I+1]  Temp
Echange  Vrai

Réalisé par : Bassem Boughzala (ISET RADES) Page 9/11

Recherche et tri dans un tableau

FinSi
FinPour
Jusqu'à Echange = Faux
(******** affichage des éléments du tableau après le tri *******)
Pour I de 1 à N faire
Ecrire(T[I]," ");
FinPour
Fin

4. Traduction en C :

#include<stdio.h>
#include<stdlib.h>
main()
{
int A[50]; /* tableau donné */
int N; /* dimension */
int I; /* rang à partir duquel A n'est pas trié */
int echange; /* variable booléenne */
int AIDE; /* pour la permutation */
do
{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}
while((N<1)||(N>50));
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", &A[I]);
}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Tri du tableau par propagation du maximum à la fin du tableau. */
do {
echange = 0;
for (I=0; I<N-1; I++)
{
if(A[I]>A[I+1])
{
AIDE=A[I];
A[I]=A[I+1];
A[I+1]=AIDE;
echange = 1;
}
}
}

Réalisé par : Bassem Boughzala (ISET RADES) Page 10/11

Recherche et tri dans un tableau

while (echange ==1);

/* Edition du résultat */
printf("Tableau trié :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
system("pause");
}

Réalisé par : Bassem Boughzala (ISET RADES) Page 11/11