L2 Algorithmique et Structures de Données 2016-2017

Interrogation 1
Durée 1H
Documents et Téléphones portables sont Interdits
Exercice 1 (1+ 0.25 + 1 + 0.25 = 2.5 points). Soit « TrierX » une procédure à deux paramètres
d’entrée (Tableau d’entiers T et sa taille n):
Procédure Trierx (T : Tableau d’entiers, Calcul de complexité (Question 3)
n : entier)
Pour j1 à n-1 faire La boucle se répète n-1 fois mais la boucle imbriquée dépend de j donc
on utilise la somme
clèT[j] C1
ij-1 C2
Tant que i ≥ 0 et T[i] > clé faire Au pire le tableau est trié d’ordre décroissant donc cette boucle de répète
T[i+1] T[i] de j-1 à 0, c-à-d j fois. De plus, une itération de cette boucle
ii-1 (condition+corps) s’exécute en C3
FTQ
T[i+1]clè
FP

Pour cette procédure,

22 24 21 25 20 21 21 22 24 25

22 24 24 25 20 20 21 22 24 25

22 22 24 25 20

21 22 24 25 20

21 22 24 25 25

21 22 24 24 25

21 22 22 24 25

2. Donner le nom du tri correspondant. Par insertion

Bon Courage Page 1

On convient de représenter un nombre binaire (𝑏𝑛 𝑏𝑛 −1 … 𝑏1 𝑏0 ) par une liste linéaire chaînée
unidirectionnelle où chaque élément contient un bit « bi (0, 1) ».

En utilisant le modèle de LLC, écrire les modules suivants :

1. Fonction NbOccLLC (L : * Maillon, b : {0, 1}) : entier  qui permet de retourner le nombre de
bit « b » (0 ou 1) dans la liste
2. Fonction Convertir10 (L : * maillon) : entier  qui permet de convertir le nombre binaire en
un nombre décimal

Rappelons que : 𝑏𝑛 𝑏𝑛 −1 … 𝑏1 𝑏0 2 = 𝑏𝑛 × 2𝑛 + 𝑏𝑛 −1 × 2𝑛 −1 + … + 𝑏1 × 21 + 𝑏0 × 20

Exemple : 101010 2 = 1 × 25 + 0 × 24 + 1 × 23 + 0 × 22 + 1 × 21 + 0 × 20 = 32 + 8 + 2 = 42

Indication : vous pouvez utiliser directement ces deux fonctions : Fonction LongLLC(L :*Maillon) : entier
et Fonction Puiss (a, b : entier) : entier.

3. Fonction Pair (L : *Maillon) : booléen  qui permet de tester si le nombre binaire est pair ou
non. Rappelons que le bit de poids faible indique la parité du nombre binaire.
4. Procédure CreerLLC(L : * Maillon, x : entier)  qui permet de convertir un nombre décimal
en un nombre binaire et construire la liste L. Rappelons que la conversion peut se faire avec
des divisions successives : Diviser le nombre entier « x » et chacun des quotients successifs par
2 jusqu'à obtenir un quotient nul. La suite des restes, dans l'ordre inverse de leur obtention,
donne la représentation du nombre décimal en binaire.
Exemple :

Aroussi Page 2
1. Fonction NbOccLLC (L : * Maillon, b : {0, 1}) : entier
Debut
PL
Cpt 0
TQ (P ≠ Nil ) faire
Si (valeur (P) = b ) alors Cpt ++
P  suivant (P)
FTQ
Retourner (Cpt)
Fin
2. Fonction Convertir10 (L : * maillon) : entier
Debut
P L
a  LongLLC(L) – 1
S 0
TQ (P ≠ Nil ) faire
S  S + valeur (P) * puiss (2, a)
aa-1
P  suivant (P)
FTQ
Retourner (S)
Fin
3. Fonction Pair (L : *Maillon) : booléen
Debut
Si L ≠ Nil alors
P L
TQ (suivant (P) ≠ Nil ) faire
P  suivant (P)
FTQ
Si valeur (P) = 0 alors retourner (vrai)
FSI
retourner (faux)
Fin
4. Procédure CreerLLC(L : * Maillon, x : entier)
Debut
L Nil
Répéter // il faut utiliser répéter pour prendre en considération le cas de x = 0
b  x mod 2
x  x div 2
// insertion au debut
allouer (P)
aff_val (P, b)
aff_suiv (P, L)
L P
Jusqu’à ce que (x = 0)
Fin

Aroussi Page 3