Université de Nice-Sophia Antipolis POLYTECH CiP2 2010–2011 ...

Université de Nice-Sophia Antipolis
POLYTECH
CiP2 2010–2011
Examen de Algorithmique et Programmation
Durée : 1h30 minutes
Aucun document autorisé Note : la qualité des commentaires, avec notamment la présence
d’affirmations significatives, ainsi que les noms donnés aux variables, l’emploi à
bon escient des majuscules et la bonne indentation rentreront pour une part importante
dans l’appréciation du travail.
◮ 1. Écrivez la définition (ensembles, fonctions et axiomes) du type abstraitPile comme
vu en TD.
Question sur 3 points
Ensembles :
Pile utiliseE et booléen
pilevide∈Pile
Fonctions :
Axiomes :
empiler : Pile×E → Pile
dépiler : Pile → Pile
sommet : Pile → E
est-vide : Pile → booléen
1. ∀p∈Pile,∀e∈E
2. est-vide(pilevide)=vrai
3. est-vide(empiler(p,e))=faux
4. dépiler(empiler(p,e))= p
5. sommet(empiler(p,e))=e
6. ∄ p, p=dépiler(pilevide)
7. ∄e, e=sommet(pilevide)
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 2. Une classe ListeChaînée implémente les fonctions longueur, ième, supprimer et
insérer d’une interface Liste comme vue en TD. Par héritage de ListeChaînée,
écrivez la classe PileChaînée qui implémente une interface Pile.
1

Question sur 3 points
p u b l i c c l a s s PileChaînée extends ListeChaînée
implements Pile
{
/**
* Rôle : construit une pile vide. Les éléments
* de la pile pourront être de types différents
*/
p u b l i c PileChaînée () {
super ();
}
/**
* Rôle : teste si la pile est vide ou non
*
* @return un boolean
*/
p u b l i c boolean estVide () {
return longueur () == 0;
}
/**
* Rôle : retourne le sommet de la pile
* @return un T
* @exception PileVideException si la pile
* est vide
*/
p u b l i c T sommet () throws PileVideException {
i f ( estVide ())
throw new PileVideException ();
return ième (1);
}
/**
* Rôle : empile un objet en sommet de pile
* @param o T, est l’objet à empiler
*/
p u b l i c void empiler (T e) {
insérer (1 ,e);
}
/**
* Rôle : enlève l’élément en sommet de pile
* @exception PileVideException si la pile
* est vide
*/
p u b l i c void dépiler () throws PileVideException {
i f ( estVide ())
throw new PileVideException ();
supprimer (1);
}
}
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 3. La classe ArbreBinaireChaîné définit l’implémentation d’arbres binaires comme
vus en TD. Deux arbres binaires a et b sont miroirs s’ils possèdent la même racine, si le
sous-arbre gauche de a est le miroir du sous-arbre droit de b et si le sous-arbre droit de
2

a est le miroir du sous-arbre gauche de b. Ajoutez à la classe ArbreBinaireChaîné
la méthode créerMiroir qui retourne l’arbre miroir de l’arbre courant this.
Question sur 3 points
/**
* Rôle : retourne un arbre binaire miroir de this
*/
p u b l i c ArbreBinaire créerMiroir () throws ArbreVideException
{
return t h i s . estVide () arbreVide :
// this non vide
new ArbreBinaireChaîné ( t h i s . valeur () ,
t h i s . créerMiroir ( t h i s . sad ()) , t h i s . créerMiroir ( t h i s . sag ()));
}
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 4. Un arbre binaire complet est un arbre dont les nœuds, qui ne sont pas des feuilles,
possèdent toujours deux sous-arbres. Écrivez la méthode estComplet qui retourne un
booléen : vrai si l’arbre binaire courant est complet, et faux sinon.
Question sur 4 points
/**
* Rôle : retourne vrai si l’arbre courant (this) est complet
* et faux sinon. Note un arbre vide est complet.
*/
p u b l i c boolean estComplet () throws ArbreVideException {
return estVide () true : estComplet ( t h i s );
}
/**
* Rôle : retourne vrai si l’arbre a complet
* et faux sinon
* Antécédent : a non vide
*/
p r i v a t e boolean estComplet ( ArbreBinaire a)
throws ArbreVideException
{
}
assert !a. estVide ();
i f (a. sag (). estVide () && a. sad (). estVide ()) return true ;
return a. sag (). estVide () || a. sad (). estVide ()
// un des deux arbres est vide et pas l’autre
f a l s e :
// les 2 sous-arbres ne sont pas vides => poursuivre le test
a. sag (). estComplet () && a. sad (). estComplet ();
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 5. Quelle est les complexités théoriques moyennes, en termes de comparaisons et de
transferts, du tri par insertion séquentielle vu en TD Expliquez.
3

Question sur 2 points
Pour ce tri, il y a n−1 étapes, et dans le cas moyen, à chaque étape, si les clés
sont réparties de façon équiprobable, il y a
2 i comparaisons. Le nombre moyen de
comparaisons est donc ∑ n i=2 2 i = 1 4 (n2 + n−2), La complexité moyenne en terme de
comparaisons de ce tri est doncO(n 2 ).
À chaque étape, le nombre de déplacements est égal au nombre de comparaisons
plus un. En moyenne, il est de 1 4 (n2 + n+2). La complexité moyenne en terme de
transferts de ce tri est aussiO(n 2 )
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 6. Écrivez la méthode TriDicho qui trie une liste générique par insertion avec recherche
dichotomique du rang d’insertion.
Question sur 4 points
/**
* Rôle : trie par insertion dichotomique la liste courante (this)
* Antécédent : c comparateur des clés des éléments de la liste courante
*/
p u b l i c void triDicho ( Comparateur c) {
f o r ( i n t i =2; i clé(ième(milieu))
gauche = milieu +1;
}
// gauche est le rang d’insertion
// décaler tous les éléments depuis ce rang jusqu’à i-1
f o r ( i n t j=i -1; j >= gauche ; j - -)
affecter (j+1 , ième (j ));
// mettre l’élément clé au rang gauche
affecter ( gauche ,x);
}
}
}
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
◮ 7. Modifiez la méthode de tri rapide (quicksort) afin qu’elle retourne la valeur médiane
d’une liste générique. On rappelle que la valeur médiane divise une liste en deux souslistes
de même taille telles que tous les éléments de la première sont inférieurs ou égaux
à la médiane, et tous éléments de la seconde lui sont supérieurs ou égaux.
4

Question sur 3 points
/**
* Rôle : recherche de la médiane de la liste courante (this)
* La méthode est basée sur l’algorithme du tri rapide
* Antécédent : c comparateur des clés des éléments
* de la liste courante
*/
p u b l i c Élément médiane ( Comparateur c) {
return médiane ( t h i s , c, (1+ t h i s . longueur ())/2 , 1, t h i s . longueur ());
}
p r i v a t e Élément médiane ( Liste < Élément > l, Comparateur c,
i n t k, i n t gauche , i n t droite ) {
i n t i= gauche , j= droite ;
C pivot = l. ième (k). clé ();
do {
while (c. inférieur (l. ième (i). clé () , pivot )) i ++;
while (c. supérieur (l. ième (j). clé () , pivot )) j - -;
i f (i