IFT 1010 - Programmation 1 Algo 1

20 Pages·2012·0.07 MB·French

IFT 1010 - Programmation 1
Algo 1
S¶ebastien Roy & Bal¶azs K¶egl
D¶epartement d’informatique et de recherche op¶erationelle
Universit¶e de Montr¶eal
automne 2003
Au programme
[Tasso :7] et [Nin~o : 2.3-6]
† Algorithme sur les tableaux
† Recherche
† Tri
† Complexit¶e
1
Algorithmes & tableaux
On peut copier, d¶eplacer, etc. les ¶el¶ements d’un tableau.
Les deux applications les plus importantes des tableaux :
Recherche
Trouver ou(cid:181) un ¶el¶ement se trouve dans un tableau
Tri Placer les ¶el¶ements d’un tableau selon un ordre donn¶e
2
Algorithmes de recherche
Il existe de nombreux algorithmes de recherche.
Trois classes distinctes
† Recherche dans un tableau non tri¶e
(on ne connait rien sur l’ordre des ¶el¶ements)
† Recherche dans un tableau tri¶e
(on sait que les ¶el¶ements sont ordonn¶es)
† Recherche dans un tableau semi-tri¶e ( ? hummm....)
(on connait certaines informations sur les ¶el¶ements)
3
Le Code
// on cherche la valeur v dans le tableau t
// on retourne l’index de v trouv¶e dans le tableau
// on retourne -1 si pas trouv¶e
int Recherche ( int t[], int v ) {
...
}
Les algorithmes de recherche (pr¶esent¶es ici)
Tableau non-tri¶e
† recherche directe
Tableau tri¶e
† recherche lin¶eaire
† recherche binaire
Tableau semi-tri¶e
(d¶epend des informations connues sur le tableau)
4
Algorithmes de recherche directe
Id¶ee : passer s¶equentiellement tous les ¶el¶ements
int RechercheDirecte ( int t[], int v ) {
int i;
for( i=0 ; i<t.length ; i++ ) {
if( t[i] == v ) return i; // trouv¶e! :-)
}
return -1; // pas trouv¶e! :-(
}
Voici la m^eme version (avec bug inclus !) :
int RechercheDirecte ( int t[], int v ) {
int i=0;
while( ( t[i] != v ) && ( i < t.length ) ) i++;
if( t[i]==v ) return i; // trouv¶e!
else return -1; // pas trouv¶e!
}
5
Algorithmes de recherche directe
Un exemple tir¶e d’un autre cours de Java....
Que dites-vous de la lisibilit¶e de ce code ?
int RechercheDirecte ( int t[], int v ) {
final int TROUVE = 0, ABSENT = 1, CHERCHE = 2;
int i = 0, etat = CHERCHE;
do {
if( i >= t.length ) etat = ABSENT;
else if( t[i] == v ) etat = TROUVE;
else i++;
} while( etat == CHERCHE );
switch( etat ) {
case TROUVE: return i;
case ABSENT: return -1;
}
}
6
Performance de la recherche directe
Mesure : On compte le nombre de comparaisons efiectu¶ees
Pour un probl(cid:181)eme de taille N (nombre d’¶el¶ements) :
Meilleur cas
On tombe sur le bon ¶el¶ement du premier coup : 1 op¶eration.
Pire cas
On passe tout le tableau : N op¶erations.
Cas moyen
La valeur peut ^etre n’importe ou(cid:181) avec probabilit¶e uniforme :
N=2 op¶erations.
7
Algorithmes de recherche lin¶eaire
Id¶ee : on peut arr^eter de chercher avant la fln
(on suppose que les ¶el¶ements sont en ordre croissant)
int RechercheLin¶eaire ( int t[], int v ) {
int i;
for( i=0 ; i<t.length ; i++ ) {
if( t[i] == v ) return i; // trouv¶e! :-)
if( t[i] > v ) return -1; // pas trouv¶e! :-(
}
return -1; // pas trouv¶e! :-(
}
Si l’¶el¶ement est absent du tableau, on arr^ete plus rapidement
que la recherche directe.
8
Algorithmes de recherche binaire
Id¶ee : On va sauter un peu partout dans le tableau
(un peu comme chercher dans le dictionnaire...)
† On choisi une page au milieu du dictionnaire
† On regarde si le mot cherch¶e est avant ou apr(cid:181)es cette page
† On cherche maintenant dans la une moiti¶e du dictionnaire
Plus pr¶ecisement :
† Choisir un intervalle de pages couvrant le dictionnaire [a; b]
† Visiter la page milieu de cet intervalle, c = (a + b)=2.
† Si le mot est trop petit, on reprend dans l’intervalle [a; c]
† Si le mot est trop grand, on reprend dans l’intervalle [c; b]
9