Université de Blida I Faculté des Sciences Dépt.

D’informatique

Epreuve de Moyenne Durée du module « Algorithmes et structures de données », L2

Exercice 1 : (6 pts)

On désire implémenter l’algorithme d’Eratosthène permettant de retrouver les nombres premiers inférieurs à un N
donné. L’algorithme agit ainsi :
1. Il crée une liste avec tous les entiers de 2 à N. Le maillon pointé (dénommé courant) est le premier.
2. Il supprime systématiquement de la liste, en commençant par le second maillon, tous les maillons dont les
valeurs sont multiples du maillon courant.
3. Il passe au maillon suivant le maillon courant et recommence l’étape 2 jusqu’à ce qu’il n’y ait plus rien à
supprimer.
4. Il liste finale contient alors tous les nombres premiers <= N.
Exemple : Pour N = 20
Liste à l’état initial : 234567891011121314151617181920.
Itération 1 : suppression des multiples de 2  235791113151719.
Itération 2 : suppression des multiples de 3  235711131719.
Toutes les autres itérations n’élimineront rien. Ainsi, les entiers premiers <=20 sont 2,3,5,7,11,13,17,19.
Ecrire la fonction Eratos(N :entier) : liste qui retourne un pointeur sur la liste ordonnée du plus petit au plus grand
entier premier inférieur ou égal à N.
Solution-type : (sur 4 points)

Fonction ERATOS(N :entier) :liste ; Tant que p<> NULL faire

Variables prec  p ; q  adr(p) ;
L,p :liste ; i : entier ; Tant que q <> NULL faire
Début si val(q) mod val(p) = 0 alors
//création de la liste AddAdr(prec, adr(q)) ; libérer(q) ;
Init(L) ; q = adr(prec) ;
Pour i  n à 2 faire Sinon
AllouerMaillon(p) ; Prec  q ; q adr(q) ;
Si (p <> NULL) alors Fsi ;
AffVal(p, i) ; AffAdr(p, L) ; Lp ; Fait ;
Fsi ; P  adr(p) ;
Fait ; Retourner L ;
//élimination des nombres non premiers Fin 

2 – A votre avis, comment pourrait-on classer l’algorithme d’Eratosthène ? (Excellent, très bon, bon, Acceptable,
mauvais). Justifiez votre réponse.

Réponse : (sur 1 pt BONUS)

L’algorithme d’Ératosthène est acceptable car il va créer la liste (O(n)) puis parcourir la liste de taille (n-1) fois pour
éliminer les doubles de 2 puis n/2 – 2 fois pour éliminer les doubles de 3 puis (n/2 -2)/3 -3 fois pour éliminer les
doubles de 5 et ainsi de suite. La partie élimination des doubles donnera donc (n-1) + ½*(n-1) + 1/3 *1/2(n-1) …
soit (n-1)*(1+1/2+1/6+1/30+…) dont une complexité de max(O(n), O(nlog(n)) soit O(nLog(n)).

En fait, je me serais contenté de la remarque selon quoi la complexité est supérieure à O(n) et inférieure à O(n 2)
(donc pas trop bon et pas mauvais non plus, soit acceptable. C’est la seule complexité existant entre les deux).
Université de Blida I Faculté des Sciences Dépt. D’informatique

Exercice 2 : (8 pts)

On voudrait utiliser une technique de hachage pour placer des chaînes de caractères dans un tableau.
1 – Expliquez l’intérêt des techniques de hachage (1 pt)
Réponse : Si on insère des éléments dans un tableau dans l’ordre d’arrivée, on aura une insertion lente et une
recherche rapide. Inversement, si on insère les éléments dans l’ordre, on aura une insertion lente et une recherche
rapide. Les techniques de hachage permettent d’avoir une insertion rapide et une recherche rapide dans un tableau.

2 – soit la fonction h1(x) = somme(position(c[i])*(i+1)) mod 13 et h2(x) = somme(position(c[i]+1)*i) mod 13, i allant
de 1 à n dans les deux cas. Position(c) est la position de la lettre c dans l’alphabet.
- Placer les valeurs « abc », « cab », « bac », « cca », « cac » et « ga » dans la table en utilisant la fonction
h1. Si une collision se produit, utilisez la fonction h2 pour déterminer le pas et rechercher une place de
vide en utilisant le double hachage. (dessinez le vecteur horizontalement)
Réponse : (2 pts) (8*0.25)
H1(abc) = (1*2+2*3+3*4 ) mod 13 = 7
H1(cab) = (3*2+1*3+2*4) mod 13 = 4
H1(bac) = (2*2+1*3+3*4) mod 13 = 4. Il y a collision avec cab. On calcule donc H2(bac) = (3*1+2*2+4*3) mod 13 = 6.
H1(cca) = (3*2+3*3+1*4) mod 13 = 6.
H1(cac) = (3*2+1*3+3*4) mod 13 = 8
H1(ga) = (7*2+1*3) mod 13 = 4. Collision avec cab. H2(ga) = (8*1+2*2) mod 13 = 12.

0 1 2 3 4 5 6 7 8 9 10 11 12
cab cca abc cac bac Ga

3 – Ecrire la fonction recherche(v :chaine) :booléen qui recherche si un élément existe dans la table. Dans ce cas, elle
retourne son indice, sinon, elle retourne -1.

Remarques
1 - La table de hachage n’ayant été donnée comme paramètre, cela suppose que c’est une variable globale. Il aurait
toutefois été préférable que ce soit un paramètre passé par variable.
2 – Dans l’énoncé, il a été spécifié booléen et la valeur de retour un entier. En fait, il faut choisir l’un ou l’autre. Si on
choisit un booléen, c’est comme dans la solution, sinon, le vrai devient « i » et le faux « -1 ».

Fonction Recherche (v :chaîne) : booléen ;

Variables
Début 
i  h1(v) ; pas  h2(v) ;
Tant que table(i).valeur <> donnée) et table(i).occupé = vrai
Faire
i = i – pas ;
si i<0 alors
i = i+n
fsi ;
fait
si table(i).occupé = faux alors
retourner faux
sinon
retourner vrai
fsi ;
fin ;

4 – Quelle est la complexité de cette fonction (la fonction recherche)? Que traduit cette complexité ? Est-ce que les
fonctions de hachage choisies sont à priori bonnes ? (expliquez)
Réponse : (2*0.5)
Université de Blida I Faculté des Sciences Dépt. D’informatique

La complexité des méthodes de hachage est O(1). C’est la meilleure complexité. Cela veut dire que les méthodes de
hachage sont excellentes (quand certaines conditions sont respectées).
Quant aux fonctions de hachage choisies, la première est bonne pas la seconde. En fait, si une clé k2 est en collision
avec une clé k1 et que H2(k2) donne 12, l’algorithme de recherche bouclerait indéfiniment à la recherche k2 car il
tombera toujours et indéfiniment sur k1 !
Université de Blida I Faculté des Sciences Dépt. D’informatique

Exercice 3 : (8 pts)

1 – Rappeler tous les cas de figure d’une suppression de valeur dans un arbre de recherche binaire.

On peut distinguer quatre cas :

1. FG = NULL et FD = NULL (Suppression d’une feuille) (0.5 pt)

2. FG = NULL et FD <> NULL (Suppression d’un nœud qui possède un seul fils) (0.5 pt)
3. FG <> NULL et FD = NULL (Suppression d’un nœud qui possède un seul fils) (0.5 pt)
4. FG <> NULL et FD <> NULL (Suppression d’un nœud qui possède deux fils) (0.5 pt)

2 – Ecrire la procédure supprime(var a :arbre, x : entier) qui supprime une valeur d’un arbre de recherche binaire.

(4 pts)

Procedure supprimer(var a:Arbre, x : entier)

Var
tmp : Arbre ;
Début
Si a<> NULL
Si info(a) = x alors
// Cas 1
Si FG(a) = NULL et FD(a) = NULL
Liberer(a) ; a := NULL ;
Fsi ;
// Cas 2
Si FG(a) = NULL et FD(a) <> NULL
tmp = FD(a) ; Liberer(a) ; a := tmp ;
Fsi ;
// Cas 3
Si FG(a) <> NULL et FD(a) = NULL
tmp = FG(a) ; Liberer(a) ; a := tmp ;
Fsi ;
// Cas 4
Si FG(a) <> NULL et FD(a) <> NULL
tmp = FD(a) ;
Tanque FG(tmp)<>NULL faire
tmp := FG(tmp);
FinTQ;
aff-FG(tmp, FG(a));
tmp := FD(a); Liberer(a) ; a := tmp ;
Fsi ;
Sinon
Si info(a)<x faire
Supprimer(FD(a),x) ;
Sinon
Supprimer(FG(a),x) ;
Fsi ;
Fsi ;
Fsi ;
Fin.
Université de Blida I Faculté des Sciences Dépt. D’informatique

Exercice 4 : (6 pts)

Ecrire une fonction qui élimine les doubles d’une liste linéaire chaînée unidirectionnelle d’entiers et la trie dans un
ordre ascendant en utilisant un Arbre Binaire de Recherche (ABR). On utilisera –sans les écrire- les opérations
InsereDansABR(var a : arbre, x :entier) qui insert une valeur x dans un ABR et SupprimeDepuisABR(var a :arbre, x :
entier) qui supprime une valeur X d’un ABR.

Réponse :

Procedure ElimineDoubles(var l:liste)

variables
a:arbre; x:entier; p:liste;
début
InitArbre(a);
tant que l <> NULL faire
InsereDansABR(a,val(l));
p := l;
l := adr(l);
libérer(p);
fait;
//reconstruction de la liste
tant que a<>NULL faire
allouer(p); x:=max(a);
AffVal(p, x); AffAdr(p,L); l:=p;
SupprimeDepuisABR(a, x);
fait;
fin;