Les arbres 2-3

Laurent Cheno
Luminy, - mai
http://lcheno.free.fr/arbres23/

R
esum
e
Nous decrivons ici les arbres 2-3, structure (decrite pour la premi`ere fois en ) darbres de
recherche qui maintiennent un equilibrage susant pour garantir par exemple un tri en O(n lg n).
Nous presentons le code Caml correspondant aux fonctions de base sur une telle structure (recherche,
insertion, suppression, et donc tri). Nous donnons egalement les elements theoriques qui permettraient
une generalisation aux arbres a-b sous la condition b
2a 1
3. Enn, nous tentons une approche
combinatoire de la structure presentee.

lyc
ee

Louis-le-Grand, Paris ; mailto:laurent.cheno@inria.fr

Table des mati`

eres
1 Les
1.1
1.2
1.3
1.4
1.5
1.6
1.7

arbres 2-3
Arbres de recherche . . .
Arbres bi- ou ter- naires .

Equilibrage
. . . . . . . .
Un petit point historique
Recherche dune cle . . . .
Insertion dune cle . . . .
Suppression dune cle . . .

.
.
.
.
.
.
.

3
3
3
4
4
4
4
7

2 G
en
eralisation : les arbres a-b
2.1 Denitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Insertion et suppression dune cle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9
9
9

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

3 Implantation en Caml des arbres 2-3

3.1 Le typage des arbres . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 La recherche dune cle . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Linsertion dune cle . . . . . . . . . . . . . . . . . . . . . . . . .
3.4 La suppression dune cle . . . . . . . . . . . . . . . . . . . . . . .
3.5 Application : un algorithme de tri . . . . . . . . . . . . . . . . .
3.5.1 Quelques applications directes des algorithmes precedents
3.5.2 Le tri proprement dit . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

10
10
10
10
12
12
12
12

4 Quelques
el
ements pour une combinatoire des arbres 2-3
4.1 Fonctions generatrices associees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Pour une analyse plus ne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

15
15
16

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

Table des gures

1
2
3
4
5
6
7
8
9
10
11
12

les deux types de nuds utilises . . . . . . . . . . .

un arbre 2-3 avant insertion . . . . . . . . . . . . .
apr`es insertion de la cle 3 . . . . . . . . . . . . . .
apr`es insertion de la cle 21 . . . . . . . . . . . . . .
apr`es recomposition . . . . . . . . . . . . . . . . .
apr`es insertion de la cle 11 . . . . . . . . . . . . . .
apr`es insertion de la cle 13 . . . . . . . . . . . . . .
un cas simple de resolution dun ls unique . . . .
un autre cas simple de resolution . . . . . . . . . .
une resolution dun ls unique un peu plus dicile
une resolution qui repercute un nouveau ls unique
repartition k3 /k pour p = 4 . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

4
5
5
5
6
6
7
7
8
8
8
17

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

10
10
11
13
14
14

Table des programmes

1
2
3
4
5
6

le typage des arbres 2-3 . . . . . . . .

la recherche dune cle . . . . . . . . .
linsertion dune cle . . . . . . . . . .
la suppression dune cle . . . . . . . .
quelques applications immediates . .
le tri dune liste gr
ace aux arbres 2-3

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

Les arbres 2-3

1.1

Arbres de recherche

Considerons un ensemble de cles dun certain type . Nous supposerons quil existe une application que
nous nommerons valuation v : a
v(a) qui associe un entier naturel a` chaque cle, permettant ainsi de
munir leur ensemble dun ordre1 deni par a  b v(a)  v(b).
Nous cherchons `a denir une structure sur lensemble de ces cles qui permettent les operations de base
suivantes :
(i) linsertion dune nouvelle cl
e dans la structure ;
(ii) la recherche dune cl
e particuli`ere ;
(iii) la suppression dune cl
e presente dans la structure ;
(iv) lextraction de la cl
e de valuation minimale (resp. minimale).

Une methode habituelle consiste a` utiliser une structure darbre binaire : les feuilles de larbre contiendront
les cles de la structure, les nuds une fonction de selection qui pourra decider, la valuation dune cle
etant donnee, sil convient de descendre `a gauche ou a` droite dans larbre.
Les types Caml generiques correspondant seraient donc les suivants :
type descente = Gauche | Droite ;;
type a valuation == a -> int ;;
type a arbre_de_recherche =
| Feuille of a
| Nud of (int -> descente)
* (a arbre_de_recherche)
* (a arbre_de_recherche) ;;

La generalisation a` un arbre n-aire se ferait aisement.

En pratique, on choisit pour la fonction de selection de xer (dans le cas dun arbre binaire) une valeur
v0 telle que si la valuation dune cle lui est inferieure, on sorientera vers la gauche, et vers la droite
dans le cas contraire. Pour le cas dun nud darite n, il conviendra de choisir n 1 valeurs enti`eres qui
permettront de selectionner la branche descendante a` parcourir.
Lun des interets de ce choix est de resoudre facilement le probl`eme de lextraction de la cle de valeur
minimale (ou maximale) : il sura de descendre systematiquement `a gauche (ou a` droite) pour atteindre
a coup s
`
ur la cle recherchee.
Bien entendu, tout le probl`eme est dans la necessite deviter quon se retrouve avec des arbres dont
la profondeur soit lineaire en leur taille. On sait bien que la profondeur dun arbre est comprise entre
un logarithme de sa taille et cette taille : le probl`eme de lequilibrage consiste `a garantir quelle reste
logarithmique.

1.2

Arbres bi- ou ter- naires

Soit donc un ensemble (inni) de cles A pour lequel existe une valuation v : A N.
On leur associe lensemble B2,3 des arbres dont les feuilles portent des valeurs de lensemble A ; qui
verient la propriete tout nud est darite 2 ou 3 ; et dont les nuds darite 2 portent un entier quand
les nuds darite 3 en portent deux. De tels arbres seront appeles arbres 2-3 generaux.
` un nud darite 2 qui porte lentier r est associee la fonction de selection qui fait descendre a` gauche
A
(resp. `
a droite) toute cle x telle que v(x)  r (resp. v(x) > r).
` un nud darite 3 qui porte le couple dentiers (r, s) avec r < s est associee la fonction de selection qui
A
fait descendre a` gauche (resp. au milieu) (resp. `a droite) toute cle x telle que v(x)  r (resp. r < v(x)  s)
(resp. s < v(x)).
Nous utiliserons la representation graphique de la gure 1 page suivante pour les deux types de nuds.
Une telle structure conserve linformation dans ses feuilles, et les cles sont triees en ordre croissant dans
le parcours prexe, inxe ou suxe, de ses feuilles.
1 tout

bon ordre surait, valuation ou pas

v(x) < r

r < v(x)

v(x) < r

r<v(x)
v(x)<s

s < v(x)

Fig. 1: les deux types de nuds utilises

La cle de valeur minimale (resp. maximale) se trouvera alors naturellement en premier (resp. en dernier)
dans tout parcours prexe, inxe ou suxe des feuilles.

1.3

Equilibrage

Soit n le nombre de feuilles dun arbre dont tous les nuds sont darite 2 ou 3, et p sa profondeur,
cest-`a-dire le nombre maximal daretes quil faut traverser dans un parcours depuis la racine jusqu`
a une
des feuilles.
On dispose alors dun resultat (classiquement demontre dans le cas darbres strictement binaires) qui
enonce que
log3 n  p  n 1.
Si lon garantit que toutes les feuilles etaient de meme profondeur p, on dispose dun resultat plus fort
quon peut enoncer ainsi :
Th
eor`
eme 1
Si un arbre 2-3 general comporte n feuilles qui sont toutes `a profondeur p, alors on dispose de la relation :
2 p  n  3p ,

1.4

ou encore

lg3 n  p  lg2 n.

Un petit point historique

Dans la suite, nous ne considererons que des arbres 2-3 generaux dont toutes les feuilles sont a` la meme
profondeur, que nous appellerons simplement arbres 2-3.
Ces arbres, quon appelle parfois aussi des arbres B + , ont ete imagines ainsi que les algorithmes que
nous allons decrire ci-dessous pour la premi`ere fois en par D. Comer dans [1].

1.5

Recherche dune cl
e

La recherche dune cle dans un arbre 2-3 ne pose pas de probl`eme particulier : linformation incluse dans
chaque nud permet de choisir la branche de descente.
Dapr`es le theor`eme precedent, il est clair que la recherche dune feuille dun arbre 2-3 qui en poss`ede n
a un co
ut logarithmique c(recherche) = (lg n). Notons quil sagit dune evaluation qui vaut dans tous
les cas, et pas seulement dans le meilleur.

1.6

Insertion dune cl
e

Linsertion dune cle se fait classiquement comme toute insertion aux feuilles dans un arbre de recherche.
Considerons lexemple de larbre 2-3 de la gure 2 page suivante.
Linsertion dune nouvelle cle de valeur 3 se fait en remplacant simplement un nud binaire par un nud
ternaire, et on obtient larbre de la gure 3 page suivante.

10 16

15

18

Fig. 2: un arbre 2-3 avant insertion

7

10 16

2 4

15

18

Fig. 3: apr`es insertion de la cle 3

La diculte `a resoudre se presente evidemment quand on se retrouve avec un nud a` 4 feuilles : la cle
inseree sest installee comme lle dun nud qui avait dej`a trois feuilles.
Cest ce qui se passe (voir la gure 4) lorsque par exemple on ins`ere la cle 21 dans larbre de la gure 2.
7

10 16 ?

15

18

21

Fig. 4: apr`es insertion de la cle 21

Il sagit alors de recomposer larbre, en eclatant le nouveau nud a` 4 feuilles forme en deux nuds
binaires.
Ainsi, larbre precedent de la gure 4, qui nest pas 2-3, devient-il celui de la gure 5 page suivante.
5

7 16

18

10

15

18

21

Fig. 5: apr`es recomposition

Bien entendu, il se peut que larbre p`ere du nud 4 temporaire soit dej`a ternaire, et il faudra dans ce cas
recommencer en eclatant le p`ere en deux nuds binaires : on peut ainsi etre amene `a remonter tout en
haut de larbre, ce qui est le seul cas o`
u la profondeur totale augmente au cours de linsertion dune cle.
Par exemple, on veriera facilement que les insertions successives des cles 11 et 13 dans larbre de la
gure 5 conduisent aux arbres des gures 6 et 7 page suivante.
7 16

10 11

11

18

15

Fig. 6: apr`es insertion de la cle 11

18

21

11

16

13

10

11

18

13

15

18

21

Fig. 7: apr`es insertion de la cle 13

Finalement, on a un algorithme qui descend tout en bas de larbre avant (dans le pire des cas) de remonter
tout en haut, et le co
ut de linsertion est encore c(insertion) = (lg n).

1.7

Suppression dune cl
e

De la meme facon, pour supprimer une cle, on commence par descendre dans larbre jusqu`
a trouver la
feuille concernee.
Si son p`ere est un nud 3, il ny a pas de diculte : on remplace ce nud ternaire par un nud binaire,
et la feuille est supprimee.
Si, en revanche, on trouve un nud binaire, la suppression conduit a` un nud unaire qui ne respecte pas
les contraintes de denition dun arbre 2-3.
Il sagit donc de gerer le cas o`
u la suppression dans une branche de larbre conduit a` un nud unaire.
On consid`ere alors le p`ere.
Ou bien il sagit dun nud ternaire : par exemple, un nud de sous-arbres g, m et d, et tel que g
soit unaire. On distinguera les manipulations necessaires selon que m est binaire ou ternaire. La gure 8
explicite le premier cas, la gure 9 page suivante le deuxi`eme.
r s

r t

devient

D
A

Fig. 8: un cas simple de resolution dun ls unique

r s

t s

t u

devient
E

Fig. 9: un autre cas simple de resolution

Dans le cas o`
u le p`ere est un nud binaire, par exemple de sous-arbres g unaire et d, la gure 10 montre
comment terminer si d est ternaire. Si en revanche d est aussi binaire, on proc`ede comme le montre la
gure 11, et on doit remonter encore plus haut dans larbre.
s

r
s t

devient

Fig. 10: une resolution dun ls unique un peu plus dicile

r
s

r s

devient

qu il faut encore remonter

Fig. 11: une resolution qui repercute un nouveau ls unique

Finalement, on a un algorithme qui descend tout en bas de larbre avant (dans le pire des cas) de remonter
tout en haut, et le co
ut de linsertion est encore c(suppression) = (lg n).

G
en
eralisation : les arbres a-b

2.1

D
enitions

Soit a
2 et b
2a 1. Un arbre a-b est un arbre tel que

toutes les feuilles sont `a la meme profondeur ;
la racine est de degre compris entre 2 et b (au sens large) ;
tous les autres nuds sont de degre compris entre a et b (au sens large).
Chaque nud de degre k (avec donc a  k  b et 2  k  b pour la racine) contient un aiguillage forme
dun (k 1)-uplet dentiers, qui permet de choisir la branche o`
u descendre dans la recherche dune cle de
valuation donnee.
Bien entendu, on dispose, comme `a la section 1.3 page 4, du
Th
eor`
eme 2
Si un arbre a-b comporte n feuilles qui sont toutes `a profondeur p, alors on dispose de la relation :
2ap1  n  bp ,

2.2

ou encore

lgb n  p  1 + lga (n/2).

Insertion et suppression dune cl

e

Les algorithmes dinsertion et de suppression sont tout a` fait analogues a` ceux quon a decrit plus haut
dans le cas o`
u a = 2 et b = 3.
Pour linsertion, il conviendra declater un nud de degre b + 1 en deux nuds de degres respectifs
(b + 1)/2 et
(b + 1)/2. On constate que la condition b
2a 1 entrane
(b + 1)/2
(b + 1)/2
a,
et il est alors facile de generaliser lalgorithme dinsertion dej`a ecrit.
De la meme facon, on reecrira lalgorithme de suppression, en remontant au p`ere dun nud qui naurait
plus que a 1 ls, ce que nous laissons faire au lecteur de ces lignes. . .

3
3.1

Implantation en Caml des arbres 2-3

Le typage des arbres

Le typage correspond naturellement a` la denition quon a donnee des arbres 2-3 : pour faciliter la
lecture des structures, il nous a paru plus agreable decrire un Nud3 de branches g, m et d et de selecteur
(r,s) sous la forme Nud3(g,r,m,s,d), de sorte que chaque entier se positionne entre les branches quil
discrimine. Nous avons choisi des etiquettes enti`eres pour cet article, et la valuation est donc simplement
la fonction identite.
Programme 1 le typage des arbres 2-3

type type_des_cl
es == int ;;

let valuation x = x ;;

type arbre23 =
| Feuille of type_des_cl
es
| Nud2 of arbre23 * int * arbre23
| Nud3 of arbre23 * int * arbre23 * int * arbre23 ;;

3.2

(* par exemple *)

La recherche dune cl
e

La recherche dune cle est une simple adaptation du programme classique de recherche dans un arbre
binaire de recherche et na pas besoin de davantage de commentaires.
Programme 2 la recherche dune cle

let recherche v a x =
let vx = v x
in
let rec cherche = function
| Feuille y -> x = y
| Nud2(g,r,d) -> cherche (if vx <= r then g else d)
| Nud3(g,r,m,s,d) -> cherche (if vx <= r then g else if vx <= s then m else d)
in
cherche a ;;

3.3

Linsertion dune cl
e

Linsertion dune cle, qui fait lobjet du programme 3 page suivante, est beaucoup plus interessante.
La clef du programme est dans lutilisation dune exception : la description de lalgorithme que nous
avons propose `a la sous-section 1.6 page 4 prevoyait, dans le cas o`
u linsertion se faisait a` un niveau
o`
u se trouvaient dej`
a 3 cles, declater larbre obtenu, et de remonter dans larbre, o`
u pouvaient encore
se produire des eclatements supplementaires. La diculte est donc de remonter dans un arbre dont la
structure ne prevoit a priori que le moyen dy descendre. . . Cest l`
a quintervient dune mani`ere qui me
semble tr`es elegante lutilisation dune exception.
Notons que leclatement peut se propager jusqu`
a la racine de larbre (rappelons au passage que cest
dailleurs le seul cas o`
u larbre voit sa profondeur augmenter dune unite), et cest l`a quintervient la
structure try ... with ... de la ligne .

10

Programme 3 linsertion dune cle

exception
Eclat
e of arbre23 * int * arbre23 ;;

let insertion23 v a x =
let vx = v x
in
let rec ins`
ere a = match a with
| Feuille y when x = y -> a
| Feuille y when vx < (v y)
-> raise (
Eclat
e (Feuille x, vx, Feuille y))
| Feuille y (* when vx > (v y) *)
-> raise (
Eclat
e (Feuille y,v y,Feuille x))
| Nud2(g,r,d) when vx <= r
-> (try Nud2(ins`
ere g,r,d)
with
Eclat
e(g,r,d) -> Nud3(g,r,d,r,d))
| Nud2(g,r,d) (* when vx > r *)
-> (try Nud2(g,r,ins`
ere d)
with
Eclat
e(g,r,d) -> Nud3(g,r,g,r,d))
| Nud3(g,r,m,s,d) when vx <= r
-> (try Nud3(ins`
ere g,r,m,s,d)
with
Eclat
e(g,r,d) -> raise (
Eclat
e(Nud2(g,r,d),r,Nud2(m,s,d))))
| Nud3(g,r,m,s,d) when vx <= s (* and vx > r *)
-> (try Nud3(g,r,ins`
ere m,s,d)
with
Eclat
e(g,r,d) -> raise (
Eclat
e(Nud2(g,r,g),r,Nud2(d,s,d))))
| Nud3(g,r,m,s,d) (* when vx > s *)
-> (try Nud3(g,r,m,s,ins`
ere d)
with
Eclat
e(g,s,d) -> raise (
Eclat
e(Nud2(g,r,m),s,Nud2(g,s,d))))
in
match a with
(* les cas particuliers du d
epart *)
| Feuille y
-> if x = y then a
else if vx < (v y) then Nud2( Feuille x,vx, Feuille y)
else Nud2( Feuille y,v y, Feuille x)
| _ -> try ins`
ere a with
Eclat
e(g,r,d) -> Nud2(g,r,d) ;;

11

3.4

La suppression dune cl
e

On ecrit lalgorithme de suppression dune facon similaire : pour remonter dans la structure, on denit
une exception, qui sappelle cette fois FilsUnique, et qui est declenchee quand la suppression normale
dune cle produit un nud unaire, quil est alors necessaire de remonter.
On obtient le programme 4 page suivante.
On notera lutilisation de cas de ltrage du genre Feuille _ -> raise Unexpected qui nont dautre
fonction que satisfaire le parseur de Caml, et eviter des messages davertissement de ltrages non exhaustifs. Cest toujours de bonne politique que deviter ce genre de messages, et cela garantit une programmation plus s
ure.

3.5
3.5.1

Application : un algorithme de tri

Quelques applications directes des algorithmes pr
ec
edents

On ecrit tr`es facilement la recherche de la cle de valuation minimale (resp. maximale) dun arbre 2-3 : il
sut de descendre syst`ematiquement `a droite (resp. `a gauche) dans la structure.
De meme, `a laide de la fonction dinsertion, peut-on ecrire une fonction qui transforme une liste en
arbre 2-3.
Ces fonctions font lobjet du programme 5 page 14.
3.5.2

Le tri proprement dit

Le tri nest alors quune suite dextractions des maximas successifs de larbre 2-3 construit a` partir de la
liste argument, ce que realise facilement le programme 6 page 14.

12

Programme 4 la suppression dune cle

exception Unexpected ;; (* bug du programme *)

exception FilsUnique of arbre23 ;;
let suppression23 v a x =
let vx = v x
in
let rec supprime a = match a with
| Feuille y when x = y -> raise Unexpected
| Feuille _ -> a
| Nud2(Feuille y,_,d) when vx = (v y) -> raise (FilsUnique d)
| Nud2(g,_,Feuille y) when vx = (v y) -> raise (FilsUnique g)
| Nud3(Feuille y,_,m,s,d) when vx = (v y) -> Nud2(m,s,d)
| Nud3(g,_,Feuille y,s,d) when vx = (v y) -> Nud2(g,s,d)
| Nud3(g,s,m,_,Feuille y) when vx = (v y) -> Nud2(g,s,m)
| Nud2(g,r,d) when vx <= r
-> ( try
Nud2(supprime g,r,d)
with FilsUnique g
-> match d with
| Nud3(gd,rd,md,sd,dd) -> Nud2(Nud2(g,r,gd),rd,Nud2(md,sd,dd))
| Nud2(gd,rd,dd) -> raise (FilsUnique (Nud3(g,r,gd,rd,dd)))
| Feuille _ -> raise Unexpected (* pour que le filtrage soit exhaustif *)
| Nud2(g,r,d) (* when vx > r *)
-> ( try
Nud2(g,r,supprime d)
with FilsUnique d
-> match g with
| Nud3(gg,rg,mg,sg,dg) -> Nud2(Nud2(gg,rg,mg),sg,Nud2(dg,r,d))
| Nud2(gg,rg,dg) -> raise (FilsUnique (Nud3(gg,rg,dg,r,d)))
| Feuille _ -> raise Unexpected (* pour que le filtrage soit exhaustif *)
| Nud3(g,r,m,s,d) when vx <= r
-> ( try
Nud3(supprime g,r,m,s,d)
with FilsUnique g
-> match m with
| Nud3(gm,rm,mm,sm,dm) -> Nud3(Nud2(g,r,gm),rm,Nud2(mm,sm,dm),s,d)
| Nud2(gm,rm,dm) -> Nud2(Nud3(g,r,gm,rm,dm),s,d)
| Feuille _ -> raise Unexpected (* pour que le filtrage soit exhaustif *)
| Nud3(g,r,m,s,d) when vx <= s
-> ( try
Nud3(g,r,supprime m,s,d)
with FilsUnique m
-> match g with
| Nud3(gg,rg,mg,sg,dg) -> Nud3(Nud2(gg,rg,mg),sg,Nud2(dg,r,m),s,d)
| Nud2(gg,rg,dg) -> Nud2(Nud3(gg,rg,dg,r,m),s,d)
| Feuille _ -> raise Unexpected (* pour que le filtrage soit exhaustif *)
| Nud3(g,r,m,s,d) (* when vx > s *)
-> ( try
Nud3(g,r,m,s,supprime d)
with FilsUnique d
-> match m with
| Nud3(gm,rm,mm,sm,dm) -> Nud3(g,r,Nud2(gm,rm,mm),sm,Nud2(dm,s,d))
| Nud2(gm,rm,dm) -> Nud2(g,r,Nud3(gm,rm,dm,s,d))
| Feuille _ -> raise Unexpected (* pour que le filtrage soit exhaustif *)
in
match a with
| Feuille y when vx = (v y) -> failwith "je ne veux pas darbre 2-3 vide"
| Feuille _ -> a
| _ -> try supprime a with FilsUnique u -> u ;;

13

Programme 5 quelques applications immediates

let rec min23 = function

| Feuille x -> x
| Nud2(g,_,_) -> min23 g
| Nud3(g,_,_,_,_) -> min23 g
and max23 = function
| Feuille x -> x
| Nud2(_,_,d) -> max23 d
| Nud3(_,_,_,_,d) -> max23 d ;;

let rec arbre23_of_list v = function

| [] -> failwith "un arbre 2-3 ne peut ^
etre vide"
| [ t ] -> Feuille t
| t :: q -> insertion23 v (arbre23_of_list v q) t ;;

Programme 6 le tri dune liste gr

ace aux arbres 2-3

let tri23 v l =
let a = arbre23_of_list v l
in
let rec recompose tampon = function
| Feuille x -> x :: tampon
| a -> let x = max23 a in recompose (x :: tampon) (suppression23 v a x)
in
recompose [] a ;;

14

Quelques
el
ements pour une combinatoire des arbres 2-3

4.1

Fonctions g
en
eratrices associ
ees

Nous noterons, pour une profondeur p Net n N, Bp,n le nombre darbres 2-3 de profondeur p qui
1, si n = 1 ;
poss`edent n feuilles. Par exemple : B0,n =
0, sinon.
Les fonctions generatrices associees sont les series formelles, elements de N[[z]], denies par :
Bp (z) =

+


Bp,n z n .

n=0

On a donc en particulier B0 (z) = z.

Soit maintenant p
1. La racine dun arbre 2-3 de taille n et de profondeur p poss`ede deux ou trois ls
qui sont chacun des arbres 2-3 de profondeurs p 1 et dont la somme des tailles vaut n.
On peut donc ecrire :


p
1, n, Bp,n =
Bp1,n1 Bp1,n2 +
Bp1,n1 Bp1,n2 Bp1,n3 .
n1 +n2 =n

n1 +n2 +n3 =n

La traduction en termes de fonctions generatrices est directe, et on obtient :


z,
si p = 0 ;
Bp (z) =
Bp1 (z)2 + Bp1 (z)3 , si p
1.
Dans [3][page 292], Flajolet et Sedgewick proposent la recurrence fonctionnelle suivante :

z,
si p = 0 ;
Bp (z) =
Bp1 (z 2 + z 3 ), si p
1.
Le point de vue utilise est totalement dierent : cette fois, on passe dune profondeur p1 `a une profondeur
p en remplacant chaque feuille par, au choix, un arbre de profondeur 1 qui est soit binaire soit ternaire,
ce qui correspond a` la substitution z z 2 + z 3 .
Remarquons quune demonstration directe de lequivalence des deux recurrences fonctionnelles ecrites
naurait vraiment rien devident2 .
On obtient les valeurs suivantes, pour 0  n  20 :
p
n

0
1
1

B0,n
B1,n
B2,n
B3,n
B4,n

B
p p,n

1
2

2
4

2 ou 3
8 9

3
10

11

12

13

14

15

3
1

1
4

14

23

32

43

63

14

23

32

43

63

En sommant a` profondeur xee, on obtient :

p
B
=
B
(1)
p
n p,n

2 mais

0
1

1
2

2
12

3
1872


n

3 ou 4
16 17

18

19

20

96
1
97

192
32
224

240
92
332

267
222
489

141
8
149

Bp,n = Bp (1) do`

u le tableau de valeurs suivant :

4
6563711232

minteresserait quand meme beaucoup !

15

5
282779810171805015122254036992

Si lon sinteresse au nombre moyen de feuilles dun arbre 2-3 de profondeur p, il sut devaluer la quantite
n
= Bp (1)/Bp (1), et Maple nous aide a` trouver les valeurs suivantes :
p
n

0
1

1
2,5

2
6,667

3
19,487

4
58,451

5
175,353

6
526,060

Il nest pas beaucoup plus dicile devaluer la variance de ce nombre de feuilles, puisque la moyenne du
carre de n secrit (Bp (1) + Bp (1))/Bp (1), et l`
a encore Maple nous fournit les resultats demandes :
p
V
(n)

V (n)

4.2

0
0
0

1
0,25
0,5

2
2,056
1,434

3
9,164
3,027

4
27,691
5,262

5
83,073
9,114

6
249,218
15,787

Pour une analyse plus ne

Pour raner notre analyse de la combinatoire des arbres 2-3, nous pouvons nous interesser au nombre k
(k)
de nuds (binaires ou ternaires) dun arbre 2-3 de profondeur p et de taille n, que nous noterons Bp,n .
Pour un arbre binaire, on sait que le nombre de feuilles est egal au nombre de nuds plus un.
Dans le cas de nos arbres 2-3, nous disposons de lencadrement analogue : k + 1  n  2k + 1. En outre,
p
k et p verient la relation : 2p 1  k  3 21 ce qui donne encore : 2p  n  3p comme on pouvait sy
attendre.
Pour montrer que linformation decrite par le triplet (n, p, k) est plus riche que prevue, montrons le
Th
eor`
eme 3
Soient k2 (resp. k3 ) le nombre de nuds binaires (resp. ternaires) dun arbre 2-3 possedant k nuds et n
feuilles. Alors : k2 = 2k n + 1 et k3 = n k 1.
Observons tout dabord que lon dispose bien s
ur de k2 + k3 = k.
Une deuxi`eme equation sobtient facilement, en considerant que tout nud/feuille sauf la racine a un
p`ere et quon a donc : 2k2 + 3k3 = k + n 1.
Il sut alors de resoudre le syst`eme de nos deux equations.

(k) n k
Introduisons la fonction generatrice `a deux variables Bp (z, u) =
Bp,n
z u .
n

Bien s
ur, on aura Bp (z) = Bp (z, 1) et B0 (z, u) = z.
(k)
Essayons detablir des recurrences sur ces entiers Bp,n .
Partant de la racine, on construit un arbre de profondeur p
1 depuis une racine binaire ou ternaire, ce
qui fournit :


(k1 )
(k2 )
(k1 )
(k2 )
(k3 )
(k)
p
1, k
1, Bp,n
=
Bp1,n
B
+
Bp1,n
Bp1,n
Bp1,n
.
p1,n
1
2
1
2
3
n1 +n2 =n
k1 +k2 =k1

n1 +n2 +n3 =n
k1 +k2 +k3 =k1

Traduisant ceci en termes de fonctions generatrices, on obtient :


z,
si p = 0 ;
Bp (z, u) =
u(Bp1 (z, u)2 + Bp1 (z, u)3 ), si p
1.
Transformant les n feuilles dun arbre de profondeur p 1 contenant k nuds en arbres de profondeur
1, on passe `a un arbre de profondeur p, possedant k + n nuds et entre 2n et 3n feuilles. Chaque feuille
donne donc naissance soit a` un nud et deux feuilles, soit a` un nud et trois feuilles, ce qui se traduit
par la substitution z u(z 2 + z 3 ), et on obtient une nouvelle recurrence fonctionnelle :

z,
si p = 0 ;
Bp (z, u) =
Bp1 (u(z 2 + z 3 ), u), si p
1.
16

Cest cette deuxi`eme recurrence que nous avons utilisee pour ecrire en Caml le calcul de la fonction
generatrice. On trouvera le listing correspondant dans le dossier complet lie `a cet article, mais nous ne le
reproduisons pas ici.
La gure 12 (qui est une copie decran, bien entendu) presente la repartition des nuds binaires/ternaires
pour les arbres 2-3 de profondeur p = 4 : on lit en abscisses le rapport k3 /k [0, 1] (graduation tous les
dixi`emes), et en ordonnees les frequences relatives (normalisees par la frequence maximale). On aurait
aime presenter des statistiques pour des profondeurs plus importantes, mais Caml declenche trop vite
lexception Out of memory. . .

Fig. 12: repartition k3 /k pour p = 4

17

R
ef
erences
[1] D. Comer. The ubiquitous b-tree. Computing Surveys, 11 :121137, 1979.
ements dalgorithmique. Masson, Paris,
[2] Dani`ele Beauquier, Jean Berstel et Philippe Chretienne. El
1992.
[3] Philippe Flajolet and Robert Sedgewick. An Introduction to the Analysis of Algorithms. AddisonWesley, Reading, Massachussets, 1996.
[4] Ronald L. Graham, Donald E. Knuth, and Oren Patashnik. Concrete Mathematics : A Foundation
for Computer Science. Addison-Wesley, Reading, Massachussets, 2nd edition, 1994.
[5] Derick Wood. Data structures, algorithms, and performance. Addison-Wesley, Reading, Massachussets, 1993.

18