IFT-2000: Structures de Données Les arbres. Arbre Un arbre est une structure dans laquelle on a un nœud qui est une racine, puis chaque nœud a zéro, un

IFT-2000: Structures de Données

Les arbres

Arbre• Un arbre est une structure dans laquelle on a un nœud qui

est une racine, puis chaque nœud a zéro, un ou plusieurs enfants.

• Les nœuds qui n’ont pas d’enfants sont appelées des feuilles.

Feuille

Racine

Feuille Feuille Feuille

Arbre binaire

• Un arbre est dit binaire si chacun de ses nœuds comporte un maximum de deux enfants.

Arbre binaire de recherche• Un arbre binaire est dit de recherche s’il respecte la règle

suivante:• Pour chaque nœud, tous ses descendants de gauche comportent

des valeurs plus petites que lui, et tous ses descendants de droite comportent des valeurs plus grandes que lui.

12 40

25

33 57

Implémentation d’une recherche simple

typedef struct nœud{

float valeur;struct nœud *enfant_de_gauche; // 0 s’il n’y a pas d’enfant de gauche.struct nœud *enfant_de_droite; // 0 s’il n’y a pas d’enfant de droite.

} Noeud;Bool est_present(const Nœud *racine, float nombre){

}

Implémentation d’une fonction qui compte les noeuds



} Noeud;int nb_noeuds(const Nœud *racine){

}

Définitions• La hauteur d’un arbre est le nombre de

rangées qu’il comporte.

12 40

25

33 57

Hauteur: 3

Implémentation de la fonction hauteur



} Noeud;int hauteur(const Nœud *racine){

}

Structure pour l’arbre avec un point d’entrée



} Noeud;typedef struct{

Nœud *racine; // 0 si l’arbre est vide.int nb_noeuds; // Ce champ est optionel, mais il permet d’accélérer les requêtes sur la taille.

} Arbre;Int hauteur(const Nœud *racine){ // …}int hauteur(const Arbre *arbre){

return hauteur(arbre->racine);}

Clé de recherche• Une clé de recherche doit toujours être choisie, afin d’établir la relation d’ordre qui

régit la position des nœuds.• D’autres information peut être emmagasinée dans chaque nœud.• Dans l’exemple ci-bas, la clé de recherche est le prénom, et l’information

complémentaire est l’âge. La relation d’ordre utilisée pour déterminer la position relative des nœuds est la comparaison lexicographique (c’est-à-dire l’ordre alphabétique) des prénoms.

Claude55

Jean40

Dominic31

Françis35

Nestor5

Implémentation d’une recherche par clé


char prenom[100];int age;struct nœud *enfant_de_gauche; // 0 s’il n’y a pas d’enfant de gauche.struct nœud *enfant_de_droite; // 0 s’il n’y a pas d’enfant de droite.

} Noeud;int trouve_age(const Nœud *racine, const char *prenom){

}

Ajout (non équilibré)typedef struct nœud{

char prenom[100];int age;struct nœud *enfant_de_gauche; // 0 s’il n’y a pas d’enfant de gauche.struct nœud *enfant_de_droite; // 0 s’il n’y a pas d’enfant de droite.

} Noeud;Nœud *ajouter(Nœud *racine, const char *prenom, int age){

}

Arbre binaire de recherche équilibré• Un arbre binaire de recherche est dit équilibré (ou balancé)

quand on lui impose un critère sur la position de ses nœuds, et que ce critère permet de maintenir une hauteur de l’ordre du logarithme du nombre de nœuds qu’il comporte.

Arbre bien équilibré Arbre mal équilibré

Arbre binaire de recherche AVL• Il existe deux façons bien connues d’équilibrer

les arbres binaires de recherche: Les arbres AVL, et les arbres Rouge-Noir. Pour le cours de Structures de Données, nous ne nous attarderons qu’aux arbres AVL.

• Dans un arbre AVL, la règle de l’équilibre est la suivante:

Pour chaque nœud, la hauteur de son sous-arbre de gauche et celle de son sous-arbre de droite

doivent différer d’au maximum 1.

Équilibre AVL

111

2 2

3

Bien équilibré selon la règle AVL

1

2 1

3


112

3 2

4


1

12

3 1

4

Mal équilibré selon la règle AVL

1

Nœud critique

Mais ce n’est pas toujours le cas

12

3 1

4

Ici, le nœud critique du déséquilibreest la racine

1

• Quand il y a un déséquilibre, le nœud le plus bas à partir duquel il y a une différence de 2 ou plus est appelé le nœud critique.

Plusieurs nœuds critiques• Il peut parfois y avoir plusieurs nœuds critiques.

Dans ce cas, on s’occupe d’abord du plus bas de tous.

Maintien de l’équilibre• Quand on implémente un arbre AVL, il faut maintenir son équilibre.• Les déséquilibres surviennent soit lors d’un ajout, soit lors d’une

suppression.• Le ou les nœuds critiques engendrés, s’il y a lieu, sont toujours sur le

chemin de l’ajout ou de la suppression.

Nouveaunoeud

Rééquilibrer un arbre déséquilibré• Quand un déséquilibre apparaît, il faut

remodeler la partie de l’arbre dont la racine est le nœud critique.

Nouveaunoeud

Les quatre cas de déséquilibre• Il faut d’abord identifier le genre de déséquilibre auquel on a affaire.• D’abord, il faut voir de quel côté l’arbre penche à partir du nœud

critique.• Dans le cas de l’exemple ci-bas, c’est vers la gauche.

Nouveaunoeud

Les quatre cas de déséquilibre• L’enfant immédiat du nœud critique du côté

vers lequel l’arbre penche s’appelle le nœud sous-critique.

Nœudcritique

Nœudsous-critique

Nouveaunoeud

Les quatre cas de déséquilibre• Puis il faut regarder de quel côté penche l’arbre à partir du nœud sous-

critique.• L’arbre sous-critique n’a pas besoin d’être déséquilibré pour qu’on considère

qu’il penche. Une différence de 1 suffit pour identifier le cas (contrairement à la vérification qu’on faisait au départ pour vérifier s’il y avait déséquilibre).

• Dans l’exemple ci-bas, l’arbre sous-critique penche vers la droite.

Nœudcritique

Nœudsous-critique

Nouveaunoeud

Les quatre cas de déséquilibre• Nous avons donc, dans cet exemple-ci, un déséquilibre vers la gauche, avec un

arbre sous-critique qui penche vers la droite.• Quand le sens du déséquilibre principal est différent du sens dans lequel

l’arbre sous-critique penche, alors deux rotations sont nécessaires. Nous appelons ça un zig-zag.

• Quand le sens du déséquilibre principal est le même que le sens dans lequel l’arbre sous-critique penche, ou bien que l’arbre sous-critique ne penche pas dutout, alors une seule rotation est nécessaire, et il s’agit d’un zig-zig.

• Dans notre exemple, nous aurons donc à faire deux rotations.

Nœudcritique

Nœudsous-critique

Nouveaunoeud

Les rotations• Quand nous nous retrouvons dans le cas où il

faut faire deux rotations, la première sert finalement à faire pencher l’arbre sous-critique dans le même sens que l’arbre critique, de façon à nous retrouver dans le cas simple d’une seule rotation.

Nœudcritique

Nœudsous-critique

Nouveaunoeud

Les rotations

Nœudcritique

Nœudsous-critique

Nouveaunoeud

• Première rotation (préparatoire à la deuxième).

Les rotations

Nœudcritique

Nouveaunoeud


Les rotations

Nœudcritique

Nouveaunoeud


Les rotations

Nœudcritique

Nouveaunoeud


Les rotations

Nœudcritique

Nouveaunoeud


Les rotations

Nœudcritique

Nouveaunoeud


Les rotations

Nœudcritique

Ancien nœudsous-critique

Nouveaunoeud

Nœudnouvellementsous-critique

• La première rotation est terminée.• Grâce à cette première rotation, nous avons retrouvé un cas de rotation

simple, car l’arbre sous-critique penche maintenant dans le même sens que le déséquilibre au nœud critique.

Les rotations

Nœudcritique

Nouveaunoeud

• Deuxième rotation.

Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud


Les rotations

Nouveaunoeud

• Les deux rotations sont terminées, nous avons maintenant un arbre AVL équilibré.

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Voici un autre exemple d’ajout. Celui-ci engendre un cas simple de déséquilibre, car l’arbre sous-critique penche dans le même sens que le déséquilibre au nœud critique.

• Supposons que nous ajoutons un nœud avec la valeur de clé 40 à l’arbre ci-bas.40

Les rotations

<50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

<50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

<50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

>25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

>25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

45

85

8

48

28

38

>36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

45

85

8

48

28

38

>36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

<45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

<45

85

8

48

28

38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

45

85

8

48

28

>38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

45

85

8

48

28

>38

36 60

26

64 9055

62

17

• Ajout de 40.

40

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• La position du nouveau nœud 40 a été déterminée. On doit donc, en remontant, vérifier si l’arbre est déséquilibré.

40

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• On vérifie l’équilibre nœud par nœud, en remontant le long du chemin parcouru depuis la racine.

40

10

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17


40

12

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17


40

32

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17


• Un déséquilibre est détecté au nœud 25.

40

42

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17


• Un déséquilibre est détecté au nœud 25.• Le nœud sous-critique est le nœud 36.

40

Les rotations

50

25 70

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• On constate que l’arbre sous-critique penche dans le même sens que le déséquilibre au nœud critique.

• On aura donc une seule rotation à faire.

40

Les rotations

50

2570

13

45

85

8

48

28

38

36 60

26

64 9055

62

17

• On a une seule rotation à faire.

40

Les rotations

50

2570

13

45

85

8

48

28

38

36 60

26

64 9055

62

17


40

Les rotations

50

25

70

1345

85

8 48

28

38

36 60

26

64 9055

6217


40

Les rotations

50

25

70

13 45

85

848

28

38

3660

26

64 9055

6217


40

Les rotations

50

25

70

13

4585

8

4828

38

36

60

26

64 9055

6217


40

Les rotations

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217


40

Les rotations

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217

• On a une seule rotation à faire.• Nous avons donc rééquilibré l’arbre à partir du nœud

critique que nous avions.• Il reste encore à vérifier l’équilibre pour le reste du chemin

en remontant à la racine, car il pourrait y en avoir d’autres.

40

Les rotations

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217




40

Les rotations

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217

• En l’occurrence, il ne reste qu’à vérifier qu’il n’y a pas de déséquilibre au nœud 50.

40

4 4

Les rotations

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217




40

Implémentation d’une rotationNœud *rotation_gauche(Nœud *racine){

Nœud *nouvelle_racine=racine->droite;

racine->droite = nouvelle_racine->gauche;

nouvelle_racine->gauche = racine;return nouvelle_racine;

}

25

13

458

48

28

38

36

26

17

40

25

13

45

8

4828 38

36

2617 40

Implémentation d’un rééquilibreNœud *reequilibrer_si_necessaire(Nœud *racine){

int diff;if(!racine) return racine;diff = hauteur(racine->droite)-hauteur(racine->gauche);if(diff>1){

Nœud *sous_critique = racine->droite;int diff_sous_critique = hauteur(sous_critique->droite)-hauteur(sous_critique->gauche);if(diff_sous_critique<0) sous_critique = rotation_droite(sous_critique);racine=rotation_gauche(racine);

}else if(diff<-1){

Nœud *sous_critique = racine->gauche;int diff_sous_critique = hauteur(sous_critique->droite)-hauteur(sous_critique->gauche);if(diff_sous_critique>0) sous_critique = rotation_gauche(sous_critique);racine=rotation_droite(racine);

}return racine;

}

Intégration du rééquilibre dans l’algorithme d’ajout

Nœud *ajout(Nœud *racine, float nouvelle_valeur){

if(!racine){

racine = malloc(sizeof(Nœud));racine->gauche=racine->droite=0;racine->valeur = nouvelle_valeur;

}else if(nouvelle_valeur<racine->valeur)

racine->gauche = ajout(racine->gauche,nouvelle_valeur);else if(nouvelle_valeur>racine->valeur)

racine->droite = ajout(racine->droite,nouvelle_valeur);return reequilibrer_si_necessaire(racine);

}

Algorithme de recherche du successeur

• Dans un ensemble ordonné, le successeur d’une valeur est la valeur qui la suit immédiatement dans l’ordre.

• Par exemple, dans l’ensemble ordonné { 3, 6, 7, 12, 17, 18, 22 }, le successeur de 12 est 17, le successeur de 3 est 7, et 22 n’a pas de successeur.


• Dans un arbre AVL, le successeur peut être découvert en descendant une fois à droite, puis autant de fois que l’on peut à gauche.

• Par exemple, dans cet arbre-ci, le successeur de 50 est 55.50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217 40


• Le successeur de 70 est 85. En effet, on descend une fois à droite, et on va à gauche tant et aussi longtemps qu’on le peut, mais ça c’est bien s’il y a un enfant de gauche. Sinon, on a déjà trouvé le successeur.

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217 40


• Comment faire pour retrouver le successeur d’un nœud qui n’a pas d’enfant de droite?

• Par exemple, comment faire pour trouver le successeur de 28? 50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217 40


• Ce qu’il faut faire, dans ce cas, c’est remonter de parent en parent jusqu’à ce que ce soit vers la droite que se trouve le parent.

• Dès que l’on a remonté une fois vers la droite, alors nous avons le successeur.

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217 40


• Si, par ce processus, on aboutit à la racine en n’ayant jamais remonté à droite, c’est alors parce que le nœud n’a pas de successeur.

50

25

70

13

45 85

8

4828

38

36

60

26

64 9055

6217 40

Implémentation de l’algorithme de recherche du successeur

Nœud *successeur(Nœud *racine, float valeur){

if(!racine) { ??? (nous aborderons ce cas plus tard) }// Il faut d’abord retrouver le nœud dont on cherche le successeur.if(valeur<racine->valeur) return successeur(racine->gauche,valeur);else if(valeur>racine->valeur) return successeur(racine->droite,valeur);else if(valeur==racine->valeur) // On a trouvé le nœud dont on cherche le successeur.

if(racine->droite) // Cas simple{

Nœud *i=racine->droite; //Une fois à droitewhile(i->gauche) i=i->gauche; // À gauche tant et aussi longtemps

qu’on peut.return i;

}else // Cas compliqué{ // Comment faire quand le nœud dont on cherche le successeur n’a pas d’enfant

de droite? }

}


• Pour résoudre le cas compliqué, l’astuce est la suivante: la fonction récursive retourne tout simplement zéro comme réponse! Cela est pour signifier à l’appelant que cet appel-ci n’a pas été capable de trouver le successeur. Puis, à l’endroit où la fonction fait un appel récursif sur l’enfant de gauche, avant de retourner simplement la réponse reçue, on vérifie si c’est zéro qui a été retourné. Si c’est le cas, alors le successeur est précisément le nœud « racine »!



if(!racine) { ??? }if(valeur<racine->valeur){

Nœud *s = successeur(racine->gauche,valeur);if(s==0) return racine; // Ceci résout le cas compliqué!return s;

}else if(valeur>racine->valeur) return successeur(racine->droite,valeur); else if(valeur==racine->valeur) // On a trouvé le nœud dont on cherche le successeur.

if(racine->droite) // Cas simple{

Nœud *i=racine->droite; while(i->gauche) i=i->gauche; return i;

}else return 0; // Cas compliqué: on retourne zéro!

}


• Dans le cas où la valeur dont on cherche le successeur n’est pas présente dans l’arbre, on pourrait avoir comme réflexe de retourner un code d’erreur.

• Par contre, il faut sauter sur l’occasion pour implémenter un algorithme bien plus puissant, puis de retourner quand même le successeur de cette valeur.

• Pour ce faire, il suffit de retourner zéro, et la même ligne de code qui réglait le cas compliqué retournera la bonne valeur pour le cas où la valeur est introuvable.



if(!racine) return 0; // Ceci sera résolu de la même façon que le cas compliqué.if(valeur<racine->valeur){

Nœud *s = successeur(racine->gauche,valeur);if(s==0) return racine; // Ceci résout aussi le cas de la valeur absente dans

l’arbre!return s;

}else if(valeur>racine->valeur) return successeur(racine->droite,valeur); else if(valeur==racine->valeur)

if(racine->droite){

Nœud *i=racine->droite; //Une fois à droitewhile(i->gauche) i=i->gauche;return i;

}else return 0;

}

Algorithme du prédécesseur

• Évidemment, pour implémenter l’algorithme de recherche du prédécesseur, il suffit de faire la même chose, mais en inversant gauche et droite.

Algorithme de suppression• Pour supprimer un nœud dans un arbre AVL, il y a deux cas simples et un

cas compliqué:– Premier cas simple: le nœud à supprimer est une feuille.

• Dans ce cas, il suffit de le supprimer directement.– Deuxième cas simple: le nœud à supprimer possède un seul enfant.

• Dans ce cas, il suffit de le supprimer et de le remplacer par son seul enfant.– Cas compliqué: le nœud à supprimer a deux enfants.

• Dans ce cas, il faut d’abord échanger ce nœud avec son successeur, puis le supprimer à son nouvel endroit, ce qui nous mènera nécessairement à l’un des deux cas simples.

• Bien entendu, il faut aussi vérifier les déséquilibres en remontant jusqu’à la racine.

• L’algorithme fonctionne aussi bien si on prend le prédécesseur plutôt que le successeur.

• Étant donné que la nécessité de retrouver le successeur ne survient que dans le cas où le nœud a deux enfants, alors nous sommes nécessairement toujours en présence du cas simple de recherche du successeur! Ainsi, une simple boucle suffit.

Exemple de suppression AVL• Supprimons le nœud 36 de cet arbre-ci.• Il faut d’abord le repérer avec une recherche

conventionnelle à partir de la racine.50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Puis, nous établissons qu’il s’agit d’un cas

compliqué car le nœud à supprimer a deux enfants. 50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Il faut donc d’abord retrouver son successeur à

l’aide d’une boucle simple (une fois à droite, plein de fois à gauche). 50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Puis on l’échange avec.

50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

3660

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

3660

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37


50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Remarquez que la règle d’ordonnancement

d’arbre binaire de recherche est temporairement enfreinte.50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Ensuite, on continue à descendre

récursivement pour supprimer 36, comme si rien n’était. 50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Puis lorsqu’on retombe sur 36, on arrive

nécessairement à l’un des deux cas simple.50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37

Exemple de suppression AVL• Dans ce cas-ci, il s’agit du cas avec un seul

enfant. 36 sera donc remplacé par 38.50

25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37



25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 40

38

37



25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 4038

37



25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 4038

37



25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 4038

37



25

70

13

45 85

8

4828 39

36

60

26

64 9055

6217 4038

37

Exemple de suppression AVL• Puis le nœud 36 est détruit avec « free ».• Ensuite, il faut remonter jusqu’à la racine pour

vérifier l’équilibre de l’arbre.50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

0 0



25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

1 1



25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

2 1



25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

373 3



25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

4 4

Les parcours d’arbre• Parcours symétrique (donne les nœuds en ordre croissant):

– Gauche, racine, droite.• Parcours anti-symétrique (donne les nœuds en ordre

décroissant):– Droite, racine, gauche.

• Parcours par priorité aux pères (aucune interprétation simple):– Racine, gauche, droite (ou racine, droite, gauche).

• Parcours par priorité aux fils (aucune interprétation simple):– Gauche, droite, racine (ou droite, gauche, racine).

• Parcours rangée par rangée:– Ne peut pas s’implémenter par une fonction récursive simple. On

doit l’implémenter comme un parcours de graphe par largeur, donc avec une file.

Implémentation de parcours d’arbrevoid parcours_symétrique(Nœud *racine){

if(!racine) return;parcours_symétrique(racine->gauche);traitement(racine); // Traitement quelconque.parcours_symétrique(racine->droite);

}void parcours_anti_symétrique(Nœud *racine){

if(!racine) return;parcours_anti_symétrique(racine->droite);traitement(racine);

parcours_anti_symétrique(racine->gauche);}

void parcours_par_priorite_aux_peres(Nœud *racine){

if(!racine) return;traitement(racine);parcours_par_priorite_aux_peres (racine->gauche); // Ça pourrait être droite avant gauche.parcours_par_priorite_aux_peres (racine->droite);

}void parcours_par_priorite_aux_fils(Nœud *racine){

if(!racine) return;parcours_par_priorite_aux_fils (racine->gauche); // Ça pourrait être droite avant gauche.parcours_par_priorite_aux_fils (racine->droite);traitement(racine);

}

Traces de parcours d’arbre

• Soit cet arbre-ci:

50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37


• Parcours symétrique: 8, 13, 17, 25, 26, 28, 37, 38, 39, 40, 45, 48, 50, 55, 60, 62, 64, 70, 85, 90.

50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37


• Parcours anti-symétrique: 90, 85, 70, 64, 62, 60, 55, 50, 48, 45, 40, 39, 38, 37, 28, 26, 25, 17, 13, 8.

50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

Traces de parcours d’arbre• Parcours par priorité aux pères (gauche avant

droite): 50, 37, 25, 13, 8, 17, 28, 26, 45, 39, 38, 40, 48, 70, 60, 55, 64, 62, 85, 90.

50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

Traces de parcours d’arbre• Parcours par priorité aux fils (gauche avant

droite): 8, 17, 13, 26, 28, 25, 38, 40, 39, 48, 45, 37, 55, 62, 64, 60, 90, 85, 70, 50.

50

25

70

13

45 85

8

4828 39

60

26

64 9055

6217 4038

37

Documents

IFT-2000: Structures de Données Les arbres. Arbre Un arbre est une structure dans laquelle on a un nœud qui est une racine, puis chaque nœud a zéro, un