Pimp A - info121A Programme Recherche Recherche linéaire

Programme
Tri
Pimp A - info121A
Récursivité
Programmation IMPérative Avancée
Dichotomie
Burkhart Wolff
Frédéric Vernier
Arbre
Recherche linéaire
Diviser pour mieux régner
Graphe
Examen blanc
Recherche
Rechercher un élément dans un ensemble
Action fondamentale de l’informatique
Base de donnée
Savoir si un élément existe
Récupérer d’autres infos associées
etc.
Recherche linéaire
boucle 0-n
boucle for si recherche exhaustive
boucle while si on s'arrête au premier trouvé
Adapté au(x) cache(s)
O(n)
Code C++
Recherche dichotomique
SUR UNE LISTE TRIEE !!!
#include <iostream>
using namespace std ;
string classLigue1_2010[20]={"Lille",
"Sochaux",
"Auxerre",
"Nancy",
"Nice",
"Marseille",
"Rennes",
"St Etienne",
"Montpellier",
"Monaco",
"Lyon",
"Bordeaux",
"Lorient",
"Caen",
"Lens",
"Paris",
"Toulouse",
"Valenciennes",
"Brest",
"Arles-Avignon"};
Itération sur intervalle
Coupe en deux
Test de la valeur du milieu
int main (int argc, char * const argv[]) {
int i=0;
while (i<20 && classLigue1_2010[i]!= "Caen") {i++;}
if (classLigue1_2010[i]=="Caen") cout << "Oui Caen est bien en Ligue 1 " << endl;
}
Réajustement de l’intervalle
par la droite si valeur trop “petite”
par la gauche si valeur trop “grande”
Code C++
#include <iostream>
using namespace std ;
Recherche 1/2
Chaine de caractère(string c++)
int rechercheDichotomiqueINSEE (int insee) {
inti;
int g = 0;
int d = liste.size()-1;
do {
i = (g + d) / 2;
if(liste[i].Insee==insee)
return i;
else if (liste[i].Insee>insee)
d = i - 1;
else
g = i + 1;
} while (g <= d);
return -1;
}
s1==s2 marche
s1<s2 ne marche pas :-(
s1.compare(s2) < 0 marche !
Bingo !
trop grand !
trop petit !
Résultats multiples
élargissement des bornes
Recherche du plus proche
...
string
Résultats multiples
#include <iostream>
using namespace std ;
int rechercheDichotomiqueINSEE (string insee) {
inti;
int g = 0;
int d = liste.size()-1;
do {
i = (g + d) / 2;
if(liste[i].Insee==insee)
return i;
else if (liste[i].Insee.compare(insee)>0)
d = i - 1;
else
g = i + 1;
} while (g <= d);
return -1;
}
A cause des corses !
int rechercheDichotomiquePop (int pop) {
int i;
int g = 0;
int d = liste.size()-1;
do {
i = (g + d) / 2;
if (liste[i].pop99==pop) {
int ib = i;
while (liste[ib-1].pop99==pop) ib--;
int ia = i;
while (liste[ia+1].pop99==pop) ia++;
return ia-ib+1;
} else if (liste[i].pop99>pop)
d = i - 1;
else
g = i + 1;
} while (g <= d);
return -1;
}
Recherche 2/2
Recherche du plus proche
Attention aux valeurs extrêmes
Attention à la sortie de boucle
Recherche binaire/dichotomique
Bingo !
trop grand !
trop petit !
résultat le plus proche
int rechercheDichotomiqueLat (float lat) {
int i;
int g = 0;
int d = liste.size()-1;
do {
i = (g + d) / 2;
if(liste[i].latitude_radian==lat || g==d) {
return i;
}
else if (liste[i].latitude_radian>lat)
d = i - 1;
else
g = i + 1;
} while (g <= d);
O(log(n))
Bingo double!
if (abs(liste[g].latitude_radian-lat)>abs(liste[g+1].latitude_radian-lat))
return g+1;
else
return g;
}
quasi-Bingo !
Recherches multiples
Recherche par interpolation (linéaire)
1 recherche = O(log(n))
n recherches = O(n.log(n))
i.e. recherche éléments de A qui sont aussi
dans B
Stratégie
itération identique
< O(log(n)) ~= O(log(log(n))) si répartition uniforme
recherche linéaire sur la moins avancée
des listes
>O(log(n)) ~= O(n) si répartition non uniforme (rep. exp.)
C’est pas toujours mieux !
Interpolation linéaire
Exercices
C’est la règle de 3 !
int rechercheInterpolationLineaireLat (float lat) {
int
i;
int g = 0;
int d = liste.size()-1;
do {
if (liste[d].surface==liste[g].surface) i = (g + d) / 2;
else i = g+1+round((d-g-2)*(lat-liste[g].latitude_radian)/(liste[d].latitude_radian-liste[g].latitude_radian));
if(liste[i].latitude_radian==lat) {
return i;
}
}
prend un intermédiaire “proportionnel”
Temps de calcul
trier les 2 listes
else if (liste[i].latitude_radian>lat)
d = i - 1;
else
g = i + 1;
} while (g <= d);
return -1;
Evalue la cible par rapport aux bornes
index
min
valeur
min
Milieu ? Ici ?
valeur
recherchée
Recherche par interpolation
noms de communes
latitudes de communes
longitudes de communes
index
max
valeur
max
surfaces de communes
Quand est-ce mieux que dichotomique ?