Module : Algorithmique avancé et

complexité

TP N°2 : La recherche d’élément

Binôme :
Aberkane Nazim
Matricule : 202031043786
Izerrouken Tarek
Matricule : 202031080904

Master 1 RSD 2023/2024

 TP N°2 : La recherche d’élément

Objectif du TP : ce TP vise à expérimenter, analyser et comparer les

performances des algorithmes de recherche d'éléments, ainsi que des techniques
pour trouver le maximum et le minimum dans des tableaux de grande dimension
tout en comparant leur performance en se basant sur la complexité
A. Recherche d’un élément
1. Soit un tableau de n (n>=2) valeurs entières non triées :
a. Écrire une fonction rechElets_TabNonTriés permettant de vérifier
l’existence d’une valeur x donnée :
Def rechElets_TabNonTriés(tableau,x) :

Pour i1 a n : //1u

Si (T[i] == x) alors : //1u
Ecrire(‘ la valeur de’ , x ,’existe au tableau au indice’, i) ; //1u
Sinon :
Ecrire (‘la valeur de’ , x , ‘ n existe pas dans ce tableau’) ;//1u
Fsi ; //2u
Finpour ; //n*[2+1]+1

Algorithme existence
Variable Tableau[n] : du taille n d’entier
i,n,x: entier

Debut
Pour i1 a n faire :
Lire(T[i]) ;
Finpour //2*n

Ecrire(‘veuillez saisir la valeur de l’element recherché’) ; //1u

Lire(x) ; //1u
rechElets_TabNonTriés(Tableau,x) ; //3*n+1

FIN
b. Calculer la complexité théorique au meilleur cas et au pire cas :
Complexité au meilleur cas : Le meilleur cas se produit lorsque l'élément
recherché est situé au début du tableau ou est l'élément actuel que nous
vérifionsen premier. Dans ce scénario, l'algorithme nécessitera un minimum
d'itérations pour trouver l'élément. Dans ce cas, la complexité temporelle serait
O(1), car nous allons trouver cet élément dès le premier test sans parcourir tout
le tableau.
Complexité au pire cas : Le pire cas se produit lorsque l'élément recherché est
soit à la fin du tableau, soit qu'il n'existe pas du tout dans le tableau. Dans ce cas,
l'algorithme devra parcourir tous les éléments du tableau pour confirmer
l'absence de l'élément recherché. La complexité temporelle serait de O(n) (où
"n" est la taille du tableau). Ainsi, on trouve O(n)=5*n+3
Voici le programme correspendant écrit en Python
2. Soit un tableau de n (n>=2) valeurs entières triées :
2.1 recherche sequentielle
a.Écrire une fonction rechElets_TabTriés permettant de vérifier l’existence
d’une valeur x donnée.
Def rechElets_TabTriés(tableau,x) :

Si (T[n]<x) alors : //1u

Ecrire(‘’la valeur recherchée n’existe pas dans ce tableau’’) ; //1u
Sinon :
Pour i1 a n : //1u
Si (T[i] == x) //1u alors :
Ecrire(‘ la valeur de’ , x ,’existe au tableau au indice’, i) ; //1u
Sinon :
Ecrire (‘la valeur de’ , x , ‘ n existe pas dans ce tableau’) ; //1u
Fsi ; //2u
Finpour ; n*[1+2]u
Fsi ; //1+3n u

Algorithme existence

Variable Tableau[n] : du taille n d’entier

i,n,x: entier

Debut

Pour i1 a n faire :

Lire(Tableau[i]) ;
Finpour ; //2n u

Ecrire(‘veuillez saisir la valeur de l’element recherché’) ; //1u

Lire(x) ; //1u
rechElets_TabTriés(tableau,x) ; //3n+1

FIN

b. Calculer la complexité théorique au meilleur cas et au pire cas.

Complexité au meilleur cas : La complexité dans le meilleur cas est O(1), si
l'élément recherché se trouve à l'indice 0 du tableau
Complexité au pire cas : nous avons ajouté un teste cest lorsque l’element
recherché est superieur a la valeur de l’indice de la taille de tableau car si elle est
superieur a la derniere valeur donc cet element n’existe pas dans ce tableau donc
on doit pas parcourir tout le tableau , sinon si element recherche < T[n] dans ce
cas on doit parcourir entierement le tableau donc la complexité sera de O(n).

Voici le programme correspendant en Python :

2.2 Recherche Dichotomique :

a. Écrire une fonction rechElets_Dicho permettant de vérifier l’existence
d’une valeur x donnée en utilisant la méthode dichotomique.
 def rechElets_Dicho(tableau, x):

debut = 0
fin = length(tableau) - 1
tant que debut < fin :
milieu = (debut + fin) // 2
Si tableau[milieu] == x:
Return vrai
Sinon :
Si tableau[milieu] > x:
fin = milieu - 1
Sinon
gauche = milieu + 1
return False
Pour i1 a n faire :
Lire(T[i]) ;
Finpour

Ecrire(‘veuillez saisir la valeur de l’element recherché’) ;

Lire(valeur_recherchee) ;

Si rechElets_Dicho(tableau_trie, valeur_recherchee):
ecirre("La valeur",valeur_recherchee, a été trouvée dans le tableau.")
Sinon :
Ecrire("La valeur ,valeur_recherchee, n a pas été trouvée dans le tableau.")
Fsi ;
FIN

b. Calculer la complexité théorique au meilleur cas. La complexité au pire

cas est de l’ordre de O(log(n))
Meilleur cas : Le meilleur cas se produit lorsque l'élément recherché est
exactement au milieu du tableau. Dans ce cas,l'algorithme trouve
immédiatement l'élément recherché après une seule comparaison. La complexité
temporelle est O(1), ce qui signifie qu'elle trouve l'élément en une seule étape.
Pire cas : . La complexité au pire cas est de l’ordre de O(log(n))
 Voici le programme correspendant écrit en Python :

3. Remplir le tableau suivant en donnant le temps de recherche1 de chacune

des trois fonctions précédentes :
n 100000 200000 400000 600000 800000 1000000 1200000 1400000 1600000 1800000
x
Elets Meilleur 7.1x10-5 8.4x10-5 0.0001 0.00013 0.00014 0.00014 0.00014 0.000142 0.000145 0.00015
non triés cas
Pire cas 0.014 0.02 0.032 0.046 0.066 0.072 0.099 0.107 0.125 0 .133

Elets Meilleur 0.00022 0.00014 0.00014 0.00014 0.00015 0.00015 0.00015 0.00015 0.00015 0.00015
3
triés cas
Pire cas 0.01 0.012 0.016 0.025 0.03 0.044 0.05 0.061 0.075 0.09
Elets Meilleur 0.00011 0.00013 0.00013 0.00015 0.00015 0.00015 0.00016 0.00016 0.00017 0.00017
triés cas
decho Pire cas 0.00013 0.00014 0.000150 0.00015 0.000159 0.000167 0.000177 0.00018 0.0002 0.00022
8
 3.

4. Que constatez vous ?

1. Recherche dans un tableau non trié :

o La complexité de la recherche linéaire dans un tableau non trié est de
O(n), où. Cela signifie qu'à mesure que la taille du tableau augmente,
le temps nécessaire pour trouver un élément donné augmente
proportionnellement.
2. Recherche dans un tableau trié :
o La recherche séquentielle est plus rapide car une fois que l'algorithme
trouve un élément qui est supérieur à celui recherché, il peut s'arrêter,
sachant que l'élément ne peut pas être trouvé dans le tableau.
3. Recherche dichotomique dans un tableau trié :
o La recherche dichotomique est une méthode plus efficace pour
rechercher un élément dans un tableau trié. Cette méthode divise
continuellement le tableau en deux, en vérifiant l'élément au milieu du
tableau, et en éliminant la moitié du tableau dans laquelle l'élément ne
peut pas se trouver. Sa complexité est de O(log n), ce qui signifie que
le temps de recherche augmente de manière beaucoup plus lente par
rapport à l'augmentation de la taille du tableau.

Conclusion : la recherche dans un tableau non trié est moins efficace que la
recherche dans un tableau trié, en raison de la complexité de l'algorithme. De plus,
la recherche dichotomique dans un tableau trié est souvent la méthode la plus
efficace pour trouver un élément, car elle divise de manière itérative le domaine de
recherche par deux, réduisant considérablement le nombre d'opérations nécessaires
pour trouver l'élément recherché.

B. Recherche du maximum et du minimum :

a. Ecrire la fonction MaxEtMinA de recherche du maximum et du
minimum d’un ensemble non trié de n éléments.

Algorihtme MAX_MIN

Def calculerMaxMin(tableau)
max ←tableau[0] //1u
min ←tableau[0] //1u
Pour i1 à n faire : 1u
Si (tableau[i] > max)alors 1u
max ← tableau[i] ; 1u
Finsi ;
Si (tableau[i] < min) alors 1u
min ← tableau[i] ;1u
FinSi ;
FinPour ; //n*(1+2+2)+1
Afficher("Le maximum est ", max) ; //1u
Afficher("Le minimum est ", min) ; //1u
Debut
Tableau T[i] : tableau d’entier
I,n,entier ;
Pour i1 a n faire : //1u
Lire(T[i]) ; //1u
Finpour ; //2*n+1
MaxetMinA(Tableau) ; //5*n+5
Fin ;
Au départ, l'algorithme suppose que le premier élément est à la fois le maximum
et le minimum. Cependant, si le véritable maximum est à l'autre bout du tableau
et le véritable minimum est aussi à un autre endroit, l'algorithme devra parcourir
tout le tableau pour les découvrir. Sinon le meilleur cas survient lorsque le
maximum et le minimum se trouvent aux premiers indices du tableau. Ainsi, le
nombre minimum de comparaisons est nécessaire pour trouver les valeurs.
Sa complexité est de O(n) car la somme des cout est 5*n+5+2*n+1=7*n+6
Voici le programme correspendant en Python :

Dans notre cas, nous avons fais la difference entre le nombre de comparaison
pour trouver le max independamenet que cel pour touver le min pour avoir plus
de precision donc le nombre de comparaison total = cmpmax+cmpmin.
2. Algorithme plus efficace :
a. Ecrire la fonction MaxEtMinB de recherche du maximum et du
minimum d’un ensemble non trié de n éléments selon un principe donné en TP

Algorithme MaxEtMin(tableau)
ind_min ← 1 ; 1u
min ← tableau[ind_min] ; 1u
ind_max ← 0 ; 1u
max ← tableau[ind_max] ; 1u
// n ← longueur(tableau) ;
SI (n MOD 2 != 0) ALORS : 2u
POUR i←0 A n-2 PAS DE 2 2u
FAIRE n/2 u
SI (max < tableau[i+2]) 2u
FIN
Ecrire ("Donnez la taille du
tableau :") ; 1u
Lire(n) ; 1u
SI (n MOD 2 = 0) 2u ALORS :
POUR i←0 A n-1 //2u FAIRE :
SI (i MOD 2 = 0) 2u ALORS :
AJOUTER grand_valeur[i DIV 2]
DANS tableau ;

ALORS : SINON :
max ← tableau[i+2] 2u
FINSI ; AJOUTER petite_valeur[i DIV 2]
FINPOUR ; 6*n/2+3 DANS tableau ;
POUR i←1 A n-3 PAS DE 2 //2u
FAIRE FINSI ; 2u
SI (min > tableau[i+2]) 2u FINPOUR ; 6n
ALORS
min ← tableau[i+2] ; 2u SINON :
FINSI ; 4u POUR i←0 A n-1 FAIRE : 2u
FINPOUR ; 6*(n-2)/2+1
(SI min > tableau[n-1] ) ALORS : SI (i MOD 2 = 0) ALORS : 2u
min ← tableau[n-1] ; AJOUTER grand_valeur[i DIV 2]
FINSI ; 3u DANS tableau ;

SINON : SINON :
POUR i←0 A n-3 PAS DE 2 FAIRE
SI (max < tableau[i+2]) 1u AJOUTER petite_valeur[i DIV 2]
ALORS : DANS tableau ;
max ← tableau[i+2] ; 1u
FINSI ; 2u FINSI ;
FINPOUR ; 4*(n-1)/2 FINPOUR :
POUR i←1 A n-2 PAS DE 2 FAIRE FINSI ;
SI (min > tableau[i+2] ) 1u
ALORS : x ← MaxEtMin(tableau) ;
min ← tableau[i+2] ; 1u
FINSI ; 2u Ecrire(‘le max de ce tableau est
FINPOUR ;4(n-1)/2 ‘,max,’et le min est ‘,min); 1u
SI (max < tableau[n-1]) ALORS :
max ← tableau[n-1] ;FINSI ; 2u
RETOURNER max, min
#1 #2
b. Sa complexité theorique : Dans cet algorithme, le pire des cas se produit
lorsque le nombre d'éléments du tableau est impair et les valeurs du maximum et
du minimum sont situées à l'opposé l'une de l'autre.

La complexité au pire des cas de cet algorithme est de l'ordre de O(n), car
l'algorithme doit parcourir tous les éléments du tableau pour déterminer le
maximum et le minimum. Cela implique deux boucles qui parcourent
respectivement les éléments pairs et impairs du tableau, suivies de conditions
supplémentaires pour s'assurer que les derniers éléments impairs sont bien
comparés pour le maximum et le minimum.
Voici le programme correspendant ecrit en python :

3-Comparer les deux fonctions MaxEtMinA et MaxEtMinB en rajoutant un

compteur dans les deux fonctions pour compter le nombre de comparaison.
Nous allons illustrer les resultats obetenues dans un tableau qui montre la
difference entre le nombre de comparaison de chaque fonction, la fonction la
plus performante est celle qui a le minimum de nombre de comparaison.
 Nombre de Nombre de
N comparaison pour comparaison pour La remarque
MaxetMinA MaxetMinB
100000 199998 99999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
200000 399998 199999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
400000 799998 399999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
600000 1199998 599999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
800000 1599998 799999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
1000000 1999998 999999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
1200000 2399998 1199999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
1400000 2799998 1399999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
1600000 3199998 1599999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
1800000 3599998 1799999 NbcompMaxEtMinA> Nb
compaMaxEtMinB
4-

n 100000 200000 400000 600000 800000 1000000 1200000 1400000 1600000 1800000
Algo
0.017 0.035 0. 068 0.1 0.13 0.18 0.19 0.21 0.29 0.32
MaxetMinA
MaxetMinB 0.011 0.022 0.05 0.087 0.11 0.16 0.18 0.23 0.26 0.29
Apres avoir comparer le temps d’exécution des 2 algorithmes qui sont différents
mais qui traitent le même problème, nous avons retrouvé que B2 fonctionne
mieux que B1 car il met moins de temps pour trouver les valeurs de max et du
min. En plus, en termes de nombre de comparaisons, B2 fais moins de
comparaison par rapport à B1 mémé en augmentant la taille du tableau, donc
nous constatons que B2 et moins complexe que B1.