Algorithmique et structures de données
Jean-Claude GEORGES
ESIEE IGI-3005
2019–2020
1/151 Jean-Claude GEORGES Algorithmique et structures de données
Types
Les types simples (TS) utilisés
– NB : nombre– ENT : nombre entier (0, 1, -7)– RÉEL : nombre réel (2.35, 1.6 · 10−19)
– BOOL : valeur logique (Vrai, Faux)– CAR : caractère (’A’, ’5’)– ADR : adresse d’une donnée (pointeur)
2/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
modifie le contenu de x∈ TS
x expression
Instruction 1 - Affectation
exécute les instructions l’une après l’autre
instruction_1
instruction_2
...
instruction_n
ouinstruction_1, instruction_2, ..., instruction_n
Instruction 2 - Bloc d’instructions
3/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
exécute le bloc d’instructions 1 si la condition est vraie et le bloc
d’instructions 2 si elle est fausse.SI condition ALORS
bloc d’instructions 1
SINON
bloc d’instructions 2
FIN SI
Instruction 3 - Conditionnelle
Note : la clause SINON peut être omise.
4/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
exécute le bloc d’instructions tant que la condition est vérifiée.
TANT QUE condition FAIRE
bloc d’instructions
FIN TANT QUE
Instruction 4 - Itération
5/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
associe un nom au bloc d’instructions
PROCÉDURE nomproc
DONNÉES : liste des données non modifiables et leurs types
DONN. MOD.: liste des données modifiables et leurs types
bloc d’instructions
FIN PROCÉDURE
Instruction 5 - Définition de procédure
6/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
associe un nom au bloc d’instructions calculant une valeur
FONCTION nomfct
DONNÉES : liste des données non modifiables et leurs types
DONN. MOD.: liste des données modifiables et leurs types
RÉSULTAT : type du résultat
bloc d’instructions
RETOUR expression
FIN FONCTION
Instruction 6 - Définition de fonction
7/151 Jean-Claude GEORGES Algorithmique et structures de données
Instructions
RécursivitéUne fonction (ou procédure) récursive fait appel à elle-même dansson bloc d’instructions.
fonction faisant appel à elle-même
FONCTION nomfct
...
SI condition particulière ALORS
bloc d’instructions cas particulier
RETOUR expression cas particulier
SINON
bloc d’instructions cas général contenant un appel
à la fonction avec des arguments se ’rapprochant’
du cas particulier
RETOUR expression cas général
FIN FONCTION
Instruction 7 - Exemple de fonction récursive
8/151 Jean-Claude GEORGES Algorithmique et structures de données
Échange mémoire
permute les contenus de x et y
utilise une variable d’échange
PROCÉDURE permute
DONN. MOD.: x∈ TS , y∈ TS
tmp x
x y
y tmp
FIN PROCÉDURE
Algorithme 1 - Échange mémoire
9/151 Jean-Claude GEORGES Algorithmique et structures de données
Échange mémoire
Échange mémoire : permutation de deux doubles
En C, les données modifiables (ou celles dont on veut économiser lacopie complète) sont transmises par leurs adresses (pointeurs).void permute (double *px, double *py)
double z;z = *px;*px = *py;*py = z;
10/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Algorithmes sur les suites
Une suite est définie par son premier terme et une applicationpermettant de calculer le prochain terme de la suite en utilisant toutou partie des données parmi :
– un ou plusieurs termes déjà calculés– le rang du terme courant– des paramètres extérieurs
Dans la suite, on utilisera la notation suivant(u) pour l’expressionpermettant le calcul du terme suivant de la suite.De même une condition booléenne sur un terme de la suite seranotée cond(u).
11/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
calcule le terme de rang n de la suite définie par u0 et suivant
itération sur le calcul u suivant(u)
FONCTION calculUn
DONNÉES : u0 ∈ TS , n∈ ENT
RÉSULTAT : TS
u u0 , i 0
TANT QUE i < n FAIRE
u suivant(u)
i i + 1
FIN TANT QUE
RETOUR u
FIN FONCTION
Algorithme 2 - Calcul de un (approche itérative)
12/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
calcule le terme de rang n de la suite définie par u0 et suivant
récursion sur le calcul de suivant(u)
FONCTION calculUn
DONNÉES : u0 ∈ TS , n∈ ENT
RÉSULTAT : TS
SI n=0 ALORS
RETOUR u0
SINON
RETOUR calculUn(suivant(u0), n - 1)
FIN SI
FIN FONCTION
Algorithme 3 - Calcul de un (approche récursive)
13/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Calcul de un : la factorielle∣∣∣∣ 0! = 1 =⇒ u0 = 1n! = n · (n − 1)! =⇒ suivant(i , u) = i · u
En C En Python
int fact(int n) int i = 1;int u = 1;while (i <= n)
u = u * i;i = i + 1;
return u;
def fact(n):u, i = 1, 1while i <= n:u = u * ii = i + 1
return u
14/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Calcul de un : la factorielle (suite)Quand on connaît mieux le langage :Itératif Récursif
int f_it1(int n) int i;int f = 1;for (i = 1 ; i <= n ; ++i)
f *= i;return f;
int f_rec1 (int n) if (n <= 0)return 1;
elsereturn n * f_rec1(n - 1);
def f_it1(n):f = 1for i in range(1, n+1):
f *= ireturn f
def f_rec1(n):if (n <= 0):return 1
else:return n * f_rec1(n - 1)
15/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Calcul de un : la factorielle (fin)Quand on connaît encore mieux le langage :Itératif Récursif
int f_it2 (int n) int f = 1;while (n)
f *= n--;return f;
f(n)n=n?n*f(n-1):1;/* 21 caractèresgcc uniquementSegmentation fault si n<=0*/
def f_it2(n):if n < 1:
return 1for t in range(1, n): #affreux
n *= treturn n
f=lambda n:n<1or n*f(n-1)# 25 caractères# retourne True(==1) si n<=0
16/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
retourne Vrai s’il existe un terme de la suite de rang inférieur ouégal à n vérifiant la condition cond et Faux sinon
itération tant que cond non vérifiée et limite non atteinte
FONCTION ilExiste
DONNÉES : u0 ∈ TS , n∈ ENT
RÉSULTAT : BOOL
i 0 , u u0 , trouvé Faux
TANT QUE non trouvé et i ≤ n FAIRE
SI cond(u) ALORS
trouvé Vrai
SINON
u suivant(u), i i + 1
, FIN SI
FIN TANT QUE
RETOUR trouvé
FIN FONCTION
Algorithme 4 - ∃ i ∈ [0 ; n] P(ui ) est vrai
17/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Il existe ... : un diviseur de n inférieur à n
int est_compos(int n) int u = 2; /* ici, comme u = i+2, i est inutile */int trouve = 0;while (! trouve && u < n)
if (n % u == 0)trouve = 1;
elseu = u + 1;
return trouve;
Note : Dans la vraie vie, on s’arrête à√n
18/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
retourne Vrai si tous les termes de la suite de rang inférieur ouégal à n vérifient la condition cond et Faux sinon
itération tant que cond vérifiée et limite non atteinte
FONCTION quelQueSoit
DONNÉES : u0 ∈ TS , n∈ ENT
RÉSULTAT : BOOL
i 0 , u u0 , ok Vrai
TANT QUE ok et i ≤ n FAIRE
SI non cond(u) ALORS
ok Faux
SINON
u suivant(u), i i + 1
FIN SI
FIN TANT QUE
RETOUR ok
FIN FONCTION
Algorithme 5 - ∀ i ∈ [0 ; n] P(ui ) est vrai
19/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Quel que soit ... : d ∈ [2,E(√n)], d ne divise pas n
int premier(int n) int d = 2;int ok = 1;while (ok && d * d <= n)
if (n % d == 0)ok = 0;
elsed = d + 1;
return ok;
Attention : avec ce programme, 0 et 1 sont considérés premiers.
20/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
calcule l’indice du premier terme de la suite qui vérifie une condi-tion cond
itération tant que cond non vérifiée
FONCTION premierQui
DONNÉES : u0 ∈ TS
RÉSULTAT : ENT
i 0 , u u0
TANT QUE non cond(u) FAIRE
u suivant(u), i i + 1
FIN TANT QUE
RETOUR i
FIN FONCTION
Boucle infinie si aucun élément de la suite ne vérifie lacondition. Penser à limiter l’amplitude de la recherche.
Algorithme 6 - Calcul de min i ∈ N / condition(ui)
21/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Premier qui... : longueur de la suite de SyracuseLa suite de Syracuse est définie par :∣∣∣∣∣∣
u0 = a
un+1 = un/2 (si un est pair)= 3un + 1 (si un est impair)
On conjecture qu’elle finit toujours par atteindre 1.int longueur_syr(int a)
int i = 0;int u = a;while (u != 1)
++i;if (u%2 == 0)
u /= 2;else
u = 3*u + 1;return i;
22/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
calcule la limite d’une suite
itération tant que termes consécutifs différents
FONCTION limiteUn
DONNÉES : u0 ∈ TS
RÉSULTAT : TS
u u0 , v suivant(u)
TANT QUE u 6= v FAIRE
u v , v suivant(u)
FIN TANT QUE
RETOUR u
FIN FONCTION
Boucle infinie si la suite ne converge pas. Penser à limiterl’amplitude de la recherche.En programmation, penser à faire un test de différencerelative.
Algorithme 7 - Limite de (un)n∈N
23/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Limite : résolution de l’équation cos(x) = x
La suite définie par : ∣∣∣∣∣ u0 = 1un+1 = cos(un)
converge. Sa limite est solution de l’équation cos(x) = x .double resol_cos_x_egale_x()
/* fonctionne car la dérivée de cos < 1inclure <math.h>, compiler avec -lm */
double u = cos(1.0);double v = cos(u);while (fabs(u - v) > 1e-5 * fabs(u))
u = v;v = cos(u);
return v;
24/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
calcule la somme des n+1 premiers termes d’une suite
schéma d’accumulation
FONCTION sigma
DONNÉES : u0 ∈ NB , n∈ ENT
RÉSULTAT : NB
i 0 , u u0 , s 0
TANT QUE i ≤ n FAIRE
s s + u , u suivant(u) , i i + 1
FIN TANT QUE
RETOUR s
FIN FONCTION
Algorithme 8 - Σi=ni=0(ui)
25/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Série : calcul de Σi=ni=0x
2
int sigma_carres(int n) int i = 0;int u ;int s = 0;while (i <= n)
u = i * i;s += u;++i;
return s;
26/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
retourne la période si détectée avant le ne élément, ou -1
algo. de Pollard : compare à une suite deux fois plus rapide
FONCTION période
DONNÉES : u0 ∈ NB , n∈ ENT
RÉSULTAT : ENT
i 0 , u u0 , v suivant(u)
TANT QUE i≤n et u 6= v FAIRE
u suivant(u) , v suivant(suivant(v)), i i + 1
FIN TANT QUE
SI i>n ALORS
RETOUR -1
SINON
i 1 , u suivant(u)
TANT QUE u 6= v FAIRE
u suivant(u) , i i + 1
FIN TANT QUE
RETOUR i
FIN SI
FIN FONCTION
Algorithme 9 - (un)n∈N périodique à partir d’un certain rang ?
27/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Algorithme de Pollard
unsigned int periode(unsigned int u0, unsigned int n, unsigned int (*f)(unsigned int)) /* cherche une période pour la suite u0 et u_n=f(u_n-1) */unsigned int i = 0;unsigned int u = u0, v = f(u);while (i <= n && u != v)
++i;u = f(u); v = f(f(v));
if (i > n)
return -1;i = 1; u = f(u);while (u != v)
++i;u = f(u);
return i;
28/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Nombres pseudo-aléatoiresPour produire des nombres pseudo-aléatoires, on peut utiliser ungénérateur congruentiel linéaire, basé sur des congruences et unefonction linéaire (D.H. Lehmer, 1948) :
Xn+1 = (a · Xn + c) mod m
Un mauvais choix peut être catastrophique (Randu, IBM 1960) :unsigned int Randu(unsigned int n)
/* u_n = ( 65539*u_n-1 ) mod 2^31 */return ( (n << 16) + (n << 1) + n) % 0x80000000;
Période maxi attendue 231 = 2 147 483 648
u0 période1 536 870 9122 268 435 456
1 024 524 288262 144 2 048
29/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Nombres pseudo-aléatoires (suite)On montre que la période d’un générateur congruentiel linéaire estmaximale (et égale à m) si et seulement si :
– c est premier avec m– pour chaque nombre premier p divisant m, a− 1 est un
multiple de p– si m est un multiple de 4, a− 1 l’est aussi
Le compilateur gcc utilise le même algorithme pour son générateurde nombres pseudo-aléatoires, mais avec a = 1 103 515 245,c = 12 345 et m = 232
static unsigned long __suivant = 1;
unsigned rand(void)
/* pour RAND_MAX = 32767 */
__suivant = __suivant * 1103515245 + 12345;
return((unsigned)(__suivant / 65536) % 32768);
30/151 Jean-Claude GEORGES Algorithmique et structures de données
Suites et séries
Nombres pseudo-aléatoires (suite)Le Mersenne TwisterAujourd’hui, le générateur de nombres pseudo-aléatoires le plusréputé est le Mersenne Twister, développé par Makoto Matsumoto etTakuji Nishimura en 1997 (sa période est 219 937 − 1). C’est lui queMaple utilise depuis sa version 11, ainsi que Python, Ruby, R, PHP,MATLAB et la GNU Scientific Library (GSL).Le source C d’une version du Mersenne Twister est disponible ici :http://www.math.sci.hiroshima-u.ac.jp/ m-mat/MT/MT2002/CODES/mt19937ar.c
En supposant que vous lanciez aujourd’hui un programme Pythongénérant par le Mersenne Twister un billion (1012) de nombrespseudo-aléatoires par seconde, en quelle année reviendra-t-il à sonpoint de départ ?
31/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Le type tableau (TAB de TS)Un tableau est une suite contiguë d’éléments de même type repérés(indicés) par un nombre entier.La numérotation commence à partir de 0 (zéro).L’accès à l’élément no k du tableau t se notera t[k]
La limite d’exploitation du tableau se fait :– soit en précisant un rang limite du tableau (taille)– soit en précisant une sentinelle (élément marqueur de fin)
32/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Parcours d’un tableau sur le nombre d’éléments
t
0 1 i n-11 i n-1
33/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
traite les n premiers éléments d’un tableau
itération sur les n premiers termes
PROCÉDURE parcoursTaille
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
i 0
TANT QUE i < n FAIRE
traite(t[i])
i i+1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 10 - Parcours d’un tableau (sur taille)
34/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Un tableau est-il trié ?
int est_trie(double t[], int n) int i ;for (i = 1; i < n; ++i)
if (t[i] < t[i-1]) return 0;
return 1;
35/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Parcours d’un tableau sur sentinelle
t
0 11
36/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
traite les éléments d’un tableau jusqu’à rencontrer une sentinelle
itération jusqu’à la sentinelle
PROCÉDURE parcoursSentinelle
DONN. MOD.: t∈ TAB de TS
DONNÉES : sentinelle∈ TS
i 0
TANT QUE t[i] 6= sentinelle FAIRE
traite(t[i])
i i+1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 11 - Parcours d’un tableau (sentinelle)
37/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Longueur d’une chaîne
int longueur_chaine(char *s) int i ;i = 0;while (s[i] != '\0')
++i;return i;
38/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Initialisation
t
0 1 i n-11 i n-1
? ? ? ?
inittab
t
0 1 i n-11 i n-1
f(0) f(1) f(i) f(n-1)
39/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
initialise les n premiers éléments d’un tableau par une fonction deleurs indicesitération sur les n premiers termes
PROCÉDURE inittab
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
i 0
TANT QUE i < n FAIRE
t[i] f(i)
i i+1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 12 - Initialisation d’un tableau
40/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Initialisation d’un tableau trié
double *remplit_trie(double t[], int n) int i;for (i = 0; i < n; ++i)
t[i] = (double)i;return t;
41/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Application (map)
t
0 1 i n-11 i n-1
map
t
0 1 i n-11 i n-1
f(t[0]) f(t[1]) f(t[i]) f(t[n-1])
42/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
modifie les n premiers éléments d’un tableau par une fonction deleurs valeursitération sur les n premiers termes
PROCÉDURE map
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
i 0
TANT QUE i < n FAIRE
t[i] f(t[i])
i i+1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 13 - Application sur les éléments d’un tableau
43/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Conversion d’une chaîne en majuscule
char *majuscule(char *t) int i;for (i = 0; t[i] != '\0'; ++i)
if ('a' <= t[i] && t[i] <= 'z') t[i] += 'A' - 'a';
return t;
44/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Copie
src
0 1 i n-11 i n-1
dest
0 1 i n-11 i n-1
copietab
45/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
copie les n premiers éléments d’un tableau src dans un tableaudest
itération sur les n premiers termes
PROCÉDURE copietab
DONN. MOD.: dest∈ TAB de TS, src∈ TAB de TS,
DONNÉES : n∈ ENT
i 0
TANT QUE i < n FAIRE
dest[i] src[i]
i i+1
FIN TANT QUE
FIN PROCÉDURE
Cet algorithme ne gère pas les recouvrements possiblesentre dest et src.
Algorithme 14 - Copie d’un tableau dans un autre
46/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Copie d’une chaîne dans une autre
char *copie_chaine(char *dest, char *src) int i ;for (i = 0; src[i] != '\0'; ++i)
dest[i] = src[i];dest[i] = '\0';return dest;
ou encore :char *copie_chaine(char *dest, char *src)
char *ret = dest;while (*dest++ = *src++);return ret;
47/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Décalage droite
t
d d+1 f-1 fd+1 f
t
d d+1d+2 f f+1d+2 f+1
decaleD
48/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
décale d’une position vers la droite éléments d’un tableaud’indices compris entre d et f
parcours à rebours pour ne pas perdre de valeur
PROCÉDURE decaleD
DONN. MOD.: t∈ TAB de TS
DONNÉES : d∈ ENT, f∈ ENT
i f
TANT QUE i ≥ d FAIRE
t[i+1] t[i]
i i-1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 15 - Décalage droite
49/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Recherche de base dans un tableau
0 i-1
6= x ?
i n-1
?
i n-1
Invariant : ∀ j < i : t[j ] 6= x
50/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
recherche la première occurrence d’une valeur dans un tableau.Retourne sa position si elle existe, -1 sinon
parcours du tableau jusqu’à rencontrer la valeur cherchée
FONCTION rechercheBase
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT, x∈ TS
RÉSULTAT : ENT
i 0
TANT QUE i < n et t[i] 6= x FAIRE
i i+1
FIN TANT QUE
SI i<n ALORS
RETOUR i
SINON
RETOUR -1
FIN SI
FIN FONCTION
Algorithme 16 - Recherche de base
51/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Recherche séquentielle dans un tableau trié
0 i-1
< x ?
i n-1
?
i n-1
Invariant : ∀ j < i : t[j ] < x
52/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
retourne la position d’insertion d’une valeur dans un tableau.
parcours du tableau jusqu’à rencontrer une valeur supérieure ouégale à la valeur cherchée
FONCTION posSeq
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT, x∈ TS
RÉSULTAT : ENT
i 0
TANT QUE i < n et t[i] < x FAIRE
i i+1
FIN TANT QUE
RETOUR i
FIN FONCTION
Algorithme 17 - Recherche séquentielle dans un tableau trié
53/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
Recherche dichotomique dans un tableau trié
t
0
< x
d
< x
d+1 f
≥ x
n-1
≥ x
n
Invariant : d < position(x) ≤ f
(∀ i <= d : t[i ] < x) ∧ (∀ i ≥ f : t[i ] ≥ x)
54/151 Jean-Claude GEORGES Algorithmique et structures de données
Gestion de tableaux
retourne la place d’une valeur dans un tableau trié.
test sur l’élément milieu, puis division par 2 de l’intervalle
FONCTION rechercheDicho
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT, x∈ TS
RÉSULTAT : ENT
d -1, f n
TANT QUE d+1 < f FAIRE
m Ent((d+f)/2)
SI t[m]<x ALORS
d m
SINON
f m
FIN SI
FIN TANT QUE
RETOUR f
FIN FONCTION
Algorithme 18 - Recherche dichotomique
55/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Principaux algorithmes de trisUn tri est un traitement permutant les éléments d’un tableau demanière à ce qu’ils soient ordonnés selon un certain critère.
http://www.sorting-algorithms.com/
https://www.youtube.com/watch?annotation_id=annotation_91201&feature=iv&src_vid=nDKGHGdXLEg&v=aXXWXz5rF64
https://www.youtube.com/watch?v=MtcrEhrt_K0 https://www.youtube.com/watch?v=3San3uKKHgg
56/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Tri d’un tableau
t
0 n-10
t
0 n-10
tri
57/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Tri bulleUn balayage consiste à parcourir le tableau en comparant leséléments consécutifs : s’ils sont ordonnés, on les laisse en place,sinon, on les permute.Le be balayage amène le be plus grand élément à sa place.
t
0
≤ t[i ]
i
?
i+1 n-b
si t[i+1]<t[i], permuter t[i+1] et t[i]
Invariant : ∀ j < i : t[j ] ≤ t[i ]
58/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
n-1 balayages, chaque balayage ordonnant les n-1 pairesd’éléments consécutifs
PROCÉDURE triBulleBase
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
b 1
TANT QUE b < n FAIRE
i 0
TANT QUE i+1 < n FAIRE
SI t[i+1] < t[i] ALORS
permute(t[i+1], t[i])
FIN SI
i i+1 // ∀j < i : t[j ] <= t[i ]FIN TANT QUE
b b+1 // t[0; n − b[<= t[n − b] et t[n − b; n[ est tri eFIN TANT QUE
FIN PROCÉDURE
Algorithme 19 - Tri bulle de base (bubble sort)
59/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tribulle
Balayage 1
40
01
62
13
34
75
56
27
0 4 6 1 3 7 5 2
0 4 6 1 3 7 5 2
0 4 1 6 3 7 5 2
0 4 1 3 6 7 5 2
0 4 1 3 6 7 5 2
0 4 1 3 6 5 7 2
0 4 1 3 6 5 2 7
Balayage 2
00
41
12
33
64
55
26
77
0 4 1 3 6 5 2 7
0 1 4 3 6 5 2 7
0 1 3 4 6 5 2 7
0 1 3 4 6 5 2 7
0 1 3 4 5 6 2 7
0 1 3 4 5 2 6 7
60/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tribulle (2)
Balayage 3
00
11
32
43
54
25
66
77
0 1 3 4 5 2 6 7
0 1 3 4 5 2 6 7
0 1 3 4 5 2 6 7
0 1 3 4 5 2 6 7
0 1 3 4 2 5 6 7
Balayage 4
00
11
32
43
24
55
66
77
0 1 3 4 2 5 6 7
0 1 3 4 2 5 6 7
0 1 3 4 2 5 6 7
0 1 3 2 4 5 6 7
61/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tribulle (3)
Balayage 5
00
11
32
23
44
55
66
77
0 1 3 2 4 5 6 7
0 1 3 2 4 5 6 7
0 1 2 3 4 5 6 7
Balayage 6
00
11
22
33
44
55
66
77
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
Balayage 7
00
11
22
33
44
55
66
77
0 1 2 3 4 5 6 7
62/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
diminue le nombre d’éléments à comparer par balayage
PROCÉDURE triBulleAmeliore
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
TANT QUE n>1 FAIRE
i 0
TANT QUE i+1 < n FAIRE
SI t[i+1] < t[i] ALORS
permute(t[i+1], t[i])
FIN SI
i i+1
FIN TANT QUE
n n-1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 20 - Tri bulle amélioré (bubble sort)
63/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
arrête le tri si tous les éléments dans l’ordre
PROCÉDURE triBulleOptimal
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
fini FAUX
TANT QUE PAS fini FAIRE
fini VRAI, i 0
TANT QUE i+1 < n FAIRE
SI t[i+1] < t[i] ALORS
fini FAUX, permute(t[i+1], t[i])
FIN SI
i i+1
FIN TANT QUE
n n-1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 21 - Tri bulle optimisé (bubble sort)
64/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Tri par sélection (sélection sort)On cherche dans le tableau le plus grand élément. On permute cetélément avec le dernier élément du tableau. On recommence sur letableau privé de ce dernier élément.La ie itération amène le ie plus grand élément à sa place.
t ≤ t[i ]
0 i-1 i n-1
t
0 i-1
MAX
p i n-1
t ≤ t[i − 1]
0 i-1 n-1
65/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
itération sur la recherche de l’indice du plus grand élément et sapermutation avec le dernier élément non encore placé
PROCÉDURE triSelectionIteratif
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
TANT QUE n>1 FAIRE
p indicePlusGrand(t,n)
permute(t[p],t[n-1])
n n-1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 22 - Tri par sélection (selection sort)
66/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
recherche de l’indice du plus grand élément du tableau
parcours du tableau mémorisant la position du plus grand élé-ment rencontré jusqu’à présent
FONCTION indicePlusGrand
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
RÉSULTAT : ENT
ipg 0 , i 1
TANT QUE i < n FAIRE
SI t[i] > t[ipg] ALORS
ipg i
FIN SI
i i+1
FIN TANT QUE
RETOUR ipg
FIN PROCÉDURE
Algorithme 23 - Indice plus grand (annexe du selection sort)
67/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
itération sur la recherche de la position de l’élément no i et inser-tion à sa place
PROCÉDURE triInsertion
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
i 1
TANT QUE i<n FAIRE
x t[i]
p rechercheDicho(t, i, x) // voir algo 18
decaleD(t, p, i-1) // voir algo 15
t[p] x , i i+1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 24 - Tri par insertion (insert sort)
68/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
trie les sous tableaux distants de n/2, (n/2)/2, etc..
PROCÉDURE triShell
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
h Ent(n/2)
TANT QUE h>0 FAIRE
st 0
TANT QUE st<h FAIRE
triSousTableau(t, st, n, h)
st st+1
FIN TANT QUE
h Ent(h/2)
FIN TANT QUE
FIN PROCÉDURE
Algorithme 25 - Tri Shell
69/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
anexe du tri shell : tri les éléments d’un tableau compris entreindices debut (inclus) et fin (exclus) et distants d’un écart donné
compare des t[i] et t[i+ecart]
PROCÉDURE triSousTableau
DONN. MOD.: t∈ TAB de TS
DONNÉES : debut∈ ENT , fin∈ ENT , ecart∈ ENT
i debut
TANT QUE i+ecart < fin FAIRE
j i+ecart
TANT QUE j - ecart ≥0 et t[j-ecart]>t[j] FAIRE
permute(t[j-ecart], t[j])
j j-ecart
FIN TANT QUE
i i+ecart
FIN TANT QUE
FIN PROCÉDURE
Algorithme 26 - Tri SousTableau (annexe tri Shell)
70/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tri shell
H=4 Départ=0
40
01
62
13
34
75
56
27
3 0 6 1 4 7 5 2
3 0 6 1 4 7 5 2
3 0 5 1 4 7 6 2
H=2 Départ=0
30
01
52
13
44
75
66
27
3 0 5 1 4 7 6 2
3 0 4 1 5 7 6 2
3 0 4 1 5 7 6 2
71/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tri shell (2)
H=2 Départ=1
30
01
42
13
54
75
66
27
3 0 4 1 5 7 6 2
3 0 4 1 5 7 6 2
3 0 4 1 5 2 6 7
H=1 Départ=0
30
01
42
13
54
25
66
77
0 3 4 1 5 2 6 7
0 3 4 1 5 2 6 7
0 3 1 4 5 2 6 7
0 1 3 4 5 2 6 7
0 1 3 4 5 2 6 7
72/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un tri shell (3)
H=1 Départ=0 (suite)
00
11
32
43
54
25
66
77
0 1 3 4 2 5 6 7
0 1 3 2 4 5 6 7
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
73/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
partitionne le tableau compris entre les indices d et f en deuxsous-tableaux disjoints (les petits et les grands), trie récursive-ment chacun des sous-tableaux
// Appeler un tri initial avec triRapide(t, 0, n-1)
PROCÉDURE triRapide
DONN. MOD.: t∈ TAB de TS
DONNÉES : d∈ ENT , f∈ ENT
SI f-d ≥ 1 ALORS
p partition(t, d, f)
triRapide(t, d, p-1)
triRapide(t, p+1, f)
FIN SI
FIN PROCÉDURE
Algorithme 27 - Tri rapide (quick sort)
74/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
place les petits devant et les grands derrière; retourne la positionde la frontière
FONCTION partition
DONN. MOD.: t∈ TAB de TS
DONNÉES : d∈ ENT , f∈ ENT
RÉSULTAT : ENT
id d, if f
TANT QUE id<if FAIRE
SI t[id+1]≤t[d] ALORS
id id+1
SINON
permute(t[id+1], t[if])
if if-1
FIN SI
FIN TANT QUE
permute(t[d], t[id])
RETOUR id
FIN FONCTION
Algorithme 28 - Partition (annexe du quick sort)
75/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un quick
Quicksort1 [0..8[
40
01
62
13
34
75
56
27
4 0 6 1 3 7 5 2
4 0 2 1 3 7 5 6
4 0 2 1 3 7 5 6
4 0 2 1 3 7 5 6
4 0 2 1 3 7 5 6
4 0 2 1 3 5 7 6
4 0 2 1 3 5 7 6
3 0 2 1 4 5 7 6
Quicksort2 [0..4[
30
01
22
13
44
55
76
67
3 0 2 1 4 5 7 6
3 0 2 1 4 5 7 6
1 0 2 3 4 5 7 6
Quicksort3 [0..3[
10
01
22
33
44
55
76
67
1 0 2 3 4 5 7 6
1 0 2 3 4 5 7 6
0 1 2 3 4 5 7 6
76/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un quick (2)
Quicksort3 [0..3[ (fin)Quicksort2 [0..4[ (fin)
00
11
22
33
44
55
76
67
Quicksort2 [5..8[
00
11
22
33
44
55
76
67
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
Quicksort3 [6..8[
00
11
22
33
44
55
66
77
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
Quicksort3 [6..8[ (fin)Quicksort2 [5..8[ (fin)Quicksort1 [0..8[ (fin)
00
11
22
33
44
55
66
77
77/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
tri d’un tableau
considère le tableau comme un arbre presque parfait et établitune structure de tas
PROCÉDURE triParTas
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
construireTas(t, n)
n n-1
TANT QUE n>0 FAIRE
permute(t[0],t[n])
n n-1
retablirTas(t, n , 0)
FIN TANT QUE
FIN PROCÉDURE
Algorithme 29 - Tri par tas (heap sort)
78/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
transforme le tableau en un tas (chaque élément est supérieur àses fils)
itération à rebours du dernier des pères jusqu’à la racine rétablis-sant le tas
PROCÉDURE construireTas
DONN. MOD.: t∈ TAB de TS
DONNÉES : n∈ ENT
pere Ent((n - 1) / 2) // le dernier vrai père
TANT QUE pere ≥ 0 FAIRE
rétablirTas(t, n, pere)
pere pere-1
FIN TANT QUE
FIN PROCÉDURE
Algorithme 30 - Construire un tas (annexe du heap sort)
79/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap
Heapify
40
01
62
13
34
75
56
27
40
01
62
13
34
75
56
27
40
01
62
23
34
75
56
17
40
01
62
23
34
75
56
17
40
01
72
23
34
65
56
17
40
01
72
23
34
65
56
17
80/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (2)
Heapify
40
31
72
23
04
65
56
17
40
31
72
23
04
65
56
17
70
31
42
23
04
65
56
17
70
31
42
23
04
65
56
17
70
31
62
23
04
45
56
17
70
31
62
23
04
45
56
17
81/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (3)
Echange
10
31
62
23
04
45
56
77
10
31
62
23
04
45
56
77
Reheap
60
31
12
23
04
45
56
77
60
31
12
23
04
45
56
77
60
31
52
23
04
45
16
77
60
31
52
23
04
45
16
77
82/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (4)
Echange
10
31
52
23
04
45
66
77
10
31
52
23
04
45
66
77
Reheap
50
31
12
23
04
45
66
77
50
31
12
23
04
45
66
77
50
31
42
23
04
15
66
77
50
31
42
23
04
15
66
77
83/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (5)
Echange
10
31
42
23
04
55
66
77
10
31
42
23
04
55
66
77
Reheap
40
31
12
23
04
55
66
77
40
31
12
23
04
55
66
77
Echange
00
31
12
23
44
55
66
77
00
31
12
23
44
55
66
77
84/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (6)
Reheap
30
01
12
23
44
55
66
77
30
01
12
23
44
55
66
77
Reheap
30
21
12
03
44
55
66
77
30
21
12
03
44
55
66
77
Echange
00
21
12
33
44
55
66
77
00
21
12
33
44
55
66
77
85/151 Jean-Claude GEORGES Algorithmique et structures de données
Les tris
Exécution d’un heap (7)
Reheap
20
01
12
33
44
55
66
77
20
01
12
33
44
55
66
77
Echange
10
01
22
33
44
55
66
77
10
01
22
33
44
55
66
77
Echange
00
11
22
33
44
55
66
77
00
11
22
33
44
55
66
77
86/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Les listes chaînéesUne liste chaînée est ensemble de données (les maillons), chacund’entre eux étant constitué d’un contenu (valeur) et d’un chaînage(pointeur en C) vers le maillon suivant de la liste.
Une liste particulière (noté ici NIL) indique la liste vide et sert desentinelle pour marquer le dernier élément de la liste.
L’accès au contenu d’un maillon m sera noté CONTENUm (lecture etécriture) et l’accès à la sous-liste suivant ce maillon sera notéSUIVANTm (lecture et écriture).
Le maillon de tête d’une liste lst sera noté TETElst et l’adressed’un maillon m sera noté ADRESSEm
87/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Les listes
lst
Une liste
3x
5
y
8z
1a
6b
l0
Une liste vide
/* Exemple de déclaration C */
typedef struct _m int contenu;struct _m * suivant;
maillon, * liste;
int main() maillon b = 6, NULL;maillon a = 1, &b;maillon z = 8, &a;maillon y = 5, &z;maillon x = 3, &y;liste lst = &x;liste l0 = NULL;return 0;
88/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
parcours pour traiter chaque élément d’une liste chaînée.
traitement, puis passage au suivant tant qu’on ne rencontre pas laliste vide.
PROCÉDURE parcoursIterListe
DONNÉES : lst∈ LISTE
TANT QUE lst 6= NIL FAIRE
m TETElst
traite(CONTENUm) // contenu du premier maillon
lst SUIVANTm // suivant du premier maillon
FIN TANT QUE
FIN PROCÉDURE
Algorithme 31 - Parcours itératif d’une liste chaînée
89/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
parcours pour traiter chaque élément d’une liste chaînée.
traitement, puis appel récursif au traitement du suivant
PROCÉDURE parcoursRecListe
DONNÉES : lst∈ LISTE
SI lst 6= NIL ALORS
m TETElst
traite(CONTENUm)
parcoursRecListe(SUIVANTm)
FIN SI
FIN PROCÉDURE
Algorithme 32 - Parcours récursif d’une liste chaînée
90/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Affichage d’une liste
void affiche (liste lst) /* affiche la liste sous la forme(1, 2, 3) ou () si liste vide */
printf("(");if (lst != NULL)
printf("%d", lst->contenu);lst = lst->suivant;while (lst != NULL)
printf(", %d", lst->contenu);lst = lst->suivant;
printf(")\n");
91/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Longueur d’une liste
int longueur(liste l) /* retourne la longueur de la liste (0 pour liste vide) */
if (l == NULL) return 0;
else
return 1 + longueur(l->suivant);
92/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
ajouter un nouvel élément en tête de liste
faire suivre le maillon par la liste actuelle, retourner le maillon
FONCTION insereEnTeteFct
DONNÉES : lst∈ LISTE
DONN. MOD.: m∈ MAILLON
RÉSULTAT : LISTE
SUIVANTm lst
RETOUR ADRESSEm
FIN FONCTION
Algorithme 33 - Insertion en tête de liste chaînée (fonction)
Si le maillon inséré est la tête d’une liste de plusd’un élément, le reste de la liste est perdu de parle nouveau chaînage.
93/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Insertion en tête de liste (fonction)
/* à appeler avec :lst = insereTeteFct(lst, &m)*/liste insereTeteFct(liste lst, maillon * pm)
pm->suivant = lst;return pm;
94/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
ajouter un nouvel élément en tête de liste
faire suivre le nouveau maillon de la liste actuelle, modifier la listepour que le le nouveau maillon soit sa tête
PROCÉDURE insereEnTeteProc
DONN. MOD.: lst∈ LISTE , m∈ MAILLON
SUIVANTm lst
lst ADRESSEm
FIN PROCÉDURE
Si le maillon inséré est la tête d’une liste de plus d’un élé-ment, le reste de la liste est perdu de par le nouveau chaî-nage.
Algorithme 34 - Insertion en tête de liste chaînée (procédure)
95/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Insertion en tête de liste (procédure)
/* à appeler avec :insereTeteProc(&l, &m)*/void insereTeteProc(liste * pl, maillon * pm)
pm->suivant = *pl;*pl = pm;
96/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
supprimer la tête de liste
retourner le suivant de la tête actuelle
FONCTION supprimeTeteFonc
DONNÉES : lst∈ LISTE
RETOUR SUIVANTTETElst
FIN FONCTION
La liste est supposée contenir au moins un élément
Algorithme 35 - Supprimer en tête de liste chaînée (fonction)
97/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Supprimer la tête de liste (fonction)
/* à appeler avec :l = supprimeTeteFct(l)*/liste supprimeTeteFct(liste l)
l = l->suivant;return l;
98/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
supprimer la tête de liste
modifier la liste pour que le la nouvelle tête soit le suivant de latête actuelle
PROCÉDURE supprimeTeteProc
DONN. MOD.: lst∈ LISTE
lst SUIVANTTETElst
FIN PROCÉDURE
La liste est supposée contenir au moins un élément
Algorithme 36 - Suprimer en tête de liste chaînée (procédure)
99/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Supprimer la tête de liste (procédure)
/* à appeler avec :supprimeTeteProc(&l)*/void supprimeTeteProc(liste * pl)
*pl = (*pl)->suivant;
100/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
ajouter un nouvel élément à sa place dans la liste
si le maillon doit être en tête (liste vide ou maillon<tête), inséreren tête, sinon appel récursif sur le suivant
FONCTION insereTrieFR
DONNÉES : lst∈ LISTE
DONN. MOD.: m∈ MAILLON
RÉSULTAT : LISTE
SI lst= NIL ou CONTENUm < CONTENUTETElst ALORS
RETOUR insereTeteFct(lst,m)
SINON
SUIVANTTETElst insereTrieFR(SUIVANTTETElst,m)
RETOUR lst
FIN SI
FIN FONCTION
Algorithme 37 - Insertion dans une liste triée (fonction récursive)
101/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Insertion dans une liste triée (fonction récursive)
/* à appeler avec :l = insereTrieFctRec(l, &m)*/liste insereTrieFctRec(liste lst, maillon * pm)
if (lst == NULL || pm -> contenu < lst->contenu)return insereTeteFct(lst, pm);
else lst->suivant = insereTrieFctRec(lst->suivant, pm);return lst;
102/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
ajouter un nouvel élément dans une liste triée
parcourir la liste jusqu’à trouver un élément supérieur. L’insérerentre l’élément précédent et l’élément supérieur
FONCTION insereTrieFctIter
DONNÉES : lst∈ LISTE
DONN. MOD.: m∈ MAILLON
SI lst = NIL ou CONTENUm<CONTENUTETElst ALORS
RETOUR insereEnTeteFct(lst,m)
SINON
av lst , ap SUIVANTTETElst
TANT QUE ap 6=NIL et CONTENUTETEap<CONTENUm FAIRE
av ap , ap SUIVANTTETEap
FIN TANT QUE
SUIVANTm ap , SUIVANTTETEav ADRESSEm
RETOUR lst
FIN SI
FIN FONCTION
Algorithme 38 - Insertion dans une liste triée (fonction itérative)
103/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Insertion dans une liste triée (fonction itérative)
/* à appeler avec :l = insereTrieFI(l, &m)*/liste insereTrieFI(liste lst, maillon * pm)
maillon *prec, *courant ;if (lst == NULL || pm->contenu < lst->contenu)
return insereTeteFct(lst, pm);prec = lst;while (prec->suivant != NULL
&& prec->suivant->contenu < pm->contenu)prec = prec->suivant;
pm->suivant = prec->suivant;prec->suivant = pm;return lst;
104/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
supprime le premier maillon égal au maillon précisé
si maillon < tête, retour liste. Si maillon = tête, supprime tête. Simaillon>tête, le supprimer dans la suite de liste.
FONCTION supprimeTrieFR
DONNÉES : lst∈ LISTE
DONN. MOD.: m∈ MAILLON
RÉSULTAT : LISTE
SI lst= NIL ou CONTENUm < CONTENUTETElst ALORS
RETOUR lst
SINON SI CONTENUm = CONTENUTETElst
RETOUR supprimeTeteFonc(lst)
SINON
SUIVANTTETElst supprimeTrieFR(SUIVANTTETElst,m)
RETOUR lst
FIN SI
FIN SI
FIN FONCTION
Algorithme 39 - Suppression dans liste triée (fonction récursive)
105/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
Suppression dans une liste triée (fonction récursive)
/* à appeler avec :l = supprimeTrieFctRec(l, &m)*/liste supprimeTrieFctRec(liste lst, maillon * pm)
if (lst == NULL || pm->contenu < lst->contenu)return lst;
if (pm->contenu == lst->contenu)return supprimeTeteFct(lst);
lst->suivant = supprimeTrieFctRec(lst->suivant, pm);return lst;
106/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
modifie la liste et ses chaînages pour qu’elle soit triée
si la liste contient moins de deux éléments, ne fait rien. Scinde laliste en deux sous-listes. Trie ces deux sous-listes. Fusionne lesdeux sous listes triées
PROCÉDURE triefusion
DONN. MOD.: lst∈ LISTE
SI lst 6= NIL ET SUIVANTTETElst 6= NIL ALORS
scinder(lst, l1, l2)
triefusion(l1)
triefusion(l2)
fusionner(lst, l1, l2)
FIN SI
FIN PROCÉDURE
Algorithme 40 - Tri d’une liste : merge sort
107/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
modifie les chaînages d’une liste et crée deux sous-listes de taillesidentiques (à 1 près)
La liste contient au moins deux éléments. Deux itérateurs delistes (un normal et un deux fois plus rapide). Lorsque le plusrapide est arrivé en bout de liste, le plus lent en est à la moitié.
PROCÉDURE scinder
DONN. MOD.: lst, l1, l2∈ LISTE
lente lst , rapide SUIVANTTETElst
TANT QUE rapide 6= NIL ET SUIVANTTETErapide 6= NIL FAIRE
rapide SUIVANTTETErapide , rapide SUIVANTTETErapide
lente SUIVANTTETElente
FIN TANT QUE
l1 lst , l2 SUIVANTTETElente
SUIVANTTETElente NIL
FIN PROCÉDURE
Algorithme 41 - Scinder (annexe du merge sort)
108/151 Jean-Claude GEORGES Algorithmique et structures de données
Les listes chaînées
crée une seule liste triée composée des deux listes initiales
Si une des deux listes est vide, la liste fusionnée, c’est l’autre !Prendre le plus petit des premiers éléments des deux listes et luichaîner la fusion de la suite de la liste concernée avec l’autre liste.
FONCTION fusionner
DONN. MOD.: l1, l2∈ LISTE
RÉSULTAT : LISTE
SI l1 = NIL ALORS
RETOUR l2
SINONSI l2 = NIL ALORS
RETOUR l1
SINONSI CONTENUTETEl1 ≤ CONTENUTETEl2
SUIVANTTETEl1 fusionner(SUIVANTTETEl1, l2) , RETOUR l1
SINON
SUIVANTTETEl2 fusionner(SUIVANTTETEl2, l1) , RETOUR l2
FIN SI
FIN FONCTION
Algorithme 42 - fusionner (annexe du merge sort)
109/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéTypes de complexité
Évaluation asymptotique de la quantité de ressources à utiliser pourexécuter.
• en temps• en mémoire
• en moyenne• au pire
110/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéTypes de complexité
Évaluation asymptotique de la quantité de ressources à utiliser pourexécuter.• en temps
• en mémoire
• en moyenne• au pire
110/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéTypes de complexité
Évaluation asymptotique de la quantité de ressources à utiliser pourexécuter.• en temps• en mémoire
• en moyenne• au pire
110/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéTypes de complexité
Évaluation asymptotique de la quantité de ressources à utiliser pourexécuter.• en temps• en mémoire
• en moyenne
• au pire
110/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéTypes de complexité
Évaluation asymptotique de la quantité de ressources à utiliser pourexécuter.• en temps• en mémoire
• en moyenne• au pire
110/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.
• Accès mémoire en temps constant (pas de mémoire cache, pasde mémoire virtuelle)• Affectations types simples en temps constant• Opérations arithmétiques (+,-,*,/) en temps constant• Pas d’exécution parallèle• On ne garde que le terme dominant d’une expression de la
complexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.• Accès mémoire en temps constant (pas de mémoire cache, pas
de mémoire virtuelle)
• Affectations types simples en temps constant• Opérations arithmétiques (+,-,*,/) en temps constant• Pas d’exécution parallèle• On ne garde que le terme dominant d’une expression de la
complexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.• Accès mémoire en temps constant (pas de mémoire cache, pas
de mémoire virtuelle)• Affectations types simples en temps constant
• Opérations arithmétiques (+,-,*,/) en temps constant• Pas d’exécution parallèle• On ne garde que le terme dominant d’une expression de la
complexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.• Accès mémoire en temps constant (pas de mémoire cache, pas
de mémoire virtuelle)• Affectations types simples en temps constant• Opérations arithmétiques (+,-,*,/) en temps constant
• Pas d’exécution parallèle• On ne garde que le terme dominant d’une expression de la
complexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.• Accès mémoire en temps constant (pas de mémoire cache, pas
de mémoire virtuelle)• Affectations types simples en temps constant• Opérations arithmétiques (+,-,*,/) en temps constant• Pas d’exécution parallèle
• On ne garde que le terme dominant d’une expression de lacomplexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéHypothèses simplificatrices
Tous les détails de l’exécution ne sont pas forcément pris en compte.• Accès mémoire en temps constant (pas de mémoire cache, pas
de mémoire virtuelle)• Affectations types simples en temps constant• Opérations arithmétiques (+,-,*,/) en temps constant• Pas d’exécution parallèle• On ne garde que le terme dominant d’une expression de la
complexité : si le temps d’exécution d’un algorithme d’entrée nest égal à 50n2 + 7n + 3 log(n), on dira que l’algorithme est enΘ(n2).
111/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéSoumission et domination (notations Knuth)
notation définitionf ∈ O(g) ∃k > 0 ∃n0 ∀n > n0 |f (n)| ≤ k |g(n)|f ∈ Ω(g) ∃k > 0 ∃n0 ∀n > n0 |f (n)| ≥ k |g(n)|f ∈ Θ(g) ∃k1, k2 > 0 ∃n0 ∀n > n0 k1|g(n)| ≤ |f (n)| ≤ k2|g(n)|
112/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : bloc d’instructions
Pour un bloc constitué de n instructions :
complexite(bloc) =n∑
k=1
complexite(instructionk)
113/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : conditionnelles
Pour une instruction SI...ALORS..SINON
complexite(SI) = complexite(test)+max(complexite(blocalors), complexite(blocsinon))
114/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : itérations
Pour une boucle TANTQUE exécutée n fois
complexite(TANTQUE) =n∑
k=0
complexite(testk)
+n∑
k=1
complexite(corpsbouclek )
115/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : appel de fonction
Pour un appel f (expr1, expr2, ..., exprn)
complexite(f(e1, e2, ..., en)) =n∑
k=1
complexite(eval(ek))
+complexite(passage)+complexite(corpsf )+complexite(retour)
116/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : exemple 1
Complexité de la puissance itérative classique
p ← 1 # T_aff
i ← 1 # T_aff
TANTQUE i <= n : # T_test | n+1 fois
p ← p * x # T_mult + T_aff | n fois
i ← i + 1 # T_add + T_aff |
FIN TANTQUE
RETOUR ← p # T_retour
Total : n * (T_test + T_mult + T_aff + T_add + T_aff)
+ (T_aff + T_aff + T_retour + T_test)
= a n + b
Complexité : Θ(n)
117/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéRègles de calcul de complexité : exemple 2
Complexité de la puissance rapide de ap
f, x, n = 1, a, p # 3 T_aff
TANT QUE n>0 : # T_test | 2+E(log_2(p))
SI n %2 != 0 ALORS # T_test | 1+E(log_2(p))
f, n = x*f, n-1 # 2 T_aff | 2T_aff+T_mult+T_add
FIN SI
x, n = x*x, n/2 # 2 T_aff | 2T_aff+T_mult+T_div
FIN TANT QUE
RETOUR = f # T_retour
Total (au pire) : (3*T_aff + T_test + T_retour) +
(1+E(log_2(p))) * (T_Test+4*T_aff+2*T_mult+T_add+T_div)
= a log_2(p) + b
Complexité : Θ(log2(n)) ou Θ(log(n))
118/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéComparaisons de croissance (1)
1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0x
0
20
40
60
80
100
120
140
160y
exp(x)
x3
x2
x log(x)
x√x
log(x)
119/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéComparaisons de croissance (2)
2 3 4 5 6 7 8 9 10x
10-1
100
101
102
103
104
105y
exp(x)
x3
x2
x log(x)
x√x
log(x)
120/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéComparaisons de croissance (3)
Le retour des deux féesFâchée que son coffre soit moins rempli le jour du 22e anniversairede la princesse, la fée Linearia modifia son sort : à chaque seconde,le coffre se garnira d’un million d’euros supplémentaires (le coffre estvide au départ).La fée Exponenzia sourit sans modifier son sort. Chaque année lecoffre verra sa somme doubler (le coffre contient 1 centime audépart).
Quel âge aura la princesse lorsque le coffre d’Exponenzia contiendraplus que le coffre de Linearia ?
121/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéComparaisons de croissance (3)
C’est le jour de son 58e anniversaire (PIB mondial 2011 : 7 · 1013$).
54 55 56 57 58 59 60 61 621014
1015
1016
1017
Exponanzia
Linearia
122/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéClasses de problème
On divise les problèmes en différentes classes :
• P (Polynomiaux) : problèmes dont les solutions peuvent êtrecalculées en un temps polynomial (problèmes faciles)• NP (Non-déterministes Polynomiaux) : problèmes dont on ne
connaît pas d’algorithme dans P, mais dont les solutions peuventêtre vérifiées en un temps polynomial (problèmes difficiles)• NP-complet (Non-déterministes Polynomiaux complets) :
problèmes qui peuvent se ramener à n’importe quel problème deNP par une réduction polynomiale (problèmes difficilesprototypes)
P=NP ?Le Clay Mathematics Institute propose 1 000 000 $ à quidémontrera ou infirmera cette conjecture.
123/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéClasses de problème
On divise les problèmes en différentes classes :• P (Polynomiaux) : problèmes dont les solutions peuvent être
calculées en un temps polynomial (problèmes faciles)
• NP (Non-déterministes Polynomiaux) : problèmes dont on neconnaît pas d’algorithme dans P, mais dont les solutions peuventêtre vérifiées en un temps polynomial (problèmes difficiles)• NP-complet (Non-déterministes Polynomiaux complets) :
problèmes qui peuvent se ramener à n’importe quel problème deNP par une réduction polynomiale (problèmes difficilesprototypes)
P=NP ?Le Clay Mathematics Institute propose 1 000 000 $ à quidémontrera ou infirmera cette conjecture.
123/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéClasses de problème
On divise les problèmes en différentes classes :• P (Polynomiaux) : problèmes dont les solutions peuvent être
calculées en un temps polynomial (problèmes faciles)• NP (Non-déterministes Polynomiaux) : problèmes dont on ne
connaît pas d’algorithme dans P, mais dont les solutions peuventêtre vérifiées en un temps polynomial (problèmes difficiles)
• NP-complet (Non-déterministes Polynomiaux complets) :problèmes qui peuvent se ramener à n’importe quel problème deNP par une réduction polynomiale (problèmes difficilesprototypes)
P=NP ?Le Clay Mathematics Institute propose 1 000 000 $ à quidémontrera ou infirmera cette conjecture.
123/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéClasses de problème
On divise les problèmes en différentes classes :• P (Polynomiaux) : problèmes dont les solutions peuvent être
calculées en un temps polynomial (problèmes faciles)• NP (Non-déterministes Polynomiaux) : problèmes dont on ne
connaît pas d’algorithme dans P, mais dont les solutions peuventêtre vérifiées en un temps polynomial (problèmes difficiles)• NP-complet (Non-déterministes Polynomiaux complets) :
problèmes qui peuvent se ramener à n’importe quel problème deNP par une réduction polynomiale (problèmes difficilesprototypes)
P=NP ?Le Clay Mathematics Institute propose 1 000 000 $ à quidémontrera ou infirmera cette conjecture.
123/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéClasses de problème
On divise les problèmes en différentes classes :• P (Polynomiaux) : problèmes dont les solutions peuvent être
calculées en un temps polynomial (problèmes faciles)• NP (Non-déterministes Polynomiaux) : problèmes dont on ne
connaît pas d’algorithme dans P, mais dont les solutions peuventêtre vérifiées en un temps polynomial (problèmes difficiles)• NP-complet (Non-déterministes Polynomiaux complets) :
problèmes qui peuvent se ramener à n’importe quel problème deNP par une réduction polynomiale (problèmes difficilesprototypes)
P=NP ?Le Clay Mathematics Institute propose 1 000 000 $ à quidémontrera ou infirmera cette conjecture.
123/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéDiviser pour régner (1)
• réduire un problème en un ou plusieurs sous-problèmes,• les résoudre récursivement,• fusionner les solutions.
124/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéDiviser pour régner (2)
Un problème : quelques opérations + un sous-problèmeSi C (n) = C (n/k) + g(n), alors C (n) = C (1) +
∑|logk (n)|i=1 g(k i )
Par exemple, recherche dichotomique, exponentiation rapide.
125/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéDiviser pour régner (3)
Un problème : quelques opérations + plusieurs sous problèmes demême tailleThéorème 1Si C (n) = aC (n/b) + cn, avec C (1) = constante alors
• si a < b C (n) = O(n)
• si a = b C (n) = O(n log(n))• si a > b C (n) = O(nlogb(a))
126/151 Jean-Claude GEORGES Algorithmique et structures de données
ComplexitéDiviser pour régner (4)
Théorème 2Si C (n) = aC (n/k) + f (n) alors
• si f (n) = O(nlogka−ε) avec ε > 0alors C (n) = Θ(nlogk (a))
• si f (n) = Θ(nlogka)alors C (n) = Θ(nlogk (a)log(n))
• si f (n) = Ω(nlogka+ε) avec ε > 0 et si il existe c < 1 tel quea.f (n/k) <= cf (n) pour n suffisamment grand,alors C (n) = Θ(f (n))
127/151 Jean-Claude GEORGES Algorithmique et structures de données
Majorité absolueL’énoncé du problème
Soit un tableau de N éléments (couleurs de pixels dans une image,nombre de voix dans une élection, etc.)Existe-t-il un élément majoritaire (présent plus de N/2 fois) ?
128/151 Jean-Claude GEORGES Algorithmique et structures de données
Majorité absolueApproche simpliste
Pour chaque élément X du tableau (N éléments)Compter son nombre d’occurrences (N comparaisons)S’il est supérieur à N/2 AlorsRetourner X
Retourner PAS_DE_MAJORITE
Complexité Θ(n2)
129/151 Jean-Claude GEORGES Algorithmique et structures de données
Majorité absolueDiviser pour régner
Remarque : si un élément est majoritaire, il l’est forcément dans unedes deux moitiés du tableau
Si N=1 Alors Retourner T[0]m1 = Majoritaire(T,N/2)m2 = Majoritaire(Adresse(T+N/2),N-N/2)Si m1=m2 AlorsRetourner m1
Si m1 != PAS_DE_MAJORITE AlorsSi frequence(m1,T,N)>N/2 Alors Retourner m1
Si m2 != PAS_DE_MAJORITE AlorsSi frequence(m2,T,N) > N/2 Alors Retourner m2
Retourner PAS_DE_MAJORITE
Complexité Θ(n log(n))
130/151 Jean-Claude GEORGES Algorithmique et structures de données
Majorité absolueUn coup de génie : Boyer & Moore
Remarque : deux éléments consécutifs différents peuvent être enlevésdu tableau sans changer l’élément majoritaire
Compteur = 0Pour chaque élément X du tableauSi Compteur = 0 AlorsCandidat = xCompteur = 1
SinonSi x = Candidat Alors Compteur = Compteur + 1Sinon Compteur = Compteur - 1
Si frequence(Candidat,T,N) > N/2 Alors Retourner CandidatRetourner PAS_DE_MAJORITE
Complexité Θ(n)
131/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingLe contexte
• Comment trouver la position d’un motif dans un texte(Chercher dans un éditeur de texte ou un navigateur)
• Chercher("aababcabcdabcde","bcd")
• Chercher("aababcabcdabcde","bcd") → 7
132/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingLe contexte
• Comment trouver la position d’un motif dans un texte(Chercher dans un éditeur de texte ou un navigateur)• Chercher("aababcabcdabcde","bcd")
• Chercher("aababcabcdabcde","bcd") → 7
132/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingLe contexte
• Comment trouver la position d’un motif dans un texte(Chercher dans un éditeur de texte ou un navigateur)• Chercher("aababcabcdabcde","bcd")
• Chercher("aababcabcdabcde","bcd") → 7
132/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non
• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non
• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non
• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non
• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non
• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non
• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non
• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Faire glisser une fenêtre de même taille que la longueur du motifau-dessus du texte.S’arrêter dès que le contenu de la fenêtre et du motif coïncidentparfaitement ou que la fenêtre sort du texte.Par exemple : Chercher("aababcabcdabcde","bcd")
• aab abcabcdabcde == bcd ? : non• a aba bcabcdabcde == bcd ? : non• aa bab cabcdabcde == bcd ? : non• aab abc abcdabcde == bcd ? : non• aaba bca bcdabcde == bcd ? : non• aabab cab cdabcde == bcd ? : non• aababc abc dabcde == bcd ? : non• aababca bcd abcde == bcd ? : oui
133/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Le programme en Python :
def naif(texte, motif, départ=0) :
for i in range(départ, len(texte) - len(motif) + 1) :
for j in range(len(motif)) :
if texte[i+j]!=motif[j] :
break
else :
return i
return -1
134/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingApproche naïve
Le programme en C :
#include <string.h>
int pm1(char texte[], char motif[], int depart)
int i, j, tt, tm;
tt = strlen(texte); tm = strlen(motif);
for (i = depart; i <= tt - tm; ++i)
for (j = 0; j < tm; ++j)
if (texte[i+j] != motif[j])
break;
if (j>=tm)
return i;
return -1;
135/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
KARP et RABIN (1987)
Idée : on ne teste la sous-chaine texte[i:i+lgr(motif)-1] que si elle ades chances de correspondre au motif.Pour cela, utiliser une fonction de hachage qui doit :
être rapidement calculable, connaissant sa valeur sur lasous-chaîne précédenteprovoquer le moins possible de collisions (deux sous-chaînesdistinctes ayant le même résultat)
136/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Prenons comme exemple une chaîne de caractères ne contenant quedes chiffres, un motif égal à 2019 et la fonction de hachageretournant la somme des quatre prochains chiffres.
texte 1 2 5 2 0 5 3 0 2 0 1 9h 10
9 12 10 8 10 5 3 12
motif 2 0 1 9
Étape 0 h(motif ) = 12, h(texte[0 : 3]) = 10 on passe
Étape 1 h(motif ) = 12, h(texte[1 : 4]) = 9 on passeÉtape 2 h(motif ) = 12, h(texte[2 : 5]) = 12 on compareÉtape 3 h(motif ) = 12, h(texte[3 : 6]) = 10 on passeÉtape 4 h(motif ) = 12, h(texte[4 : 7]) = 8 on passeÉtape 5 h(motif ) = 12, h(texte[5 : 8]) = 10 on passeÉtape 6 h(motif ) = 12, h(texte[6 : 9]) = 5 on passeÉtape 7 h(motif ) = 12, h(texte[7 : 10]) = 3 on passeÉtape 8 h(motif ) = 128, h(texte[8 : 11]) = 12 on compare
137/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Prenons comme exemple une chaîne de caractères ne contenant quedes chiffres, un motif égal à 2019 et la fonction de hachageretournant la somme des quatre prochains chiffres.
texte 1 2 5 2 0 5 3 0 2 0 1 9h 10 9
12 10 8 10 5 3 12
motif 2 0 1 9
Étape 0 h(motif ) = 12, h(texte[0 : 3]) = 10 on passeÉtape 1 h(motif ) = 12, h(texte[1 : 4]) = 9 on passe
Étape 2 h(motif ) = 12, h(texte[2 : 5]) = 12 on compareÉtape 3 h(motif ) = 12, h(texte[3 : 6]) = 10 on passeÉtape 4 h(motif ) = 12, h(texte[4 : 7]) = 8 on passeÉtape 5 h(motif ) = 12, h(texte[5 : 8]) = 10 on passeÉtape 6 h(motif ) = 12, h(texte[6 : 9]) = 5 on passeÉtape 7 h(motif ) = 12, h(texte[7 : 10]) = 3 on passeÉtape 8 h(motif ) = 128, h(texte[8 : 11]) = 12 on compare
137/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Prenons comme exemple une chaîne de caractères ne contenant quedes chiffres, un motif égal à 2019 et la fonction de hachageretournant la somme des quatre prochains chiffres.
texte 1 2 5 2 0 5 3 0 2 0 1 9h 10 9 12
10 8 10 5 3 12
motif 2 0 1 9
Étape 0 h(motif ) = 12, h(texte[0 : 3]) = 10 on passeÉtape 1 h(motif ) = 12, h(texte[1 : 4]) = 9 on passeÉtape 2 h(motif ) = 12, h(texte[2 : 5]) = 12 on compare
Étape 3 h(motif ) = 12, h(texte[3 : 6]) = 10 on passeÉtape 4 h(motif ) = 12, h(texte[4 : 7]) = 8 on passeÉtape 5 h(motif ) = 12, h(texte[5 : 8]) = 10 on passeÉtape 6 h(motif ) = 12, h(texte[6 : 9]) = 5 on passeÉtape 7 h(motif ) = 12, h(texte[7 : 10]) = 3 on passeÉtape 8 h(motif ) = 128, h(texte[8 : 11]) = 12 on compare
137/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Prenons comme exemple une chaîne de caractères ne contenant quedes chiffres, un motif égal à 2019 et la fonction de hachageretournant la somme des quatre prochains chiffres.
texte 1 2 5 2 0 5 3 0 2 0 1 9h 10 9 12 10
8 10 5 3 12
motif 2 0 1 9
Étape 0 h(motif ) = 12, h(texte[0 : 3]) = 10 on passeÉtape 1 h(motif ) = 12, h(texte[1 : 4]) = 9 on passeÉtape 2 h(motif ) = 12, h(texte[2 : 5]) = 12 on compareÉtape 3 h(motif ) = 12, h(texte[3 : 6]) = 10 on passe
Étape 4 h(motif ) = 12, h(texte[4 : 7]) = 8 on passeÉtape 5 h(motif ) = 12, h(texte[5 : 8]) = 10 on passeÉtape 6 h(motif ) = 12, h(texte[6 : 9]) = 5 on passeÉtape 7 h(motif ) = 12, h(texte[7 : 10]) = 3 on passeÉtape 8 h(motif ) = 128, h(texte[8 : 11]) = 12 on compare
137/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Prenons comme exemple une chaîne de caractères ne contenant quedes chiffres, un motif égal à 2019 et la fonction de hachageretournant la somme des quatre prochains chiffres.
texte 1 2 5 2 0 5 3 0 2 0 1 9h 10 9 12 10 8 10 5 3 12motif 2 0 1 9
Étape 0 h(motif ) = 12, h(texte[0 : 3]) = 10 on passeÉtape 1 h(motif ) = 12, h(texte[1 : 4]) = 9 on passeÉtape 2 h(motif ) = 12, h(texte[2 : 5]) = 12 on compareÉtape 3 h(motif ) = 12, h(texte[3 : 6]) = 10 on passeÉtape 4 h(motif ) = 12, h(texte[4 : 7]) = 8 on passeÉtape 5 h(motif ) = 12, h(texte[5 : 8]) = 10 on passeÉtape 6 h(motif ) = 12, h(texte[6 : 9]) = 5 on passeÉtape 7 h(motif ) = 12, h(texte[7 : 10]) = 3 on passeÉtape 8 h(motif ) = 128, h(texte[8 : 11]) = 12 on compare
137/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Une bonne fonction de hachage doit :être rapidement calculablec’est le cas :h(5, 2, 0, 5) = 12h(2, 0, 5, 3) = 12− 5 + 3 = 10provoquer le moins possible de collisionsce n’est pas le cas :de nombreuses séries de quatre chiffres ont même somme
138/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
Karp et Rabin proposent la fonction suivante, pour une chaîne delongueur ` quelconque :
h(Tk..k+`−1) =(Tkb
`−1 + Tk+1b`−2 + ...+ Tk+`−2b
1 + Tk+`−1b0) mod m
avec m une valeur facilitant le calcul (souvent une puissance de 2) etb un nombre premier convenablement choisi.
h(Tk+1..k+`) =(b(h(Tk..k+`−1)− b`−1Tk
)+ Tk+`
)mod m
Ainsi, le passage à la prochaine valeur reste facile et le risque decollision s’amenuise ( le modulo permet de ne pas avoir de nombrestrop grands, plus coûteux à manipuler)
139/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Karp-Rabin
def KR(motif, texte):
lgr_motif, lgr_texte = len(motif), len(texte)
h_motif, h_texte = 0, 0 # hash sur le motif, sur le texte
b , m = 2, 256
baseP = pow(b, lgr_motif - 1, m) # b^l-1 mod m
for i, c in enumerate(motif): # Calcul du h motif et texte (indice 0)
h_motif = (b * h_motif + ord(c)) % m
h_texte = (b * h_texte + ord(texte[i])) % m
for i in range(lgr_texte - lgr_motif + 1): # Recherche
if h_texte == h_motif:
for j, c in enumerate(motif):
if texte[i + j] != c: break
else: return i
if i < lgr_texte - lgr_motif: # Mise à jour du h_texte
h_texte = (b * (h_texte - ord(texte[i]) * baseP)
+ ord(texte[i + lgr_motif])) % m
return -1
140/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Knuth-Morris-Pratt
KNUTH et PRATT (1975) MORRIS (1975)
Principe : une analyse fine de l’algorithme naïf montre que desinformations ne sont pas utilisées : lorsque l’on constate unedifférence, il se peut que des éléments précédents aient correspondu.
Il est possible d’augmenter la longueur des décalages et de prendreen compte les éléments du texte qui ont déjà correspondu au motif.
141/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Knuth-Morris-Pratt
En décalant le motif, on peut avoir un préfixe v du motif quicoïncide avec un suffixe de la partie u du texte. Un tel préfixe v estappelé le bord de u. Si on note plb(k) la longueur du plus long bordde motif [0..k − 1], les comparaisons peuvent reprendre entremotif [plb(k)] et texte[i + k]
142/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Knuth-Morris-Pratt
def KMP(motif, texte):
# calcul des plus longs bords du motif
plb = [0]
for c in motif[1: ]:
j = plb[-1]
while j > 0 and c != motif[j]: j = plb[j - 1]
if c == motif[j]: j += 1
plb.append(j)
# recherche
j = 0
for i in range(len(texte)):
while j > 0 and texte[i] != motif[j]: j = plb[j - 1]
if texte[i] == motif[j]:
j += 1
if j == len(motif): return i - (j - 1)
return -1
143/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingAlgorithme de Boyer-Moore-Horspool
BOYER et MOORE (1977) HORSPOOL (1980)
Idée : partir de la fin du motifSi le caractère du texte qui ne correspond pas n’appartient pasau motif, on peut décaler de la longueur du motif.S’il appartient au motif, on peut décaler de la distance aucaractère du motif le plus à droite qui lui est égal.
Preprocess : on crée un dictionnaire des décalages à effectuer en casd’inégalité.
Le plus performant !
144/151 Jean-Claude GEORGES Algorithmique et structures de données
def BMH(motif, texte):
lgr_motif = len(motif)
lgr_texte = len(texte)
if lgr_motif > lgr_texte: return -1
decalages = dict((motif[k],lgr_motif - k - 1)
for k in range(lgr_motif - 1))
k = lgr_motif - 1
d = -1
while k < lgr_texte:
j = lgr_motif - 1
i = k
while j > d and texte[i] == motif[j]:
j -= 1
i -= 1
if j == d: return i + 1
d = -1
k += decalages.get(texte[k], lgr_motif)
return -1
145/151 Jean-Claude GEORGES Algorithmique et structures de données
Pattern matchingComparaison des algorithmes
Algorithmes implémentés en Python (temps de recherche en ms)
Motif : 40 caractères, texte : 11 129 caractères
position naif KR KMP BMH finddébut 184 0.26 0.22 0.10 0.04 0.00fin 10997 12.50 10.79 3.45 0.52 0.01
absent -1 12.46 10.84 3.29 0.43 0.01Motif : 50 000 caractères, texte : 1 000 000 caractères ACGT
position naif KR KMP BMH finddébut 100 14.53 54.96 61.64 43.56 0.17fin 949900 1382.02 1046.24 535.85 352.52 2.62
absent -1 1321.71 1026.64 566.37 334.45 2.58
146/151 Jean-Claude GEORGES Algorithmique et structures de données
Conclusion provisoireQu’est ce qui empêche de résoudre un problème
les contraintes réellesle manque de connaissanceles a-prioris
Ce n’est pas parce que les choses sont difficiles que nous ne lesfaisons pas, c’est parce que nous ne les faisons pas qu’elles noussemblent difficiles.
Sénèque
Ils ne savaient pas que c’était impossible, alors ils l’ont fait.Mark Twain
Le meilleur moment pour planter un arbre, c’était il y a 20 ans.Le deuxième meilleur moment, c’est maintenant.
Proverbe chinois
147/151 Jean-Claude GEORGES Algorithmique et structures de données
Bibliographie I
Genrich Altshuller.The innovation algorithm : TRIZ, systematic innovation and technical creativity.Technical Innovation Center, Worcester, Mass, 1999.
Jacques Arsac.Jeux et casse-tête à programmer.DUNOD, Paris ; Bruxelles ; Montréal - France, 1985.
Jon Bentley.Programming pearls.Addison-Wesley, Reading, Mass, 2000.
Elwyn R. Berlekamp, John H. Conway, and Richard K. Guy.Winning ways for your mathematical plays.A.K. Peters, Natick, Mass, 2001.
John H. Conway.On numbers and games.A.K. Peters, Natick, Mass, 2001.
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein.Introduction to algorithms.MIT Press, Cambridge, Mass, 2009.
A. K. Dewdney.The (new) Turing omnibus : 66 excursions in computer science.Henry Holt, New York, 2001.
148/151 Jean-Claude GEORGES Algorithmique et structures de données
Bibliographie II
Henry Dudeney.536 puzzles & curious problems.Scribt, S.l, 1967.
Henry Dudeney.Amusements in mathematics.Dover Publications, New York, 1970.
Henry Dudeney.The Canterbury puzzles.Dover, Mineola, NY, 2002.
Martin Gardner.The colossal book of mathematics : classic puzzles, paradoxes, and problems : number theory,algebra, geometry, probability, topology, game theory, infinity, and other topics of recreationalmathematics.Norton, New York, 2001.
Ronald Graham, Donald Knuth, and Oren Patashnik.Concrete Mathematics: A Foundation for Computer Science (2nd Edition).Addison-Wesley, 1994.
Magnus Lie Hetland.Python Algorithms: Mastering Basic Algorithms in the Python Language.Apress, 1990.
Donald Knuth.The art of computer programming.Addison-Wesley, Reading (Mass.) Harlow Menlo Park et al, 1997.
149/151 Jean-Claude GEORGES Algorithmique et structures de données
Bibliographie III
Ernst L. Leiss.A programmer’s companion to algorithm analysis.Chapman&Hall/CRC Press, 2007.
Sam Loyd.Cyclopedia of puzzles.Ishi Press International, Bronx, N.Y, 2007.
Edouard Lucas.Récréations mathématiques (4 tomes).A. Blanchard, Paris, 1992.
Zbigniew Michalewicz.How to solve it : modern heuristics.Springer, Berlin New York, 2004.
Roger Nelsen.Proofs without words : exercises in visual thinking.The Mathematical Association of America, Washington, D.C, 1993.
Nils Nilsson.Principles of artificial intelligence.Springer-Verlag, Berlin, Germany New York, N.Y, 1982.
George Pólya.Comment poser et résoudre un problème.J. Gabay, Sceaux, 1989.
150/151 Jean-Claude GEORGES Algorithmique et structures de données
Bibliographie IV
George Pólya.How to solve it : a new aspect of mathematical method.Princeton University Press, Princeton N.J, 2004.
William Poundstone.How would you move Mount Fuji? : Microsoft’s cult of the puzzle : how the world’s smartestcompanies select the most creative thinkers.Little, Brown, Boston, 2004.
Dennis Shasha.Puzzles for programmers and pros.Wiley Pub, Indianapolis, Ind, 2007.
151/151 Jean-Claude GEORGES Algorithmique et structures de données