Les arbres
3.2 LES ARBRES BINAIRES
3.2.9 Arbre binaire et questions de l’arbre n-aire
fprintf (fs, "%s\n", ligne);
recopierListe (lc, ls); // ls vide }
// détruire l'arbre intermédiaire detruireArbre (narbre);
}
3.2.9 Arbre binaire et questions de l’arbre n-aire
Dans de nombreuses applications, l’arbre est donné sous sa forme n-aire. C’est le cas de la nomenclature d’un objet comme par exemple les composantes et sous-composantes d’un avion, d’une voiture, d’une maison, de la Terre, ou du corps humain. Le nombre de sous-composantes étant variable (le degré des nœuds est variable), la mémorisation se fait par conversion de l’arbre n-aire en un arbre binaire (voir Figure 57). Il faut alors répondre à des questions de l’arbre n-aire en utilisant la mémorisation de l’arbre binaire. Ainsi, pour l’arbre généalogique de racine Julie, les feuilles de l’arbre n-aire correspondent aux personnes sans enfant (Pauline, Sonia, Paul, Antonine) et sont différentes des feuilles de l’arbre binaire (Paul, Antonine) qui n’ont pas d’intérêt pour l’application. Dans une nomenclature d’objet, les feuilles n-aires sont les composants (les pièces) de base qu’il faut assembler pour constituer l’objet.
Remarque : ayant un pointeur sur un nœud de l’arbre binaire (fourni par exemple par la fonction trouverNoeud() (voir § 3.2.4.e, page 119), les descen-dants n-aires de ce nœud se trouvent dans le sous-arbre gauche. L’appel des diverses fonctions traitant de la descendance n-aire d’un nœud racine se fait donc en explorant le SAG du nœud de départ.
3.2.9.a Feuilles n-aires
Une feuille n-aire a un sous-arbre gauche vide, le pointeur sur le premier fils est à NULL. La fonction listerFeuillesNAire() est donc un parcours d’arbre binaire avec écriture pour les nœuds qui ont un sous-arbre gauche vide.
04Chap_03 Page 130 Samedi, 17. janvier 2004 10:37 10
3.2 • Les arbres binaires 131
© Dunod – La photocopie non autorisée est un délit.
// lister les feuilles NAire à partir de racine static void listerFeuillesNAire (Noeud* racine,
char* (*toString) (Objet*)) { if (racine != NULL) {
if (racine->gauche == NULL) printf ("%s ",
toString (racine->reference));
listerFeuillesNAire (racine->gauche, toString);
listerFeuillesNAire (racine->droite, toString);
} }
Ayant un pointeur sur un nœud racine de l’arbre binaire, il faut explorer seule-ment le sous-arbre gauche de ce nœud racine. On crée un nouveau nœud racine ayant un sous-arbre droit vide.
void listerFeuillesNAire (Arbre* arbre) { if (arbre->racine != NULL) {
Noeud* nrac = cNd (arbre->racine->reference,
arbre->racine->gauche, NULL);
Arbre* narbre = creerArbre (nrac, arbre->toString, NULL);
listerFeuillesNAire (narbre->racine, narbre->toString);
free (nrac);
free (narbre);
} }
Pour compter le nombre de feuilles n-aires, le principe est le même. Il faut compter au lieu d’écrire.
// fournir le nombre de feuilles n-aires à partir de racine static int nbFeuillesNAire (Noeud* racine) {
int n = 0;
if (racine == NULL) { return 0;
} else {
if (racine->gauche == NULL) n = 1;
return n + nbFeuillesNAire (racine->gauche) + nbFeuillesNAire (racine->droite);
} }
int nbFeuillesNAire (Arbre* arbre) { int n = 0;
if (arbre->racine != NULL) {
Noeud* nrac = cNd (arbre->racine->reference,
arbre->racine->gauche, NULL);
Arbre* narbre = creerArbre (nrac, arbre->toString, NULL);
n = nbFeuillesNAire (narbre->racine);
free (nrac);
free (narbre);
}
return n;
}
04Chap_03 Page 131 Samedi, 17. janvier 2004 10:37 10
132 3 • Les arbres
3.2.9.b Descendants n-aires
Cette fonction énumère tous les descendants n-aires d’un nœud. Si racine repère le nœud « Jonatan », descendantsNAire (racine, toString) fournit Pauline Sonia Paul (voir Figure 57). Il faut faire un parcours préfixé du SAG de Jonatan.
// fournir les descendants n-aires de racine
static void descendantsNAire (Noeud* racine, char* (*toString) (Objet*)) { if (racine != NULL) {
if (racine->gauche == NULL) {
printf ("Pas de descendant pour %s\n",
toString (racine->reference));
} else {
prefixe (racine->gauche, toString ); // descendants dans SAG }
} }
void descendantsNAire (Arbre* arbre) {
return descendantsNAire (arbre->racine, arbre->toString);
}
3.2.9.c Parcours indenté n-aire
Le parcours indenté de l’arbre binaire de la Figure 58 conduit au résultat suivant (voir fonction indentationPrefixee(),§ 3.2.4.d, page 119) qui peut être intéressant pour la mise au point des diverses fonctions basées sur la mémorisation de cet arbre binaire mais n’a pas de signification particulière pour l’application.
Parcours préfixé (avec indentation binaire) Julie
Jonatan Pauline Sonia Paul Gontran
Antonine
L’indentation n-aire est plus proche de l’application (voir Figure 57), et affiche les fils d’un nœud avec le même décalage comme indiqué ci-dessous. Il faut explorer le SAG du nœud de départ. C’est un parcours d’arbre avec changement de niveau quand on descend dans le SAG (vers le premier fils). Le SAD concerne les frères qui sont au même niveau.
Indentation n-aire Julie
Jonatan Pauline Sonia Paul Gontran
Antonine
04Chap_03 Page 132 Samedi, 17. janvier 2004 10:37 10
3.2 • Les arbres binaires 133
© Dunod – La photocopie non autorisée est un délit.
// parcours n-aire indenté
static void indentationNAire (Noeud* racine, char* (*toString) (Objet*), int niveau) { if (racine != NULL) {
for (int i=1; i<niveau; i++) printf ("%5s", " ");
printf ("%s\n", toString (racine->reference));
indentationNAire (racine->gauche, toString, niveau+1);
indentationNAire (racine->droite, toString, niveau);
} }
void indentationNAire (Arbre* arbre) { if (arbre->racine != NULL) {
Noeud* nrac = cNd (arbre->racine->reference, arbre->racine->gauche, NULL);
Arbre* narbre = creerArbre (nrac, arbre->toString, NULL);
indentationNAire (narbre->racine, arbre->toString, 1);
free (nrac);
free (narbre);
} }
3.2.9.d Ascendants n-aires
La fonction ascendantsNAire() énumère les ascendants sur l’arbre n-aire d’un nœud donné. ascendantsNaire (racine, “Paul”) fournit Jonatan Julie. Sur l’arbre n-aire (voir Figure 57), l’ascendant direct de Paul est Jonatan, l’ascendant direct de Jonatan est Julie. Il faut faire un parcours d’arbre interrompu quand on a trouvé l’objet cherché et écrire uniquement quand on remonte d’un SAG (voir Figure 58), donc après l’appel récursif examinant le SAG. La fonction fournit vrai si on a trouvé, faux sinon. Cette fonction est très proche de la fonction trouverNoeud() qui elle, fournit un pointeur sur le nœud recherché. La fonction utilise deux pointeurs de fonctions : un pour écrire les caractéristiques des nœuds et l’autre pour trouver le nœud dont on veut les ascendants.
// fournir les ascendants n-aires de "objet"
static booleen ascendantsNAire (Noeud* racine, Objet* objet,
char* (*toString) (Objet*), int (*comparer) (Objet*, Objet*)) { booleen trouve;
if (racine == NULL) { trouve = faux;
} else if ( comparer (objet, racine->reference) == 0 ) { printf ("%s ", toString (racine->reference));
trouve = vrai;
} else {
trouve = ascendantsNAire (racine->gauche, objet, toString, comparer);
if (trouve) {
printf ("%s ", toString (racine->reference));
} else {
trouve = ascendantsNAire (racine->droite, objet, toString,
comparer);
} }
return trouve;
}
04Chap_03 Page 133 Samedi, 17. janvier 2004 10:37 10
134 3 • Les arbres
booleen ascendantsNAire (Arbre* arbre, Objet* objet) { return ascendantsNAire (arbre->racine, objet,
arbre->toString, arbre->comparer);
}
3.2.9.e Parcours en largeur n-aire
Le parcours en largeur consiste à traiter les nœuds de l’arbre étage par étage en partant de la racine. Ainsi, sur l’arbre n-aire de la Figure 57, l’énumération en largeur fournit : Julie, Jonatan Gontran, Pauline Sonia Paul Antonine. On peut également réécrire le nom du sous-arbre et obtenir un fichier décrivant l’arbre n-aire sous la forme suivante, ce que fait le programme enLargeurNAire() ci-dessous.
Julie: Jonatan Gontran;
Jonatan: Pauline Sonia Paul;
Gontran: Antonine;
La méthode consiste à créer une liste, chaque élément de la liste pointant sur un nœud de l’arbre. Au début, la liste li contient un seul élément pointant sur la racine de l’arbre (voir Figire 73). Ensuite, tant que la liste n’est pas vide, on extrait l’élément en tête de la liste li, et on insère en fin de liste les fils n-aires du nœud. Sur l’exemple, on extrait l’élément de la liste pointant sur Julie et on insère dans la liste devenue vide, les fils n-aires de Julie, soit Jonatan et Gontran. Au tour suivant, Jonatan est remplacé par ses fils n-aires Pauline, Sonia, Paul, et Gontran est remplacé par Antonine. Là également, on utilise la mémorisation de l’arbre binaire pour répondre à des questions de l’arbre n-aire.
Julie /
Jonatan
Pauline /
Sonia /
Paul / /
Gontran /
Antonine / /
/ /
li
Figure 73 Parcours en largeur n-aire d’un arbre binaire.
04Chap_03 Page 134 Samedi, 17. janvier 2004 10:37 10
3.2 • Les arbres binaires 135
© Dunod – La photocopie non autorisée est un délit.
static void enLargeurNAire (Noeud* racine, char* (*toString) (Objet*)) { Liste* li = creerListe();
insererEnFinDeListe (li, racine);
while (!listeVide (li) ) {
Noeud* extrait = (Noeud*) extraireEnTeteDeListe (li);
Noeud* p1F = extrait->gauche; // premier fils
if (p1F != NULL) printf ("%s: ", toString (extrait->reference));
Noeud* pNF = p1F;
void enLargeurNAire (Arbre* arbre) { if (arbre->racine != NULL) {
Noeud* nrac = cNd (arbre->racine->reference, arbre->racine->gauche, NULL);
Arbre* narbre = creerArbre (nrac, arbre->toString, NULL);
enLargeurNAire (narbre->racine, arbre->toString);
free (nrac);
free (narbre);
} }
3.2.9.f Duplication d’un arbre n-aire sur N niveaux
La fonction dupArbreNAireSNNiv() duplique nbniveau d’un arbre n-aire à partir du nœud racine en utilisant la mémorisation de l’arbre binaire. Ainsi, sur l’arbre n-aire de la Figure 57, on peut ne mémoriser que 2 niveaux soit Julie et Jonatan-Gontran.
L’algorithme est un algorithme de duplication d’arbre, y compris des objets réfé-rencés (voir § 3.2.6, page 125), le niveau nbniveau étant décrémenté quand on descend dans un SAG vers le premier fils. Il y a arrêt des appels récursifs si l’arbre est vide ou si nbniveau vaut 0.
static Noeud* dupArbreNAireSNNiv (Noeud* racine, int nbniveau,
Objet* (*cloner) (Objet*)) { if ((racine == NULL) || (nbniveau==0) ) {
return NULL;
} else {
Noeud* nouveau = cNd (cloner (racine->reference));
nouveau->gauche = dupArbreNAireSNNiv (racine->gauche, nbniveau-1, cloner);
nouveau->droite = dupArbreNAireSNNiv (racine->droite, nbniveau, cloner);
return nouveau;
} }
Arbre* dupArbreNAireSNNiv (Arbre* arbre, int nbniveau,
Objet* (*cloner) (Objet*)) { Noeud* racine = dupArbreNAireSNNiv (arbre->racine, nbniveau, cloner);
return creerArbre (racine);
}
04Chap_03 Page 135 Samedi, 17. janvier 2004 10:37 10
136 3 • Les arbres
3.2.9.g Dessin d’un arbre n-aire
La fonction dessinerArbreNAire (Noeud* racine, FILE* fs) ; dessine un arbre en mettant en évidence les successeurs n-aires d’un nœud comme l’indique le schéma de la Figure 74.
| | _______Julie_______
| | | | ______Jonatan______ Gontran | | | | | | | | Pauline Sonia Paul Antonine
Figure 74 Dessin n-aire d’un arbre.
L’arbre à dessiner est dupliqué en ajoutant pour chaque nœud sa position (son numéro de colonne) sur la feuille de dessin. Les feuilles n-aires de l’arbre sont numérotées dans un parcours infixé : Pauline 1, Sonia 2, Paul 3, Antonine 4. La posi-tion d’un nœud qui n’est pas une feuille n-aire est la moyenne de la posiposi-tion de son premier et dernier fils n-aires. Ainsi Jonatan se trouve en position (1+3)/2 = 2.
Gontran est en position 4. Julie est en position (2+4)/2=3. Cette position est multi-pliée par la valeur du plus long identificateur déterminé par la fonction maxIdent().
On effectue alors un parcours en largeur. Connaissant les positions (numéros de colonne) de chaque nœud, l’algorithme procède de la même manière que pour le dessin de l’arbre binaire (voir § 3.2.8, page 127). On insère dans une liste lc un poin-teur sur la racine de l’arbre à dessiner. On dessine les éléments de la liste courante lc, et on les remplace par leurs fils n-aires dans une liste des suivants ls qui devient la liste courante pour le prochain tour. Les tirets entourant le nom sont écrits entre la position du premier fils et du dernier fils n-aires.
Exercice 16 - Dessin n-aire d’un arbre
En utilisant le module de gestion de listes (voir § 2.3.8, page 48), et en vous inspirant de l’algorithme dessinerArbre() (voir § 3.2.8, page 127), écrire :
• la fonction : static Arbre* dupArbN (Arbre* arbre, int lgM) ; qui duplique l’arbre et calcule la position de chaque nœud de l’arbre. La fonction maxIdent() (voir
§ 3.2.5.c, page 123) permet de calculer la valeur lgM (largeur maximale d’une colonne).
• la fonction : void dessinerArbreNAire (Arbre* arbre, FILE* fs) ; qui dessine l’arbre comme indiqué sur la Figure 74.
04Chap_03 Page 136 Samedi, 17. janvier 2004 10:37 10
3.2 • Les arbres binaires 137
© Dunod – La photocopie non autorisée est un délit.