Академический Документы
Профессиональный Документы
Культура Документы
Anne 2010-2011
Algorithmique et arbres
L2
TD 6
12
3
2
14
5
14
5
15
18
9
15
19
x
a
y
b
rotation_droite(x)
E
rotation_gauche(x)
b
C
y
a
C
D
D
E
Figure 2: Rotations gauche et droite. Dans cette version les lments a et b sont changs entre
les nuds x et y mais x garde sa place dans larbre qui le contient.
4. Sur le second exemple de la figure 1, laide de rotations dont vous prciserez le sens et le
centre, amener le nud de cl 9 la racine.
5. Dmontrer que toute rotation prserve la proprit dtre un arbre de recherche.
6. crire lalgorithme de rotation droite en C.
7. crire un algorithme permettant de remonter la racine nimporte quel nud dun arbre
binaire de recherche, laide de rotations.
Exercice 5 (Insertion / suppression ABR).
Former un arbre binaire de recherche en insrant successivement et dans cet ordre les lments : 10, 7, 3, 9, 11, 5, 6, 4, 8 (rpondre en reprsentant larbre obtenu). Supprimer llment 7.
(rpondre en reprsentant le nouvel arbre. Il y a deux rponses correctes possibles, selon la
variante choisie pour lalgorithme de suppression, nen donner quune seule).
1,5 pt
13 min
1,5 pt
9 min
Exercice 7.
On peut afficher les lments dun ABR de taille n en ordre tri en un temps O(n).
1. Expliquer comment et argumenter sur le temps dexcution.
2. Est-ce que la proprit de tas permet dafficher en ordre tri et en temps O(n) les lments
dun tas de taille n ? Argumenter. Indication : on peut planter (former) un tas de n lments
en un temps (n).
Corrig
Correction de lexercice 1.
Un seul arbre un nud, deux deux neuds :
b
b
b
b
b
b
Quatorze arbres quatre nuds (non dessins). On peut le calculer en trouvant la rcurrence :
Cn+1 =
n
X
Ck Cnk
k=0
2h1 1 < n 2h 1
Do h 1 log n < h, donc log n + 1 majore h.
Larbre peigne est quand lui exactement de hauteur n.
Correction de lexercice 2.
int taille(ab_t x) {
if (estVide(x)) {
return 0;
}
return 1 + taille(gauche(x)), taille(droite(x));
}
Correction de lexercice 3.
void hauteur(ab_t x) {
if (estVide(x)) {
return 0;
}
return 1 + max(hauteur(gauche(x)), hauteur(droite(x)));
}
Correction de lexercice 4.
Linsertion est donne par les figures 3 et 4.
La suppression est donne par les figures 5 et 6.
1. Figure 7.
2. rotation gauche de centre 5, puis rotation droite de centre 14.
12
3
14
5
13
15
18
9
15
19
13
*/
void rotation_droite(ab_t x){
element_t tmp;
ab_t y;
assert(x && x->gauche);
y = x->gauche;
/* change des lments */
tmp = x->e;
x->e = y->e;
4
b <- x
/ \
C
a
/ \
D
E
12
3
15
5
18
9
19
y->e = tmp;
/* dplacement des sous-arbres */
x->gauche = y->gauche;
y->gauche = y->droite;
y->droite = x->droite;
x->droite = y;
/* mise jour des parents */
(x->gauche)->parent = x;
(y->droite)->parent = y;
}
12
15
2
3
14
5
x->gauche = y;
/* mise jour des parents */
(x->droite)->parent = x;
(y->gauche)->parent = y;
}
5. Voici lalgo en pseudo-code.
Fonction Remonter(x)
y = Parent(x);
si y 6= NULL alors
/* y existe, x nest pas la racine
si x == Gauche(y) alors
/* x est fils gauche de y
RotationDroite (y );
sinon
/* x est fils droit de y
RotationGauche (y );
/* Llment qui tait dans le nud x est dsormais dans le nud y
Remonter (y );
Et en C :
void remonter(abr_t x) {
y = x->parent;
if (y) { /* x nest pas encore la racine */
if (x == y->gauche) {
rotation_droite(y);
}
else {
rotation_gauche(y);
}
/* llment qui tait contenu dans x est maintenant dans y */
remonter(y);
}
}
Correction de lexercice 5.
Pas de correction.
*/
*/
*/
*/
Correction de lexercice 6.
Ds que n vaut 3 on est confront un problme si a est llment la racine de larbre
quasi-parfait et que b est son fils gauche et c sont fils droit alors par la proprit des tas on doit
avoir a c et par la proprit des ABR a < c. Impossible.
Correction de lexercice 7.
On peut le faire avec la fonction de parcours infixe. Cette fonction est appele une fois sur
chaque nud de larbre et une fois et chacun de ses appels gnre au maximum 2 appels sur des
nuds vides (NULL) ne gnrant aucun nouvel appel. Ainsi il y a au maximum 3 n appels cette
fonction au cours dun parcours (on pourrait tre plus prcis et trouver 2n + 1) et chaque appel
se faisant en temps constant (pas de boucle), le temps total du parcours est
void parcours_infixe(abr_t x) {
if (x) {
parcours_infixe(x->gauche);
affiche_element(x->e);
parcours_infixe(x->droite);
}
}
Si on pouvait parcourir les lments dun tas en ordre tri en temps O(n), comme on plante
un tas en O(n), on aurait un tri par comparaison en O(n). Impossible. Le parcours du tas en ordre
tri est ainsi ncessairement en (n log n).