coursAlgo_V6.ppt

Algorithmique : Volume 6
• Recherche
• Adressage dispersé
• Tris
• Complexité
Cécile Balkanski, Nelly Bensimon, Gérard Ligozat
iUT ORSA
Y
Université Paris XI
I.U.T. d'Orsay
Département Informatique
Année scolaire 2003-2004

2003-2004 Algorithmique 6 : Recherche,
complexité, tris
2
Recherche

2003-2004 Algorithmique 6 : Recherche, complexité, tris 3
Recherche
• Problème général abstrait
ensemble de valeurs E, élément a; est-ce que a  E?
réponse: booléen (x) { xE | x=a }
• plus généralement
existe-t-il x vérifiant certains critères
(x) { xE | j(x)}
trouver tous les x satisfaisant certains critères
{ xE | j(x)} (bases de données)

Recherche en informatique
• On ne travaille pas sur des ensembles mathématiques,
mais sur des structures de données particulières
• Les données peuvent être de nature complexe
(agrégats, classes)
• Exemples :
tableau
tableau trié
20 18 9 5 24 13 27 2 8 32 7 12 36 15 17 19
2 5 7 8 9 12 13 15 17 18 19 20 24 27 32 36

32
18
9
5
2
24
27
20
36
19
13
8
12
15
17
7
arbre binaire de recherche

Tri de données complexes
• Exemple de donnée complexe:
type Etudiant = agrégat
nom: chaîne
âge: entier
classement: entier
photo: fichier_GIF
fin
• on peut trier par nom (ordre alphabétique), par âge, par
classement
• pas par photo
• clés, clés primaires ex-aequo, même âge

Recherche et type de données
• On utilise divers types de données sur lesquelles
on fait des opérations de base:
- ajout
- suppression
- mise-à jour
- consultation
• Chaque structure a des avantages et des
inconvénients :
• tableau, tableau trié, arbre binaire, liste chaînée,
etc.

Recherche séquentielle
fonction rechSeq (tab , nbre , val) retourne (booléen)
{renvoie VRAI si val est dans tab, FAUX sinon}
paramètre s (D) tab: tableau[1, MAX] d'entiers
(D) nbr, val: entier
variables trouvé: booléen i: entier
début trouvé  faux
i  0
tant que non trouvé ET i < nbr faire
i  i+ 1
trouvé  (tab[i] = val)
ftq
retourne (trouvé)
fin

fonction rechSeq (tab, nbre, val) retourne(entier)
{renvoie le premier indice où se trouve val dans tab, -1 sinon}
paramètre s (D) tab: tableau [1, MAX] d'entiers
variables trouvé: booléen i: entier
début
trouvé  faux
i  0
tant que non trouvé ET i < nbr faire
i  i+1
ftq
si trouvé alors retourne (i) sinon retourne (-1) fsi
fin

Recherche avec critères
procédure rechLesMin (tab_d, nbre_d, tab_r, nbre_r, val)
{renvoie dans le tableau tab_r les éléments de tab_d  val}
paramètre s (D) tab_d: tableau [1, MAX] d'entiers,
nbr_d, val: entier
(R) tab_r: tableau [1, MAX] d'entiers, nbr_r: entier
variables id, ir: entiers
début ir  0
pour id  l à nbre_d faire
si (tab_d[id]  val)
alors irir+ 1
tab_r[ir]  tab_d[id]
fsi
fpour
fin

fonction rechMin (tab, nbre) retourne(entier)
{renvoie la plus petite valeur contenue dans le tableau tab}
paramètre s (D) tab : tableau [1, MAX] d'entiers,
nbr : entier
variables i, min : entiers
début
imin  tab[l]
pour id  2 à nbre faire
si (tab[i] < min)
alors min  tab[i]
fsi
fpour
retourne (tab[min])
fin

fonction rechPosMin (tab, nbre) retourne(entier)
{retourne le (dernier) indice de la plus petite valeur du tableau tab}
paramètre s (D) tab: tableau [1, MAX] d'entiers, nbr: entier
variables i, imin, min: entiers
début
min tab[1]
imin 1
pour id 2 à nbre faire
si (tab[i]  min)
alors min tab[i]
imin  i
fsi
fpour
retourne (imin)
fin

Recherche séquentielle dans tableau ordonné
fonction rechSeq (tab, nbre, val) retourne(entier)
{renvoie le premier indice où se trouve val s'il est dans tab, -1 sinon}
variables trouvé, dépassé : booléens ; i : entier
début
trouvé  faux; dépassé  faux; i  0
tant que non (trouvé OU dépassé) ET i < nbr faire
i  i+ 1
dépassé  (tab[i] > val)
ftq
si trouvé alors retourne (i) sinon retourne(-1)
fin

Recherche dichotomique
• Rappel: les valeurs doivent être triées !
Principe:
on vise au milieu du tableau
si l'élément visé est plus grand que val, il suffit
de chercher à gauche ; s'il est plus grand, il
suffit de chercher à droite
2 5 7 8 9 12 13 15 17 18 19 20 24 27 32 36

2 5 7 8 9 12 13 15 17 18 19 20 24 27 32 36
2 5 7 8 9 12 13 15 17 18 19 20 24 27 32 36

Recherche dichotomique
fonction rechDicho (tab, nbre, val) retourne(entier)
{renvoie un indice où se trouve val s'il est dans tab, -1 sinon}
paramètre s (D) tab : tableau [1, MAX] d'entiers
(D) nbr, val : entier
variables trouvé : booléen ; id, if, im: entiers
début
trouvé  faux; id  0 ; if  nbre + 1
tant que non trouvé ET (if - id) > 1 faire
im  (id + if)/2
trouvé  (tab[im] = val)
si (tab[im] > val) alors if  im
sinon id  im
fsi
ftq
si (id = 0) alors retourne (-1)
sinon si (tab[id]=val) alors retourne(id)
sinon retourne (-1)
fsi
fsi
fin

Recherche dichotomique: variantel
fonction rechDicho (tab, nbre, val) retourne(entier)
{renvoie le plus grand indice où se trouve val s'il est dans tab, -1 sinon}
variables id, if, im: entiers
début
id  0; if  nbre+1
tant que (if - id) > 1 faire
im  (id + if)/2
si (tab[im] > val) alors if  im
sinon id  im
fsi
ftq
si (id = 0) alors retourne (-1)
sinon si (tab[id]=val) alors retourne(id)
sinon retourne (-1)
fsi
fsi
fin

Recherche dichotomique : variante2
fonction rechDicho (tab, nbre, val) retourne (entier)
{renvoie le plus petit indice où se trouve val s'il est dans tab, -1 sinon}
variablesid, if, im: entier
début
id  0 ; if  nbre+ 1
tant que (if - id) > 1 faire
im  (id + if)/2
si (tab[im]  val) alors if  im
sinon id  im
fsi
ftq
si (if = nbre + 1) alors retourne (-1)
sinon si (tab[if]=val) alors retourne(if)
sinon retourne(-1)
fsi
fsi
fin

Recherche dans un ABR
fonction rech (unAbr, val) retourne(booléen)
{renvoieVRAl si val se trouve dans l'ABR unAbr, FAUXsinon}
paramètre s (D) unAbr: ABR
(D) val: entier
variables trouvé: booléen ; id, if, im: entiers
début
si unAbr.Vide() alors retourner (FAUX)
sinon si (unAbr.Info() = val)
alors retourner(VRAI)
sinon si (unAbr.Info() < val)
alors retourner (Rech(unAbr.FD(), val))
sinon retourner (Rech(unAbr.FG(), val))
fsi
fsi
fsi
fin

32
18
9
5
2
24
27
20
36
19
13
8
12
15
17
7
Simulation de recherche

complexité, tris
23
Adressage Dispersé

24
Adressage dispersé
• Objectif: classer M éléments dans un tableau
• Principe: dans un tableau de p cases, on classe
l'élément x, à l’indice k, donné par une fonction
d'adressage h
- classer un élément x  entier k, compris entre 1 et p
• Fonction h: h(x)=k
- la valeur k ne dépend que de l'élément x ;
- l'élément x n'est pas placé relativement aux autres
éléments

25
Quelques exemples de fonctions
d’adressage
• x : chaîne h1(x) = nombre de caractères de la chaîne
h1("Paul") = 4 h1("MmeDupont")=9
• x : entier h2(x) = somme de ses chiffres décimaux
h2(342) = 9 h2(100 340) = 8
• x : entier h3(x)= nombre de bits à 1 dans l'écriture
binaire
h3(342) = h3(101010010) = 4
• x : chaîne de caractères
h4(x) = somme des codes ASCII des caractères de la chaîne

26
Exemple de classement par la
fonction d’adressage h1
• Suite de prénoms :
- Marc, Izabelle, Paule, Jeanne, Ali, Jo, Michèle
- Codes associés par h1 (nb caractères) : 4, 8, 5, 6, 3, 2, 7
• Constatations :
- la valeur k ne dépend que de l'élément x ;
- la place de l'élément x n'est pas déterminée relativement aux autres
éléments classés...
- ...à la différence d'un tri avec relation d'ordre où la place d'un élément
est déterminée par le nombre d'éléments "meilleurs" selon cet ordre.
Jo Ali Marc Paule Jeanne Michèle Izabelle
1 2 3 4 5 6 7 8

27
Une autre fonction d’adressage
• h5 associe à c1…ck la somme :
- (Somme (rang de ci dans l’alphabet * i) modulo 9) +1
• Suite de prénoms : Marc, Izabelle, Paule, Jeanne, Jo,
Michèle
- h5 (Marc) = ((13*1+1*2+18*3+3*4) mod 9) + 1 = 81 mod 9 + 1 = 1
- h5 (Jeanne) = ((10*1+5*2+1*3+14*4+14*5+5*6) mod 9) + 1
= 179 mod 9 + 1 = 9
– h5 (Paule) = ((16*1+1*2+21*3+12*4+5*5) mod 9) + 1 = 1 mod 9 + 1 = 2
Marc Paule Jo Izabelle Michèle Jeanne
1 2 3 4 5 6 7 8 9

28
Recherche d’un élément
Algorithme de recherche d'un élément x dans
une table construite par adressage dispersé
d'une suite d'éléments :
1) on calcule le code associé à cet élément x par la
fonction d’adressage, soit p.
2) on compare le contenu de la p-ième case de la table
avec l’élément x : si identité, la recherche est positive,
sinon elle est négative.

29
Ajout d’un élément
Algorithme d'ajout d'un élément X dans une
table construite par adressage dispersé d'une
suite d'éléments:
1) on calcule le code associé à cet élément par la
fonction d'adressage, soit p.
2) on affecte l'élément à la p-ième place dans la table,
à condition toutefois que cette place ne soit pas
déjà occupée  risque de collision

30
Exemples (avec h5 )
• Recherche de "Isabelle"
- code associé par h5 : 1 et tabAdrDisp [1]  "Isabelle "
 recherche négative
• Ajout de "Ali"
- code associé par h5 : 8 ; tabAdrDisp [8] : " "
 ajout possible
• Ajout de "Lola"
- code associé par h5 : 2 ; or tabAdrDisp [2] : "Paule"
 collision
Marc Paule Jo Izabelle Michèle Ali Jeanne
1 2 3 4 5 6 7 8 9

31
Méthodes de résolution des
collisions : méthodes internes
• lnternes car on opère dans le tableau alloué
- première possibilité : on utilise la place libre dans le tableau
• Algorithme d'ajout d'un élément entré en collision :
- à partir du rang de la collision, rechercher la première place libre et y
placer l'élément entré en collision.
- arrivé à la dernière case du tableau, continuer la recherche à la première
case du tableau.
• Exemples: "Lola" (avec h5 : 2) et "Isabelle" (avec h5 : 1)
Marc Paule Lola Isabelle Jo Izabelle Michèle Ali Jeanne
1 2 3 4 5 6 7 8 9

32
Retrait d’un élément
fonction d'adressage : soit p ;
avec l'élément x :
• si identité, on le supprime puis on place dans cette
case une marque pour indiquer que l'élément
supprimé a pu provoquer d'éventuelles collisions
• si non identité, on poursuit la recherche
séquentiellement en cas d'éventuelles collisions
• arrêt si case vide ou parcours jusqu’à (p-1)

33
fonction d'adressage : soit p.
• si identité, la recherche est positive,
• sinon on poursuit la recherche séquentiellement, en
cas d’éventuelles collisions (utiliser les marques)
• arrêt avec recherche négative si case vide ou
parcours jusqu’à (p-1)

34
Exemples (avec h5 )
retrait de «Marc» (code 1)
Marc Paule Lola Isabelle Jo Izabelle Michèle Ali Jeanne
1 2 3 4 5 6 7 8 9
X Paule Lola Isabelle Jo Izabelle Michèle Ali Jeanne
1 2 3 4 5 6 7 8 9
retrait de «Ali» (code 8)
recherche de «Isabelle» (code 1)
X Paule Lola Isabelle Jo Izabelle Michèle Ali Jeanne
1 2 3 4 5 6 7 8 9
X Paule Lola Isabelle Jo Izabelle Michèle X Jeanne
1 2 3 4 5 6 7 8 9

35
Résolution interne des collisions
(suite)
• Deuxième solution: on partitionne le tableau en
deux :
- une zone d'adressage primaire
- une zone de débordement
rechercher une place libre dans la zone de
débordement et y placer l'élément entré en
collision

36
Exemple
• Ajout de «Lola» (code associé par h5 : 2)
• puis de «Isabelle» (code associé par h5 : 1)
1 2 3 4 5 6 7 8 9
Lola Isabelle
10 11 12 13 14 15
Zone de
débordement
(à la « suite »
du tableau)

37
Recherche …
fonction d'adressage, soit p
avec l'élément x : si identité, la recherche est positive,
sinon on mène une recherche séquentielle dans la
zone de débordement du tableau

38
… et retrait
• si identité, on le supprime puis on place dans cette
case une marque pour indiquer que l'élément
supprimé a pu provoquer d'éventuelles collisions
• si non identité, poursuivre la recherche
séquentiellement en cas d'éventuelles collisions,
dans la zone de débordement du tableau

39
Exemples
Recherche de «Ali» (h5 : 8), puis «Lola» (h5 : 2)
Retrait de «Marc» (h5 : 1)
Recherche «Isabelle» (h5 : 1)
1 2 3 4 5 6 7 8 9
Lola Isabelle
10 11 12 13 14 15

40
Méthodes de résolution externe des
collisions
• "Externes " car on alloue des zones de stockage
supplémentaires
• Le tableau contient, pour un code donné, deux
informations :
- une place de rangement d'un élément (principal) ;
- une liste de débordement pour les éléments entrés
en collision avec l'élément précédent

41
Ajout d’un élément
- Créer la liste de débordement associée à ce code si
celle-ci n'existe pas encore,
- puis ajouter à cette liste le nouvel élément
• Exemple (avec h5): ajout de « Lola » (code 2)
Lola
1 2 3 4 5 6 7 8 9

42
Exemples (suite)
Lola
ajout de « Isabelle » (1)
Isabelle
1 2 3 4 5 6 7 8 9
ajout de « José » (1)
1 2 3 4 5 6 7 8 9
Isabelle
José Lola

43
2) on compare le contenu de la première information de
la p-ième case de la table avec l'élément x
• si identité, la recherche est positive ;
• sinon, on mène une recherche séquentielle dans
la liste associée
• recherche de « Michèle » (7),
• puis « Isabelle » (1)
1 2 3 4 5 6 7 8 9
José Lola
Isabelle

44
Retrait d’un élément
1) on calcule le code associé à cet élément x par la fonction
d'adressage, soit p
2) on compare le contenu de la première information de la p-ième
case de la table avec l'élément x
• si identité, on retire l’élément et on le remplace par l'élé-
ment placé en tête de la liste associée, quand elle existe ;
• sinon on mène une recherche séquentiellement dans la
liste associée, avec retrait si la recherche est positive
• retrait de « Michèle » (7),
• puis « Lola » (2) et enfin « Marc » (1)
1 2 3 4 5 6 7 8 9
Isabelle
José Lola

45
Algorithmes de la méthode
d'adressage dispersé avec résolution
externe
type Info2 = agrégat
principal : chaîne {première chaîne associée à un code donné}
débord : Liste {objet Liste dont l'information est une chaîne}
fin
fonction code (uneChaîne) retourne (entier)
{retourne la valeur donnée par la fonction d’adressage}
paramètre (D) uneChaîne : chaîne

46
Procédure ajout (table, laChaîne)
{ajoute l'élément laChaîne dans une table, par adressage dispersé, avec
résolution externe des collisions}
paramètres (D/R) table: tableau [1, TAILLEMAX] de Info2
(D) laChaîne : chaîne
variables ok: booléen
ind: entier
début
ind  code(laChaîne)
si table[ind].principal = " "
alors {c'est la première occurrence de ce code d'adressage}
table[ind].principal  laChaîne
sinon {il y a collision: la place principale est déjà occupée, d’où
ajout dans la liste de débordement,en tête}
table[ind].débord.premier()
table[ind].débord.insèreAvant(laChaîne)
fsi
fin

47
Fonction recherche (table, laChaîne) retourne (booléen)
{recherche si l'élément laChaîne est présent dans une table, par adressage
dispersé, avec résolution externe des collisions}
paramètres (D) table: tableau [1, TAILLEMAX] de Info2
variables trouvé, ok: booléens; ind : entier
début
trouvé  table[ind].principal = laChaîne
si non trouvé {recherche de laChaîne dans la liste de débordement}
alors table[ind].débord.premier()
tant que non trouvé et
non table[ind].débord.horsListe() faire
trouvé  (table[ind].débord.info() = laChaîne)
table[ind].débord.suivant()
ftq
fsi
retourne (trouvé)
fin

48
Fonction retrait (table, laChaîne) retourne booléen
{retire, si possible, l’élément laChaîne d’une table construite par adressage
dispersé avec résolution externe des collisions}
variables ok : booléen; ind : entier
début
trouvé  (table[ind].principal = laChaîne)
si trouvé {alors retrait de laChaîne du champ principal de la table}
alors retraitPrincipal (table, laChaîne, ind)
sinon {recherche, et éventuel retrait, de laChaîne dans la liste de
débordement}
ok  rechercheRetraitDeborde (table, laChaîne, ind)
fsi
retourne (ok)
fin

49
Procédure retraitPrincipal (table, laChaîne, ind)
{retire l’élément laChaîne du champ Principal du code adresse ind; ce champ
reçoit la valeur de tête de la liste de débordement si possible}
(D) laChaîne : chaîne; ind : entier
variables elt : Info2; ind : entier
début
si (table[ind].débord.vide()) {il n’y a pas eu de collision sur ce code}
alors {ce code n’adresse plus aucune chaîne}
table[ind].principal  " "
sinon {on récupère l’élément en tête de liste de débordement}
table[ind].débord.premier() ; elt  table[ind].débord.info()
{pour mettre sa valeur dans le champ principal}
table[ind].principal  elt
{et puis on retire la cellule de tête de la liste de débordement}
table[ind].débord.supprimer()
fsi
fin

50
Fonction rechercheRetraitDéborde(table, laChaîne,ind)
{recherce et retire, si possible, l’élément laChaîne de la liste de débordement du
code adresse ind}
(D) laChaîne : chaîne; ind : entier
variable trouvé : booléen
début
table[ind].débord.premier()
trouvé  faux
{recherche de laChaîne dans la !iste de débordement}
tant que non trouvé et non table[ind].débord.horsListe() faire
trouvé  (table[ind].débord.info() = laChaîne )
si non trouvé alors table[ind].débord.suivant()
ftq
{si trouvé, alors retrait dans la liste de débordement de la table}
si trouvé
alors table[ind].débord.supprimer() {le curseur est placé sur laChaîne}
retourne (trouvé)
fin

complexité, tris
51
Complexité des algorithmes

Complexité des algorithmes
• Complexité temporelle, complexité spatiale
coût en temps: temps nécessaire à l'exécution
coût en espace: espace mémoire nécessaire
• Pire des cas, complexité moyenne
- la complexité dans le pire des cas n'est pas nécessairement une bonne
indication du coût en pratique (exemple de la méthode du simplexe)
- comment estimer le cas moyen ?
• Étude a priori, bancs d'essai et évaluation a posteriori
- étude théorique
- étude pratique de l'algorithme implémenté, bancs d'essai

Complexité d'un problème, complexité d’un
algorithme
• contraintes sur un problème
par exemple, recherche d'un élément dans un tableau de n
éléments non triés : si l'élément n'est pas présent, n
comparaisons seront nécessaires pour le constater
• Attention: si le tableau est trié, une seule peut être
suffisante !
- parmi les différents algorithmes possibles, certains sont meilleurs que
d'autres
- la comparaison des pires des cas peut ne pas être une bonne indication

Complexité asymptotique
• Nécessité d'étudier la complexité pour de grosses
quantités de données
• Exemple : deux algorithmes pour une même tâche:
- A1 effectue n2 opérations de base, A2 effectue n.log2 n opérations
• Deux machines :
- M1 effectue 210 (environ mille) opérations par sçconde
- M2 effectue 220 (environ un million d') opérations par seconde
• Temps de calcul (en secondes) :

M1 M2
A1 A2 A1 A2
n = 210 210 10 1 < 0,01
n = 220 230 20. 210 220 20
Complexité asymptotique (2)

Rapidité de croissance comparée
de certaines fonctions usuelles

Calcul de la complexité d’un algorithme
• Calcul de la valeur d'un polynôme en un point
1. p  a[0]
2. pour i 1 à n faire {puissance(a, n) retourne an}
3. xpi  puissance (x , i)
4. p  p + a[i]* xpi
fpour
• Nombre de multiplications
en 3 --> 1+2+3+...+ (n-1) = (n-l)n/2
en4 --> n
• Nombre d'additions en 4 --> n
• soit au total: n(n + 3)/2 < n2 pour n > 3.

Notations utilisées
• Grand O
f(n) = 0(g(n)) s'il existe C> 0 et no > 0 tels que
f(n)  C. g(n) pour tout n  no
• Grand oméga
f(n) = Ω(g(n)) s'il existe C> 0 et no > 0 tels que
f(n)  C. g(n) pour tout n  no
• Grand thêta
f(n) = Θ(g(n)) s'il existe C1 et C2 > 0 et no > 0 tels que
C1.g(n)  f(n)  C2. g(n) pour tout n  no

Exemples
• f(n) = O(1) f est majorée
• f(n) = Ω (1) f est minorée
3n+2 = O(n) 3n+3 = O(n)
100n+6 = O(n)
10n2+4n+2=O(n2) 3n+3 = O(n2)
1000n2 + 100 n -6 = O(n2) 10n2+4n+2= O(n4)
6*2n + n2 = O(2n)
• ----> c'est la plus petite fonction g(n) qui est
intéressante

Exemples (suite)
3n+3 = Ω (n)
100n+6 = Ω (n)
10n2+4n+2= Ω (n2)
6*2n + n2 = Ω (n2) 6*2n + n2 = Ω (n)
6*2n + n2 = Ω (1)
• ----> c'est la plus grande fonction g(n) qui est
intéressante

Temps d’exécution des algorithmes
• Temps constant (rares algorithmes, cf. adressage
dispersé) O(1)
• Temps logarithmique (exemple: recherche
dichotomique) O(log2n)
• Temps linéaire (exemple: recherche séquentielle) O(n)
• Temps polynomial O(nk) (coûteux si k dépasse 3)
- quadratique O(n2)
- cubique O(n3)
• Temps exponentiel O(cn) (à éviter en général)

Comparaison des complexités d'algorithmes de la
même classe
• Calcul de la valeur d'un polynôme en un point (1)
p  a[0]
pour i  1 à n faire
xpi  puissance(x, i)
p  p + a[i]* xpi
fpour
n(n+1)/2 multiplications, n additions : algorithme en O(n2)

Calcul de la valeur d'un polynôme en un point (2)
p  a[0]
xpi  1
pour i  1 à n faire
xpi  xpi * x
p  p + a[i]* xpi
fpour
2n multiplications, n additions : algorithme en O(n)

• Calcul de la valeur d'un polynôme en un point (3)
p  a[n]
pour i  n - 1 à 0, pas -1 faire
p  p*x + a[i]
fpour
n multiplications, n additions algorithme en O(n)
Complexité optimale pour cette classe d'algorithmes :
en O(n)

Calcul de la complexité d’algorithmes de recherche simples
• Opérations élémentaires retenues: les
comparaisons
1. Recherche séquentielle dans un tableau non
trié
- complexité au pire n comparaisons
- complexité moyenne n/2 comparaisons
algorithme en O(n)
2. Recherche séquentielle dans un tableau trié
- complexité au pire n comparalsons
- complexité moyenne n/2 comparaisons
algorithme en O(n)

• Recherche dichotomique (dans un tableau trié 1)
- complexité au pire = complexité moyenne =
nombre p d'intervalles considérés
• Exemple avec n = 8 = 23 tableau de 8 éléments
niveau 0
niveau 1
niveau 2
niveau 3
Profondeur de l’arbre de décision de l’ordre de log2n :
complexité algorithmique en O(log2n)

complexité, tris
67
Tris

Tris
• Données dans un ensemble d'éléments S muni d'un ordre total
ordre | a < a (réflexif)
partiel | a < b et b < c => a < c (transitif)
| a ~ b et b < a => a = b (antisymétrique)
total | a,b a=b OU a<b OU b<a (total)
• Problème du tri
éléments al, ..., an ~ S donnés
trouver une permutation p: { 1, . . ., n} { 1, . . .,n} telle que
ap(1)  …  ap(n)
En général, on s'intéresse plutôt au résultat de l'application de p

• Tris internes et tris externes
- internes: l'ensemble des données peut être traité en mémoire
centrale
- externes: on opère sur une partie des données seulement
• Tris d'entiers: méthode des seaux
à trier: des entiers entre 1 et m
principe:
- on crée m files d'attente vides numérotées 0, …, m-1
- on parcourt linéairement les données, et on place ai
dans la file numérotée ai
- on place les files d'attente bout à bout

• Exemple m = 10, 4 7 3 2 8 1 5
• Résultat: 1, 2, 3, 4, 5,
• Estimation du coût :
- chaque élément peut être placé dans une file en temps
constant, d'où O(n) pour les n éléments ;
- concaténation de m files en O(m) ;
- si m = 0(n), coût total en O(n).
1 2 3 4 5 7 8
0 1 2 3 4 5 6 7 8 9

• Cette méthode peut être généralisée à des k-uplets d'entiers
munis de l'ordre lexicographique, et plus généralement à des
chaînes (de longueur variable):
(s1,..., sp) < (t1,..., tq) si et seulement si
• ou bien p < q et si = ti pour 1  i  p (s est un préfixe de t);
• ou bien il existe j tel que si < tj et si = ti pour tout i < j.
• Exemples:
634 < 63472 tri < triage
64589 < 647 seau < selle
• Pour des suites de k-uplets dont chaque composante est un entier
entre 0 et m-l, on obtient un algorithme de coût O((m+n)k).

Cas général:
- on trie des éléments quelconques munis d'un ordre (total)
- la seule opération disponible est la comparaison de deux éléments
Exemple: tri de trois éléments a, b, c
a<b
b<c a<c
a<c b<c
a, b, c
a, c, b
b, a, c
c, a, b b, c, a c, b, a

Estimation du coût
• Arbre binaire de hauteur h => au plus 2h feuilles
•Théorème Un arbre de décision pour n éléments a une hauteur supérieure ou
égale à log(n!).
- En effet, un arbre de décision doit avoir au moins autant de feuilles que de
résultats possibles, c'est-à-dire n! feuilles au moins. Donc la hauteur de cet arbre
est  log(n!)
• Estimation
Formule de Stirling: n! approximé par (n/e)n, donc le nombre de tests nécessaires est
minoré par n(logn - log e) = nlog n -1,44n
• => on ne peut pas espérer faire mieux que O(n log n)

Méthodes de tri élémentaires (1)
Tri par sélection
• Données: un tableau de n éléments à trier
• Principe: pour chaque position successive dans le tableau, on cherche l'élément
qui occupera cette position dans le tableau trié, et on l'y place en permutant
cet élément avec l'élément courant.
liste triée
liste triée
case courante
devrait se trouver
dans la case courante
reste à trier
reste à trier

20 18 9 5 24 13 27 2 8 32 7 12 36 15 17 19

Algorithme de tri par sélection
procédure triSélection (tab, nbre)
{recherche pour chaque case l'élément qui doit y être affecté et y place cet
élément}
paramètre s (D/R) tab: tableau [1, MAX] d'entiers
(D) nbre: entier
variables indDuMin, position: entier
début
pour position  1 à nbre -1 faire
indDuMin  sélection(tab, nbre, position,nbre)
{recherche l’indice de l’élément minimum entre position et la fin de tab}
échanger(tab, position, indDuMin) {échange deux positions dans tab}
fpour
fin

Algorithme de tri par sélection (2)
fonction sélection (tab, nbre, indDébut,indFin) retourne(entier)
{recherche l'indice de l'élément minimum de tab entre indDébut et indFin}
paramètre s (D) tab: tableau [1, MAX1 d'entiers
(D) nbre, indDébut, indFin : entiers
variables indDuMin, ind: entiers
début
indDuMin  indDébut
pour ind  (indDébut + 1) à indFin faire
si tab[indDuMin] > tab[ind] alors indDuMin  ind
fpour
retourner(indDuMin)
fin

Méthodes de tri élémentaires (1)
Tri par insertion
• Données: un tableau de n éléments à trier
• Principe: la partie gauche est triée; on essaie d'insérer chaque nouvel élément
dans cette liste, en décalant d'un cran la partie droite restante.
liste triée
liste triée
place du nouveau
reste à trier
nouveau
reste
reste

20 18 9 5 24 13 27 2 8 32 7 12 36 15 17 19

Algorithme de tri par insertion
procédure triInsertion (tab, nbre)
{recherche pour chaque élément la case où il doit être affecté et y place cet
élément}
(D) nbre: entier
variables indVal, numPlace: entiers
début
pour indVal  2 à nbre faire
{recherche de 1'endroit où doit s'insérer la valeur placée en indVal}
numPlace  Insertion(tab, nbre, indVal)
{si la valeur n'est pas à insérer en fin de zône triée, l'insérer à la place voulue}
si (numPlace  indVal ) alors
{libère la position numPlace par décalage et y place tab[indVal]}
décalerEtPlacer(tab, numPlace, indVal)
fsi
fpour
fin

procédure décalerEtPlacer(tab, nPlace, indVal)
{libère la position nPlace par décalage et y place tab[indVall}
(D) nPlace, indVal: entiers
variables indDuMin, ind, deCôté: entiers
début
deCôté  tab[indVal]
{faire un trou au rang nPlace en décalant les valeurs qui suivent d'un rang vers la droite}
pour ind  indVal à nPlace + 1 pas -1 faire tab[ind]  tab[ind-1]
fpour
tab[nPlace]  deCôté
fin

Simulation du décalage

Deux algorithmes pour la recherche de place
1. Recherche séquentielle dans un tableau trié
fonction insertion (tab, nbre, indV) retourne(entier)
{renvoie la place à laquelle il faut affecter tab[indV] pour respecter l'ordre}
(D) nbr, indV: entiers
variables dépassé: booléen; i, val, nbValTriées: entiers
début
val  tab[indV]; nbValTriées  indV - 1
dépassé  faux; i  0
tant que i < nbValTriées ET non dépassé faire
ii+ 1
dépassé  (tab[i] > val)
ftq
si dépassé alors retourne (i) sinon retourne (i+l) fsi
fin

Simulation du tri par insertion séquentielle

2. Recherche dichotomique
fonction insertion (tab, nbre, indV) retourne (entier)
{renvoie la place à laquelle ilfaut affecter tab[indV] pour respecter l'ordre}
(D) nbr, indV: entiers
variables id, if, im, val: entiers
début
val  tab[indV]; id  0 if  indV + 1
tant que if - id > 1 faire
im  (id + if)/2
si (tab[im] > val) alors if im sinon id im fsi
ftq
retourne (id + 1)
fin

Simulation du tri par insertion dichotomique

Complexité des tris élémentaires
• Coût du tri par sélection
- on fait (n-l) + (n-2) + ... + 1 tests de comparaison, soit en tout:
n(n-l)/2 comparaisons
- on peut être amené à faire n-1 échanges
=> algorithme en O(n2)
• Coût du tri par insertion:
- en moyenne n2/4 comparaisons
- n2/8 échanges deux fois plus dans le pire des cas
=> ici encore algorithme en O(n2)

Tris indirects
• Problème : tri sur différents critères
• On veut mémoriser les résultats des tris par
nom, par taille, par date
Rep[1] Rep[2] Rep[3]
nom toto.C toto.o toto
taille 20 457 3 456 5 248
date 12.04.01 13.04.01 15.04.1

Solution : utilisation
de tableaux d’indices
• On utilise trois tableaux différents qui
contiennent non les agrégats, mais les
indices des agrégats dans le tableau
3 1 2
triNom
triTaille
triDate
2 3 1
1 2 3

Tris indirects (suite)
• Dans l’algorithme de tri, la comparaison de
deux agrégats se fait relativement à un
critère (nom, taille, date) :
précède(i, j, Critère, tab)
fonction qui retourne vrai si le fichier tab[i]
précède le fichier tab[j] relativement au
critère Critère

complexité, tris
91
Fin du volume 6

coursAlgo_V6.ppt

Recommandé

Recommandé

Contenu connexe

Similaire à coursAlgo_V6.ppt

Similaire à coursAlgo_V6.ppt (11)

Dernier

Dernier (20)

coursAlgo_V6.ppt