BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Type pour les arbres binaires Fonction 4 : Parcours Postfixé

Type Pointeur : ↑Nœud Procédure Par_postfixe(E/ racine: Pointeur )
Début
Type Nœud=enregistrement Si (racine <>Nil) Alors
Valeur : entier // la valeur du nœud Par_préfixe (racine↑.Fils_G) ;
Fils_G: Pointeur; // le fils gauche Par_préfixe (racine↑.Fils_D) ;
Fils_D: Pointeur; // le fils droit Écrire (racine↑.valeur) //afficher la valeur de la racine du
Fin; //sous-arbre courant en dernier
Fsi ;
Fonction d’allocation Fin;

Fonction 1 : Création_Nœud
Fonction Créer_Nœud(val : entier):Pointeur
Var nœud : Pointeur;
Début
Nouveau(nœud) ; // allouer un nouveau nœud
nœud↑.valeur← val; // affecter les champs du nœud
nœud↑.Fils_G← Nil;
nœud↑.Fils_D← Nil;
Créer_Nœud← nœud; //récupérer la nœud créé
Fin;
Fonctions des parcours des arbres binaires
Fonction 2 : Parcours Préfixé (version récursive)
Procédure Par_préfixe(E/ racine: Pointeur )
Début
Si (racine <>Nil) Alors
Écrire (racine↑.valeur) //afficher la valeur du nœud courant
@ Par_préfixe (racine↑.Fils_G); //appel récursif pour visiter le
// fils gauche.
Par_préfixe (racine↑.Fils_D) ; //appel récursif pour le visiter
Fsi ; // fils droit.
Fin;
 Important : Dans un appel récursif, dès qu’on
termine l’appel (aucun autre appel interne) on reprend le
traitement juste après l’appel origine. Dans l’algorithme
précédent, lorsque le traitement de l’appel Par_préfixe
(racine↑.Fils_G), on reprend le traitement juste avant
l’appel Par_préfixe (racine↑.Fils_D) (Flèche bleu).
Fonction 3 : Parcours Infixé (version récursive)
Procédure Par_infixe(E/ racine: Pointeur )
Début
Si (racine <>Nil) Alors
Par_préfixe (racine↑.Fils_G) ; //visiter le fils gauche en
// premier.
Écrire (racine↑.valeur) //afficher la valeur de la racine du
//sous-arbre courant
Par_préfixe (racine↑.Fils_D) ; //visiter le fils droit en dernier
Fsi ;
Fin;
Fonction 5 : Parcours Préfixé (version itérative)
Procédure Par_préfixe(E/ racine: Pointeur )
Var nœud : Pointeur
pile : Pile de Pointeur // Pile pour garder trace des
//nœuds visités
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Soient les fonctions suivantes permettant de traiter les pile
// Nouveau(pile) : créer une pile vide
// Vide(pile) : retourne vrai si la pile est vide, faux sinon
// Empiler(pile, X) : empiler l’élément X au sommet de la
// pile. ( X doit être du type compatible
// avec la pile
// Dépiler(pile, X) : dépiler le sommet de la pile dans
// l’élément X
/////////////////////////////////////////////////////////////////////////////////////////////////////
Début
Nouveau(pile) ; //créer une nouvelle pile pour les nœuds.
nœud ← racine ;
TQ nœud <> Nil OU non Vide(pile) Faire // répéter le
// traitement tant que la pile est non vide ou le nœud n’est pas à Nil
TQ nœud <> Nil Faire // Afficher les fils gauches
Écrire (nœud ↑.valeur) ; //afficher la valeur du nœud
Empiler (pile, nœud ) ; // empiler le nœud pour visiter
//son sous-arbre droit ultérieurement
nœud ← nœud↑.Fils_G ; //avancer jusqu’au nœud le
//plus à gauche
Fait ;
Dépiler (pile, nœud ) ; // dépiler le nœud pour visiter
//le sous-arbre droit (la valeur du nœud
// a été déjà affichée).
nœud ← nœud↑.Fils_D ; //passer au sous-arbre droit
Fait;
Fin;
 Important : Dans la version itérative des
algorithmes du parcours des arbres, il est impératif
d’utiliser la pile pour garder trace des nœuds parcourus
afin de pouvoir les visiter tous .

-- 1 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Fonction 6 : Parcours Infixé (version itérative)

nœud ← nœud↑.Fils_D ; //passer au sous-arbre droit
Procédure Par_infixe(E/ racine: Pointeur )
Var nœud : Pointeur Sinon // si le sous-arbre droit est déjà visité → afficher
pile : Pile de Pointeur Écrire (nœud ↑.valeur) ; // la valeur du nœud
Début nœud ←Nil ; // pour explorer d’autre branches (autre
Nouveau(pile) ; //créer une nouvelle pile pour les nœuds. // que la branche courant s’il y en a
nœud ← racine ; Fsi ;
Fait;
TQ nœud <> Nil OU non Vide(pile) Faire.
TQ nœud <> Nil Faire Fin;
Empiler (pile, nœud ) ; // empiler le nœud sans affichage
// pour visiter son sous-arbre gauche avant l’affichage
nœud ← nœud↑.Fils_G ; //avancer jusqu’au nœud le  Important : Il est fortement conseillé d’utiliser
//plus à gauche le principe des trois fonctions précédentes (récursif et
Fait ; itératif) pour réaliser la plus part des traitements
Dépiler (pile, nœud ) ; // dépiler le nœud pour visiter appliqués sur les arbres binaires. La différence sera
//le sous-arbre droit. au niveau du traitement (au lieu de l’affichage)
Écrire (nœud ↑.valeur) ; //afficher la valeur avant d’explorer
//le sous-arbre droit
Fonctions de recherche dans les arbres
nœud ← nœud↑.Fils_D ; //passer au sous-arbre droit
binaires de recherche
Fait;
Fin; Fonction 8 : Rechercher dans un ABR, et retourner le
nœud et son père (version itérative).

Fonction 7 : Parcours Postfixé (version itérative) Procédure Search_ABR(E/ racine: Pointeur , E/ val :
entier, S/ nœud: Pointeur , S/ père: Pointeur)
Procédure Par_postfixe(E/ racine: Pointeur )
Var père : Pointeur;
Var nœud : Pointeur nœud : Pointeur;
pile : Pile de Pointeur
trouve : Booléenne.
DV : Booléenne Début
droit_visité : Pile de Booléenne
père← Nil ; // initialiser le père
Début nœud← racine;
///////////////////////////////////////////////////////////////////////////////////////////////////// trouve← faux ;
// Ici on doit empiler avec chaque nœud un indice pour dire si le
// sous-arbre droit à été visité ou non. C’est le rôle de la pile TQ (non trouve ET nœud<>Nil) Faire
// droit_visité Si (nœud↑.valeur=val) Alors //nœud trouvé
/////////////////////////////////////////////////////////////////////////////////////////////////////
trouve← vrai;
Nouveau(pile) ; Sinon
Nouveau(droit_Visité) ; père← nœud; //mis à jour du père
nœud ← racine ; Si (nœud↑.valeur<val) Alors //passer au fils
// gauche pour visiter le sous-arbre gauche
DV← faux ;
nœud ← nœud↑.Fils_G ;
TQ nœud <> Nil OU non Vide(pile) Faire Sinon //passer au fils droit pour visiter le
// sous-arbre droit
TQ nœud <> Nil Faire nœud ← nœud↑.Fils_D ;
Empiler (pile, nœud ); // empiler le nœud sans affichage Fsi ;
Empiler (droit_Visité, faux) ; // empiler son état : fils Fsi ;
//droit non visité encore Fait;
nœud ← nœud↑.Fils_G ; // descendre jusqu’au fils le plus
// à gauche
//////////////////////////////////////////////////////////////////////////////////////////////
Fait ; // concernant le nœud père et si la valeur cherchée n’existe pas
Dépiler (pile, nœud ) ; // dépiler le nœud pour visiter le sous- // dans l’arbre , il s’agit du père du nœud à insérer si on veut
//arbre droit toujours avant l’affichage // insérer cette valeur absente dans l’arbre. Voir fonction 10.
Dépiler (droit_Visité, DV) ; // dépiler également l’état de //////////////////////////////////////////////////////////////////////////////////////////////
// sous-arbre droit (visité ou non)
Si(DV=faux) Alors // si le sous-arbre droit n’est pas
// encore visité Fin;
Empiler (pile, nœud ) ; // ré-empiler le nœud avec un état
Empiler (droit_Visité, vrai) ; //vrai pour indiquer que
// le sous-arbre droit a été visité

-- 2 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Fonction 9 : Recherche dans une ABR, (version récursive), Si (père = Nil) Alors //l’arbre est vide →
ici on ne peut pas retourner le père. racine← nœud; // insérer la racine
Sinon
Fonction Search_ABR(E/ racine: Pointeur , E/ val : Si (père↑.valeur>val) Alors //insérer le nœud
// comme fils gauche gauche
entier) : Pointeur
père↑.Fils_G← nœud ;
Début
Si (racine = Nil) Alors Sinon //insérer le nœud comme fils gauche droit
Search_ABR← Nil; //le cas particulier de la fonction père↑.Fils_D← nœud ;
// récursive Fsi ;
Sinon
Fsi ;
Si (racine↑.valeur = val) Alors //valeur dans la racine Fsi;
Search_ABR← racine; // un deuxième cas
// particulier pour la fonction récursive Fin;
Sinon
Si (racine↑.valeur<val) Alors //appel récursif Fonction 11 : Insertion dans une ABR (version
//pour chercher dans le sous-arbre gauche
récursive).
Search_ABR ←
Search_ABR(racine↑.Fils_G,val) ; Procédure Insert_ABR(ES/ racine: Pointeur , E/ val :
entier)
Sinon //appel récursif pour chercher dans le
//sous-arbre droit
Var nœud : Pointeur;
Search_ABR← Début
Search_ABR(racine↑.Fils_D,val) ; Si (racine=Nil) Alors //arbre vide → insérer la racine
Fsi ; nœud ← Créer_nœud(val) ;
Fsi ; racine← nœud ;
Fait; Sinon // on doit descendre jusqu’aux feuilles (Insertion se
Fin; // fait au niveau des feuilles uniquement

Si (racine↑.valeur>val) Alors //explorer le

// sous-arbre gauche
 Important : Dans une fonction récursive il est Si (racine↑.Fils_G = Nil) Alors //insérer la
strictement obligatoire de définir au moins un cas // valeur comme un fils gauche du nœud courant
particulier ( dans lequel la fonction retourne une valeur
bien définie et non pas un appel récursif). Cette nœud ← Créer_nœud(val) ;
contrainte n’est pas présente pour les procédures racine↑.Fils_G← nœud ;
récursives.
Sinon // insérer dans le sous-arbre gauche
Insert_ABR( racine↑.Fils_G , val) ;
Fsi ;
Fonctions d’insertion dans les arbres
binaires de recherche Sinon

Fonction 10 : Insertion dans une ABR (version Si (racine↑.valeur<val) Alors //explorer le

// sous-arbre droit
itérative).
Si (racine↑.Fils_D =Nil) Alors //insérer
Procédure Insert_ABR(ES/ racine: Pointeur , E/ val : // la valeur comme un fils droit
entier)
Var père : Pointeur; nœud ← Créer_nœud(val) ;
nœud : Pointeur; racine↑.Fils_D← nœud ;

Début Sinon // insérer dans le sous-arbre droit

Insert_ABR(racine↑.Fils_D , val);
Search_ABR(racine, val, nœud, père) ; // chercher la Fsi ;
// valeur et retourner son endroit pour l’insérer
//si elle n’existe pas
Fsi ;
Si (nœud<>Nil) Alors Fsi ;
Écrire(‘La valeur existe déjà’) ; Fait;
//////////////////////////////////////////////////////////////////////////////////////////////
Sinon // on doit insérer la valeur // Si la valeur existe déjà, elle ne sera pas insérée.
//////////////////////////////////////////////////////////////////////////////////////////////
nœud ← Créer_nœud(val) ; //Allocation d’un nœud.
Fin;

-- 3 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Exercices Supplémentaires Question 02 : (version récursif)

Fonction Nb_feuilles(E/ racine: Pointeur ):Entier
Exercice 01 Début
Soit un AB. //////////////////////////////////////////////////////////////////////////////////////
1. Donner une fonction pour trouver le nombre de nœuds // On suit le même principe que la question précédente //
d’un arbre binaire. // pour la version récursive et la version itérative //
2. Donner une fonction pour trouver le nombre de feuilles /////////////////////////////////////////////////////////////////////////////////////
d’un arbre binaire. Si racine =Nil Alors
3. Donner une fonction pour trouver le nombre de nœuds
Nb_feuilles ←0 ;
internes (non feuilles) d’un arbre binaire en utilisant
les questions 1 et 2.
Sinon
4. Donner une fonction pour trouver le nombre de nœuds Si racine↑.Fils_G=Nil ET racine↑.Fils_D=Nil Alors
internes d’un arbre binaire sans utiliser les questions 1 Nb_feuilles ←1;
et 2.
Sinon
Question 01 : (version récursif) Nb_ feuilles ←Nb_ feuilles (racine↑.Fils_G)+
Nb_ feuilles (racine↑.Fils_D) ;
Fonction Nb_noeud(E/ racine: Pointeur ): Entier
Fsi ;
Début
Fsi ;
Si racine =Nil Alors
Nb_nœud ←0 ; //le cas particulier : arbre vide Fin;
Sinon
Nb_nœud ←1+Nb_nœud (racine↑.Fils_G)+
Nb_nœud (racine↑.Fils_D) ; //appel récursif Question 02 : (version itératif)
Fsi ; Fonction Nb_feuilles(E/ racine: Pointeur ):Entier
Fin; Var nœud : Pointeur
pile : Pile de Pointeur
nb : Entier
Question 01 : (version itératif)
Début
Fonction Nb_nœud(E/ racine: Pointeur ):Entier
Var nœud : Pointeur Nouveau(pile) ;
pile : Pile de Pointeur nœud ← racine ;
nb : Entier nb ← 0 ;
Début TQ nœud <> Nil OU non Vide(pile) Faire
//////////////////////////////////////////////////////////////////
TQ nœud <> Nil Faire
// On suit le principe du parcours préfixe // Si nœud ↑.Fils_G=Nil ET nœud ↑.Fils_D=Nil
///////////////////////////////////////////////////////////////// Alors
nb++ ;
Nouveau(pile) ; Fsi ;
nœud ← racine ;
nb ← 0 ; // nombre des nœuds Empiler (pile, nœud ) ;
nœud ← nœud↑.Fils_G ;
TQ nœud <> Nil OU non Vide(pile) Faire
Fait ;
TQ nœud <> Nil Faire
nb++ ; // incrémenter le nombre des nœuds Dépiler (pile, nœud ) ;
Empiler (pile, nœud ) ; // descendre jusqu’à le nœud le nœud ← nœud↑.Fils_D ;
// plus à gauche du sous-arbre courant Fait;
nœud ← nœud↑.Fils_G ;
Fait ; Nb_feuilles← nb ;
Dépiler (pile, nœud ) ; // dépiler pour visiter le sous-arbre droit Fin;
nœud ← nœud↑.Fils_D ;
Fait;
Nb_nœud← nb ;
Fin;

-- 4 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Question 03 : Exercice 02
Fonction Nb_nœud_internes(racine: Pointeur ):Entier On dit qu’un arbre est filiforme si chaque nœud a au moins
Début un fils vide :
1. Écrire une fonction est_filiforme permettant de
Nb_nœud_internes ←Nb_nœud (racine) - vérifier si un arbre est filiforme.
Nb_feuilles(racine) ;
Fin; On dit qu’un arbre est un peigne gauche si le fils droit de
chaque nœud est vide. On défini de même les peignes droits.
2. Écrire une fonction Est_peigneG qui vérifie si un
Question 04 : (version récursive) arbre est peigne gauche.
3. Écrire une fonction peigneG qui retourne le peigne
Fonction Nb_nœud_internes(racine: Pointeur ):Entier
gauche des N premiers entiers. N donné.
Début
////////////////////////////////////////////////////////////////////////////////////// Question 01 : (version itératif)
// On suit le même principe que les questions 1 et 2 //
// pour la version récursive et la version itérative // Fonction Est_filiforme(racine: Pointeur ):Booléenne
//////////////////////////////////////////////////////////////////////////////////// Var nœud : Pointeur
pile : Pile de Pointeur
Si racine =Nil Alors filiforme : Booléenne
Nb_ nœud_internes ←0 ; Début
Sinon ////////////////////////////////////////////////////////////////////////////
Si racine↑.Fils_G<>Nil OU racine↑.Fils_D<>Nil // Idem, on suit le principe du parcours préfixe //
Alors ///////////////////////////////////////////////////////////////////////////
Nb_ nœud_internes ← 1+ Nouveau(pile) ;
Nb_ nœud_internes (racine↑.Fils_G)+ nœud ← racine ;
Nb_nœud_ internes (racine↑.Fils_D) ; filiforme ← vrai;
Sinon //la branche courante s’agit d’une seule feuille. TQ (nœud <> Nil OU non Vide(pile) )ET
Nb_nœud_ internes ←0 ; (filiforme=vrai) Faire
Fsi ;
TQ nœud <> Nil Faire
Fsi ;
Si nœud↑.Fils_G<> Nil ET
Fin;
nœud↑.Fils_D <> Nil Alors
Question 01 : (version itératif) filiforme← faux;
Fonction Nb_nœud_internes(E/ racine: Pointeur ):Entier Fsi ;
Var nœud : Pointeur Empiler (pile, nœud ) ;
pile : Pile de Pointeur nœud ← nœud↑.Fils_G ;
nb : Entier
Début Fait ;
Nouveau(pile) ; Dépiler (pile, nœud ) ;
nœud ← racine ; nœud ← nœud↑.Fils_D ;
nb ← 0 ;
Fait;
TQ nœud <> Nil OU non Vide(pile) Faire
Est_filiforme← filiforme ;
TQ nœud <> Nil Faire
Si nœud ↑.Fils_G <>Nil OU nœud ↑.Fils_D<>Nil Fin;
Alors
nb++ ;
Fsi ;
Empiler (pile, nœud ) ;
nœud ← nœud↑.Fils_G ;
Fait ;
Dépiler (pile, nœud ) ;
nœud ← nœud↑.Fils_D ;
Fait;
Nb_nœud← nb ;
Fin;

-- 5 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Question 01 : (version récursive) Question 03 : (version itératif)

Fonction Est_filiforme(racine: Pointeur ): Booléenne Fonction peigneG (E/ N: Entier ): Pointeur
Début Var i : Entier
père, nœud : Pointeur
Si ( racine<>Nil) Alors Début
SI (racine↑.Fils_G <> Nil ET racine↑.Fils_D <> Nil ) i←1;
Alors père← Nil ; racine← Nil
Est_filiforme← faux ; // le cas particulier TQ (i<=N) Alors
Sinon // vérifier la branche non vide nœud← Créer_nœud(i) ;
Si père<>Nil
SI (racine↑.Fils_G <> Nil)
Est_filiforme← Est_filiforme(nœud↑.Fils_G)
père↑.Fils_G← nœud ; // insérer le nœud comme fils
// gauche
Sinon Sinon
racine← nœud ; // arbre vide → insérer la racine
SI (racine↑.Fils_D <> Nil)
Fsi ;
Est_filiforme← Est_filiforme(nœud↑.Fils_D)
père← nœud ; // avancer le père
Sinon // racine↑.Fils_G=Nil ET racine↑.Fils_D=Nil i++ ;
Est_filiforme← vrai ; // j’ai arrivé à la fin de l’arbre
// sans problème → un deuxième cas particulier Fait;
Fsi ; Fin ;
Fsi ;
Fsi ;
Exercice 03
Sinon
Écrire une fonction qui étant données racien un ABR et val
Est_filiforme← vrai; // arbre vide
un entier, retourne un ABR qui ne contient que les éléments
Fsi ; de racine inférieur ou égal à val.
Contrainte :
Fin ; L’algorithme ne doit pas comparer tout les nœuds à val.

Question 01 : (version récursive)

Question 02 : (version récursive) Fonction arb_inf(E/racine:Pointeur, val:Entier):
Fonction Est_peigneG (racine: Pointeur ): Booléenne Pointeur
Début Var nœud, racine2: Pointeur
//////////////////////////////////////////////////////////////////////////////////////
Début
// On suit le même principe que Est_filiforme // nœud ← racine; racine2← Nil ;
///////////////////////////////////////////////////////////////////////////////////// TQ (nœud <> Nil OU non Vide(pile) )Faire
Si ( racine<>Nil) Alors TQ nœud <> Nil Faire
Si nœud↑.valeur > val Alors // ne pas visiter le sous
SI (racine↑.Fils_D <> Nil ) Alors // arbre droit (tous les nœuds sont supérieur à val) →
Est_peigneG← faux ; // passer au fils gauche sans empiler le nœud courant.
Sinon nœud ← nœud↑.Fils_G ;
SI (racine↑.Fils_G <> Nil) Sinon; // on doit visiter le sous arbre droit (il se peut
// qu’il y aura des nœuds inférieur à val) → empiler
Est_peigneG← Est_peigneG(nœud↑.Fils_G) ; // et insérer le nœud ensuite passer au fils gauche
Sinon
SI (racine↑.Fils_G=Nil) Empiler (pile, nœud ) ;
Est_peigneG← vari ; Insert_ABR(racine2, nœud↑.valeur) ;
Fsi ; nœud ← nœud↑.Fils_G ;
Fsi ; Fsi ;
Fsi ;
Fait ;
Sinon
Est_peigneG← vrai; // arbre vide Dépiler (pile, nœud ) ;
Fsi ; nœud ← nœud↑.Fils_D ;
Fin ; Fait;
arb_inf← racine2 ;
Fin;

-- 6 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Exercice 04 Si nœud↑.Fils_G=Nil ET racine↑.Fils_D=Nil

Soit un AB représentant une opération arithmétique. Alors // feuille comme fils droit
1. Écrivez une fonction qui affiche l’arbre sous forme Écrire (‘)’) ;
agréable (Voir l’exemple). Dépiler (pile, nœud ) ; // dépiler une autre fois
2. Écrire une fonction qui calcule la valeur associée à nœud ← nœud↑.Fils_D ;
l’arbre.
Fsi ;
père← nœud ; // réinitialiser le père
→ (3*((5+1)/2)); Fait;
→ valeur associée=09 Fin;

Question 2 :
Fonction Calculer_expr(E/ racine: Pointeur ) : Entier
Question 01: version récursive Début
Procédure Aff_expr(E/ racine: Pointeur )
Début /////////////////////////////////////////////////////////////////////////////////////////////////////
// Soient la fonction suivante permettant d’évaluer une expression
Si (racine <>Nil)Alors // Evaluer(op1, operateur, op2) : retourne un entier
// représentant la valeur de op1 operateur op2 :
Si racine↑.Fils_G=Nil ET racine↑.Fils_D=Nil Alors // exemple : Evaluer(5,+,2)=7
Écrire (racine↑.valeur) ; //feuille → opérant /////////////////////////////////////////////////////////////////////////////////////////////////////
Sinon //nœud interne → opérateur
Si (racine <>Nil) Alors
Écrire (‘(’) ;
Aff_expr (racine↑.Fils_G) ; //explorer le sous-arbre gauche. Si racine↑.Fils_G=Nil ET racine↑.Fils_D=Nil Alors
Écrire (racine↑.valeur) ; // afficher l’opérateur Calculer_expr← racine↑.valeur; // feuille :
Aff_expr (racine↑.Fils_D) ; //explorer le sous-arbre droit Sinon
Écrire (‘)’) ; Calculer_expr←
Fsi ; Evaluer (Calculer_expr(racine↑.Fils_G),
Fsi ; racine↑.valeur,
Fin; Calculer_expr (racine↑.Fils_D)) ;
Fsi ;
Sinon
Question 01: Version Itérative Calculer_expr← 0 ; // on doit traiter ce cas car c’est une
Procédure Aff_expr(E/ racine: Pointeur ) // fonction donc on doit retourner une valeur dans tous les cas
Var père : Pointeur; Fsi ;
nœud : Pointeur; Fin;
pile : pile de Pointeur;
Début
nœud ← racine;
père←Nil ; //pour vérifier s’il s’agit d’un sous-arbre droit
Exercice 07
TQ (nœud <> Nil OU non Vide(pile) )Faire Soit un ABR.
TQ nœud <> Nil Faire 1. Écrire une fonction qui permet de retrouver le
Empiler (pile, nœud ) ; // descendre jusqu’ minimum.
père← nœud ; // mis à jour du père à chaque empilement 2. Écrire une fonction qui permet de retrouver le
maximum.
nœud ← nœud↑.Fils_G ; 3. Écrire une fonction qui permet de retrouver le
Fait ; successeur d’un nœud à partir de la méthode
minimum.
Si père↑.Fils_G=Nil ET père↑.Fils_D=Nil Alors 4. Écrire une fonction qui permet de retrouver le
prédécesseur d’un nœud à partir de la méthode
Écrire (‘(’) ; //feuille comme fils gauche
maximum.
Fsi ;

Écrire (racine↑.valeur) ; //afficher la valeur :opérant ou

// opérateur
Dépiler (pile, nœud ) ; // pour visiter le sous-arbre droit
nœud ← nœud↑.Fils_D ;

-- 7 --
BENADJIMI Noussaiba Révision sur les arbres Université d’Alger/2017

Question 01 : (version itératif) Question 03 : (version itératif)

Fonction Min_ABR (E/ racine: Pointeur) : Pointeur Fonction Succ_ABR (racine: Pointeur, val) : Pointeur
Var nœud : Pointeur Var nœud : Pointeur
Début Début
//////////////////////////////////////////////////////////////// nœud ← Search_ABR( racine,val);
// Il s’agit du nœud le plus à gauche // Si (nœud<>Nil) Alors // le min de sous-arbre droit
////////////////////////////////////////////////////////////////
Succ_ABR ← Min_ABR (nœud↑.Fils_D);
Si (racine <>Nil) Alors Sinon
nœud ← racine ;
TQ (nœud<>Nil) Alors Si (val<Min_ABR (racine)) Alors
Si nœud↑.Fils_G=Nil Alors // le nœud le plus à gauche Succ_ABR ← Min_ABR (racine);
Sinon
Min_ABR ← nœud ;
Fsi ; Si (nœud↑.valeur>Max_ABR (racine)) Alors
nœud ← nœud↑.Fils_G; // n’explorer que les branches Succ_ABR ←Nil;
// gauches
Sinon // chercher l’emplacement d’insertion de val
// comme si on veut insérer la valeur
Fait;
nœud← racine ;
Sinon
TQ (nœud↑.valeur>val) Alors
Min_ABR ← Nil;
Fsi ; nœud ←nœud↑.Fils_D
Fsi ;
Fin ; Succ_ABR ← Min_ABR (nœud↑.Fils_D);
Fsi ;
Question 02 : (version itératif) Fsi ;
Fonction Max_ABR (E/ racine: Pointeur) : Pointeur Fsi ;
Var nœud : Pointeur Fin ;
Début
////////////////////////////////////////////////////////////////
// Il s’agit du nœud le plus à droit // Question 04 : (version itératif)
//////////////////////////////////////////////////////////////// Fonction Pre_ABR (racine: Pointeur, val) : Pointeur
Var nœud : Pointeur
Si (racine <>Nil) Alors
Début
nœud ← racine ;
nœud ← Search_ABR( racine,val);
TQ (nœud<>Nil) Alors
Si (nœud<>Nil) Alors // le min de sous-arbre gauche
Si nœud↑.Fils_D=Nil Alors // le nœud le plus à droite
Pre_ABR ← Max_ABR (nœud↑.Fils_G);
Max_ABR ← nœud ;
Fsi ; Sinon
nœud ← nœud↑.Fils_D; // n’explorer que les branches
Si (val>Max_ABR (racine)) Alors
// droites
Pre_ABR ← Max_ABR (racine);
Fait;
Sinon
Sinon
Max_ABR ← Nil; Si (nœud↑.valeur<Max_ABR (racine)) Alors
Fsi ; Pre_ABR ←Nil;
Fin ; Sinon // chercher l’emplacement d’insertion de val
// comme si on veut insérer la valeur
nœud← racine ;
TQ (nœud↑.valeur<val) Alors
nœud ←nœud↑.Fils_G
Fsi ;
Pre_ABR ← Max_ABR (nœud↑.Fils_G);
Fsi ;
Fsi ;
Fsi ;
Fin ;

Bon courage :)

-- 8 --