IN 101 - Cours 12 1 Arbres

IN 101 - Cours 12
1 Arbres
1.1 Structure d’arbre
Un arbre est une structure de donn´ee permettant de stocker des informations de mani`ere
hi´erarchique.
Fils
racine
feuilles
arc
noeuds internes
sous−arbre
père
Frères
Dans un arbre, des nœuds (dit parents) sont connect´es `a des des nœuds (dits fils) par des arcs.
Les nœuds sans fils sont des feuilles.
Les nœuds sans parent sont des racines.
Dans un arbre, les arcs connectant les nœuds ne forment pas de boucle (un nœud fils ne
peut ˆetre le parent de son parent).
Dans un arbre, il n’y a pas de raccourci (chaque nœud a au plus un parent).
Degr´e d’un nœud : nombre de fils.
Arit´e d’un arbre : nombre maximal de fils.
Arité 2: arbre binaire Arité > 2: arbre n−aire
1.2 Impl´ementation d’arbres
Les arbres g´en´eraux peuvent ˆetre implant´es en C en repr´esentant un nœud par une structure
contenant une liste chaˆın´ee de fr`eres et chaque p`ere a un pointeur sur son premier fils.
1

child
data
child
brother
brother brother brother
child
child
struct node {
int data ;
struct node ∗c h i l d ;
struct node ∗b r o t h e r ;
};
Les arbres binaires peuvent ˆetre impl´ement´es en repr´esentant un nœud par une structure conte-
nant un pointeur vers chaque fils.
data rightleft
struct bnode {
int data ;
struct bnode ∗left ;
struct bnode ∗r i g h t ;
};
Les arbres binaires peuvent aussi ˆetre impl´ement´es en utilisant un tableau dans lequel les fils
d’un nœud d’indice isont aux indices 2i+ 1 et 2i+ 2. Son p`ere est `a l’indice floor((i−1)/2).
ea
012345 76
bcd f g h
8 9
a
bc
def g
h
2 * 0 + 1
2 * 0 + 2 4 * 0 + 1
1.3 Parcours d’arbre
Parcourir un arbre en profondeur d’abord (DFS) consiste `a r´ecursivement explorer tous les les
fils d’un nœud. Sur un arbre binaire ¸ca consiste `a explorer r´ecursivement le sous-arbre fils droit
puis le sous-arbre fils gauche (ou inversement).
void d f s ( struct b node ∗n )
{
i f ( n != NULL) {
t r a i t e m e n t ( o p t i o n n e l ) 1
;
d s f ( n−>l e f t ) ;
t r a i t e m e n t ( o p t i o n n e l ) 2
;
d s f ( n−>r i g h t ) ;
t r a i t e m e n t ( o p t i o n n e l ) 3
;
}
Trois parcours en profondeur possibles : pr´efixe (traitement 1), infixe (traitement 2), postfixe
(traitement 3).
Parcourir un arbre en largeur d’abord (BFS) consiste `a parcourir ses nœud par niveau de
profondeur . On visite d’abord tous les nœuds de mˆeme profondeur.
Le parcours en largeur d’abord s’appuie sur une structure de file.
2

/
1
5
0
2
3 4
7
6
void largeur (struct b node ∗n )
{
en qu eu e ( n ) ;
wh ile ( ( n = t ake ( ) ) != NULL) {
do something (n−>data ) ;
i f ( n−>l e f t != NULL)
en qu eu e ( n−>l e f t ) ;
i f ( n−>r i g h t != NULL)
en qu eu e ( n−>r i g h t ) ;
}
}
1.4 Arbre binaire de recherche
Un arbre binaire de recherche est tel que chaque nœuds contient une clef.
La clef d’un nœud est >`a celle de son fils gauche (donc `a celles de tous les nœuds du sous-arbre
gauche).
La clef d’un nœud est <`a celle de son fils droit (donc `a celles de tous les nœuds du sous-arbre
droit).
> 42
21
7
1
8
6410
22 38
42
> 21< 21
> 21 et < 42
35
La recherche s’effectue par comparaison de la clef recherch´ee avec celle du nœud courant lors
d’un parcours en profondeur d’abord.
Absent
35 ?
21
Présent
1
8
35 6410
22 38
42
35 > 21
35 < 42
23 ?
21
35 64
22 38
42
23 > 21
23 < 42
23 < 35
23 > 22
7
1
8
7
10
b o ol s e a r c h ( int v , struct b node ∗n )
{
i f ( n == NULL) return ( f a l s e ) ;
i f ( v == n−>data ) return ( t r u e ) ;
i f ( v <n−>data )
return ( s e a r c h ( v , n−>l e f t ) ) ;
else
return ( s e a r c h ( v , n−>r i g h t ) ) ;
}
La complexit´e des op´erations de recherche, insertion, suppression dans un arbre binaire de
recherche est g´en´eralement meilleure que dans les structures de tables .
3