Algorithme de recherche

Définitions Notion de complexité : Il est souhaitable de pouvoir évaluer les performances d’une solution (algorithme) à une problématique. Complexité théorique -> Terminaison & Correction Complexité algorithmique -> utilisation des ressources (mémoires et temps)

Recherche d’un élément dans une liste ; valeur de sortie VRAI

Recherche d’un élément dans une liste def rec_element(x,liste): if len(liste)==0 : return False # Faux si la liste est vide for y in liste: if y==x: return True # return casse la boucle return False

Recherche d’un élément dans une liste def rec_element(x,liste): cpt,trouve,n=0, False,len(liste) # initialisation while cpt<n and not trouve : #condition de sortie if liste[cpt]==x : trouve=True return trouve

Recherche d’un élément dans une liste def rec_element(x,liste): trouve,n=False,len(liste) # initialisation for i in range(n): if y==x: trouve=True break # break casse la boucle à utiliser avec parcimonie return trouve

Recherche 2 d’un élément dans une liste ; valeur de sortie l’indice

Recherche 2 d’un élément dans une liste def rec_el2(x,liste): if len(liste)==0 : return False # Faux si la liste est vide for i in range(len(liste)): if liste[i]==x: return i # return casse la boucle return False

Recherche 2 d’un élément dans une liste def rec_el2 (x,liste): cpt,trouve,n=0, False,len(liste) # initialisation while cpt<n and not trouve and trouve!=0: if liste[cpt]==x : trouve=cpt return trouve

Recherche 3 d’un élément dans une liste ; valeur de sortie liste des indices

Recherche 3 d’un élément dans une liste def rec_el3(x,liste): if len(liste)==0 : return False s=[] for i in range(len(liste)): if liste[i]==x: s.append(i) return s

Recherche du maximum

Recherche du maximum def max(liste): if len(liste)==0 : return False # renvoie faux si la liste est vide M=liste[0] # initialisation for i in range(n): if liste[i]>M: M= liste[i] # si l'élément de la liste à l'index i est plus grand alors on remplace M return M

Recherche du maximum Correction L'invariant de boucle est le prédicat : M = max(liste[0:k]) préconditionnement: M=liste[0] # initialisation Cette ligne de programme montre que le prédicat est vrai à l'entrée de la boucle puisque la liste à un seul élément hérédité: M = max(liste[0:k]) est vrai. Pour l'itération suivant i=k if liste[k]>M: M= liste[k] 2 cas: soit liste[k]>M et donc il devient le nouveau maximum M= liste[k] soit il est plus petit et le maximum ne change pas. L'hérédité est bien montré et M = max(liste[0:k+1])  postconditionnement: A la sorite de la boucle k=n-1 et donc nous avons bien M = max(liste[0:n])

Recherche du Maximum Algorithme maximum(table : liste de taille n) Début: max ← table[1] pour i allant de 2 à n faire si table[i]>max alors max ← table[i] retourner max fin 1UT 2UT 1UT Pire des cas : liste croissante le test est vrai pour chaque itération T=3(n-1)+1 UT Meilleur des cas : le nombre maximum est bien le premier élément T=2(n-1)+1 UT La complexité de cet algorithme est linéaire en O(n)

Recherche médiane

Recherche médiane def mediane(liste): # liste est une liste non vide n=len(liste) cpt, p,med,r = [0]*n, n//2,0,0 for i in range(n): for el in liste: if liste[i]>el: cpt[i]+=1 if cpt[i]==p and n%2: return liste[i] if (cpt[i]==p or cpt[i]==p-1 )and not n%2: r+=1 med+= liste[i]/2 if r: return med return med

Recherche de la médiane Algorithme: médiane(table: liste de taille n) début pour i allant de 1 jusqu’à n faire compteur[i]← 0 mediane←0 si n%2=1 faire pour i allant de 1 à n faire pour j allant de 1 à n faire si table[j]>table[i] alors compteur[i]←compteur[i]+1 si compteur[i]=(n+1)%2 faire mediane← table[i] sinon si table[j]>table[i] alors compteur[i]←compteur[i]+1 si compteur[i]=n/2-1 ou compteur[i]=n/2+1 faire mediane ← (mediane + table[i])/2 retourner mediane fin Complexité O(n) n impair Complexité O(n²) : 2 boucles de 1 à n Temps constant O(1) à l’intérieure des boucles n pair Complexité O(n²) La complexité de cet algorithme est quadratique en O(n²)

Recherche de la moyenne

Recherche de la moyenne def moy(liste): n=len(liste) if n==0 : return False s=liste[0] for i in range(1,n): s+=liste[i] return s/n

Recherche de la moyenne Correction : L'invariant de boucle est le prédicat : s = somme(liste[0:k]) préconditionnement: s= 0 # initialisation de la somme Cette ligne de programme montre que le prédicat est vrai et que la somme d'un élément est l'élément lui-même hérédité: S = somme(liste[0:k]) est vrai. Pour l'itération suivant i=k s+=liste[i] On ajoute bien le dernier élément de la liste : postconditionnement: A la sorite de la boucle k=n-1 et donc nous avons bien s = somme(liste[0:k]) c'est à dire la somme de tous les éléments de la liste. La valeur renvoyée est cette somme divisée par le nombre d'élément de la liste ; La fonction renvoie bien la moyenne de la liste

Recherche de la Moyenne Algorithme moyenne(table: liste de taille n) # calcul de la moyenne d'une liste début Somme=0 i=0 pour i allant de 1 à n faire somme=somme + liste[i] retrourner somme/n fin 1UT 1UT 2 UT La complexité de cet algorithme est linéaire en O(n)

Variance et écart type On cherche une méthode pour calculer la variance et l’écart type d’une liste en minimisant la complexité. La variance V d'une liste est une mesure de la dispersion des données autour de la valeur moyenne. Plus la variance est petite, plus l'ensemble des données sont proches les unes des autres. Nous avons besoin de la moyenne pour calculer la variance donc la complexité est au moins en O(n).

Variance et écart type Algorithme variance(table: liste de taille n) début somme=0 , carre= 0 i=0 pour i allant de 1 à n faire somme=somme + liste[i] carre = carre + liste[i]**2 retrourner somme/n fin (carre/n)-(somme/n)**2 La complexité de cet algorithme est linéaire en O(n)

Recherche par dichotomie Recherche d’un élément dans un ensemble trié par dichotomie: Recherche de la définition d'un mot dans le dictionnaire français. (par exemple dichotomie) méthode naïve : recherche depuis le début de l'alphabet on s'arrête dès que le mot est trouvé. Méthode par dichotomie on sépare au milieu la zone de recherche et on répond à la question avant ou après la limite.

Recherche par dichotomie Recherche d’un élément dans un ensemble trié par dichotomie: Avant Après Après Trouvé

Recherche par dichotomie Comment traduire cette recherche d’un point de vue algorithmique ? Avec une boucle tant que on recherche l’élément dans la liste Critère d’arrêt de la boucle On a trouvé l’élément La recherche est infructueuse et l’élément n’est pas dans la liste. La dernière liste est de taille 1 obligatoirement, c’est à dire que l’indice initial et final de la liste est identique

Recherche par dichotomie def rec_dic(x,liste): n=len(liste) if n==0 : return False min,max, trouve=0,n-1,False if liste[min]==x:return min if liste[max]==x:return max while max-min>1 and not trouve: c=(max+min)//2 if liste[c]<x: min=c elif liste[c]>x: max = c else : trouve=True if trouve : return c else : return not trouve

Recherche par dichotomie def rec_dic (x,liste): n=len(liste) if n==0 : return False min,max,trouve=0,n-1,False while max>=min and not trouve: c=(max+min)//2 if liste[c]==x: trouve=True elif liste[c]>x: max = c-1 else : min=c+1 if trouve : return c else : return not trouve

Recherche par dichotomie Correction: Invariant de boucle : liste[min]<x<liste[max] ou trouvé Complexité: Soit une liste de taille L, l'intervalle maxk-mink diminue de moitié pour chaque passage dans la boucle de sorte que : (maxk+1-mink+1)= (maxk-mink)//2 On en déduit donc pour n itérations : (max0-min0)=L= (maxn-minn)//2n=1 en sortie de la boucle Un majorant du compteur est le nombre N vérifiant : La complexité est donc logarithmique par rapport à la taille L de la liste.

Recherche du zéro par dichotomie def dichotomie(f,a,b,eps=10**-6): if abs(f(a))<eps : return a elif : a<b: min,max=a,b else: min,max=b,a if: f(a)*f(b)>0 : return False while max - min >eps: c=(max+min)/2 if abs(f(c))<eps : return c elif f(c)*f(max)>0: max=c else : min=c return (max+min)/2

Recherche du zéro par dichotomie Correction: Invariant de boucle : min<x< max si la fonction f est monotone ceci correspond à f(min)<0< f(max) ou f(min)>0> f(max) f(min) * f(max)<0

Recherche du zéro par dichotomie Complexité: L'intervalle maxk-mink diminue de moitié pour chaque passage dans la boucle de sorte que : (maxk+1-mink+1)= (maxk-mink)/2 On en déduit donc pour n itérations : (max0-min0)= (maxn-minn)/2n<eps en sortie de la boucle Un majorant du compteur est le nombre N vérifiant : La complexité est donc logarithmique par rapport à la taille de l'intervalle entre les nombres a et b.

Recherche d’un mot On cherche à trouver un mot dans une phrase ou une liste. Le problème de la recherche d’un mot x de longueur m dans un texte y de longueur n  consiste à signaler toutes les occurrences de x dans y.

Recherche d’un mot Un algorithme de recherche exacte de mot est une succession de tentatives (traitements consistant à comparer le  contenu de la  fenêtre et le mot) ; décalages (de la fenêtre vers la droite).

Recherche d’un mot Algorithme naif(mot: chaine taille m, texte: chaine taille n) début compteur=0 pour i allant de 1 a n-m faire: k=0 pour j allant de 1 à m faire si mot[j]=texte[i+j-1] alors k=k+1 si k=m alors compteur=compteur +1 retourner compteur fin Complexité en O(mn)

Recherche d’un mot Algorithme naif(mot: chaine taille m, texte: chaine taille n) début compteur=0 pour i allant de 1 a n-m faire: k=0 pour j allant de 1 à m faire si mot[j]=texte[i+j-1] alors k=k+1 si k=m alors compteur=compteur +1 retourner compteur fin Comment gagner du temps sur cette algorithme ?

Recherche d’un mot Plusieurs idées: Rechercher les mots dans le texte avec les séparateurs et comparer la longueur des mots avant l’identification de chaque lettre. On compare la fin des mots et non le début, cela permet d’effectuer des sauts de recherche de la longueur du mot (algorithme de Boyer- Moore) Algorithme KMP On construit un tableau, indiquant pour chaque position le décalage, càd la prochaine position d’une occurrence potentielle de la chaîne. Puis recherche, en comparant les caractères de la chaîne et ceux du texte. En cas de différence, il utilise le tableau pour connaître le décalage à prendre en compte pour continuer la recherche sans retour en arrière.

Recherche d’un mot def rec_mot(mot,phrase): m,p,s,i= len(mot), len(phrase), [],0 if n==0 or m==0 : return False def meme_mot(mot1,mot2): n=len(mot1) if n!=len(mot2) or n==0: return False cpt=n-1 while cpt>=0 and mot1[cpt]==mot2[cpt]: cpt-=1 return mot1[cpt]==mot2[cpt] while i<p-m: if meme_mot(mot,phrase[i:i+m:]): s.append(i) i+=1 return s