notes de cours - usherbrooke.ca · université de sherbrooke chapitre 9 : les arbres binaires de...

Université de Sherbrooke Chapitre 9 : Les arbres binaires de recherche : interface et implantation Département de génie électrique et de génie informatique

GEI 442 : Structures de données et algorithmes Ahmed KHOUMSI 1Hiver 2000

Notes de cours

GEI 442 : STRUCTURES DE DONNÉES ET ALGORITHMESSTRUCTURES DE DONNÉES ET ALGORITHMES

Chapitre 9

Les arbres binaires de recherche : interface et implantation

Ahmed KHOUMSI



ArbresArbres

Un arbre = ensemble de nœuds + ensemble de liens orientés reliant paires de nœuds

Un lien l reliant un nœud p à un nœud q est représenté graphiquement par :

Nous dirons que : - l est : - un lien sortant du nœud p - un lien entrant du nœud q - p est parent de q - q est enfant de p

Chaque nœud, sauf la racine, contient un seul lien entrant venant de son unique nœud parent

Pour chaque nœud, il y a un seul chemin reliant la racine à ce nœud

Le nombre de liens constituant un chemin est appelé longueur du chemin

Un nœud sans enfant est une feuille

p

q



Arbres binairesArbres binaires

Chaque nœud peut avoir au plus deux enfants nommés : - enfant gauche - enfant droit

Un nœud p et ses enfants droit et gauche d et g sont représentés graphiquement par :

Exemple d ’application : expressions avec opérateurs binaires (càd à 2 opérandes) :

- Opérandes sont des feuilles

- Opérateurs sont des nœuds

Une feuille est évaluée elle-même

Un nœud est évalué récursivement en appliquant son opérateur aux nœuds enfants

p

g d



Arbres binaires : exemple d ’applicationArbres binaires : exemple d ’application

Codage de Huffman : pour la compression de données

Code = succession de 0 et 1

Lettres codées sont des feuilles de l ’arbre binaire

Code de chaque lettre spécifie le chemin de la racine à la feuille

Un « 0 » est représenté par un lien gauche

Un « 1 » est représenté par un lien droit

Exemple : Lettres a, b, c, d codées par : a( 0 ) b( 100 ) c( 101 ) d( 11 )

Ce codage est représenté dans l ’arbre binaire :a

d

b c

0 1

1

1

0

0



Arbres binaires de recherche (ABR)Arbres binaires de recherche (ABR)

Type d ’arbres binaires particulièrement adaptés pour effectuer les trois types d ’opérations suivantes : - insertion - suppression - recherche

Contient uniquement objets implantant l ’interface Comparable

Ordonnancement des éléments : pour tout nœud p dont les enfants gauche et droit sont g et d, on doit avoir : g < p < d

Les duplicata sont interdits



Interface d ’un ABRInterface d ’un ABR ([1], Fig. 6.18)

public interface SearchTree{ void insert( Comparable x ) throws DuplicateItem;

void remove( Comparable x ) throws ItemNotFound;

void removeMin( ) throws ItemNotFound;

Comparable find( Comparable x ) throws ItemNotFound;

Comparable findMin( ) throws ItemNotFound;

Comparable findMax( ) throws ItemNotFound;

void makeEmpty( );

boolean isEmpty( );

void printTree( );}



Interface d ’un ABRInterface d ’un ABR (suite)

insert( x ) : insertion de x jette exception si x trouvé (car duplicata interdits)

remove( x ) : recherche et suppression de x jette exception si x non trouvé

removeMin( ) : recherche et suppression du plus petit élément de l ’ABR jette exception si ABR vide

find( x ) : recherche et retourne x jette exception si x non trouvé

findMin( ) : recherche et retourne le plus petit élément de l ’ABR jette exception si ABR vide

findMax( ) : recherche et retourne le plus grand élément de l ’ABR jette exception si ABR vide

isEmptymakeEmpty

printTree : imprime ABR

comme pour les autres SDs



Exemple d ’objet implantant ComparableExemple d ’objet implantant Comparable

import Supporting.*;import Supporting.Comparable;

public final class CompString implements Comparable{ public CompString( String x ) { value = x; }

public String toString( ) { return value; }

public int compares( Comparable rhs ) { return value.compareTo( ((CompString) rhs).value ); }

public boolean lessThan( Comparable rhs ) {

return compares( rhs ) < 0; }

public boolean equals( Object rhs ) { return value.equals( ((CompString) rhs).value ); }

private String value;}



Exemple d ’utilisation d ’ABRExemple d ’utilisation d ’ABR

import DataStructures.*;import Exceptions.*;

public final class TestSearchTree {

public static void main( String [ ] args ) {

SearchTree t = new BinarySearchTree( ); CompString result = null;

try { t.insert( new CompString( "Becky" ) ); } catch( DuplicateItem e ) { } // Impossible

try { result = (CompString) t.find( new CompString( "Becky" ) ); System.out.print( "Found " + result + ";" ); } catch( ItemNotFound e ) { System.out.print( "Becky not found;" ); }

try { result = (CompString) t.find( new CompString( "Mark" ) ); System.out.print( " Found " + result + ";" ); } catch( ItemNotFound e ) { System.out.print( " Mark not found;" ); }

System.out.println( ); }}



Utilisation d ’un ABR Utilisation d ’un ABR (suite)

Création d ’un ABR

Insertion d ’un objet Becky de type CompString (page 8)

Recherche de Becky (trouvé)

Recherche de Mark (non trouvé)



Performances Performances

Les performances des opérations d ’insertion, recherche et suppression sont :

- Avec des réalisations simples : - O( logN ) dans le moyen cas - O( N ) dans le pire cas

- Avec des réalisations plus complexes : O(logN) dans les pire et moyen cas



Opérations de recherche Opérations de recherche Find : (1) on commence à la racine (2) si valeur du nœud courant = valeur recherchée alors on a trouvé (3) si valeur du nœud courant < valeur recherchée alors : - si enfant droit existe alors : - on se branche sur enfant droit - on va à (2)

- sinon on n ’a pas trouvé (4) si valeur du nœud courant > valeur recherchée alors : - si enfant gauche existe alors : - on se branche sur enfant gauche - on va à (2)

- sinon on n ’a pas trouvé

FindMin : (1) on commence à la racine (2) tant que nœud courant a un enfant gauche, on se branche sur

enfant gauche (3) on retourne le nœud courant (sans enfant gauche)

FindMax : Comme FindMin, en remplaçant gauche par droit



Opération d ’insertion Opération d ’insertion Soit v la valeur à insérerOn recherche vSi v est trouvée alors : erreur (car duplicata interdits)Sinon : - cela signifie qu ’on est arrivé à un nœud K qui a au plus un enfant et dont la valeur est v - on ajoute v comme enfant gauche ou droit de K selon que

v < K ou v > K

Exemple : ([1], Fig. 18.2) : on veut insérer 6 dans l ’ABR suivant :

- Une recherche de 6 nous fait parcourir les nœuds 7, 2, 5 - 6 n ’est pas trouvé car : 5 < 6 et 5 n ’a pas d ’enfant droit - 6 est inséré comme enfant droit de 5 et on obtient :

≠

2

5

7

9

3

1

2

5

7

9

3

1

6



Opérations de suppressionOpérations de suppression

Opération la plus compliquée car la suppression « brute » peut déconnecter l ’ABR

Il faut donc : - reconnecter l ’ABR - préserver la propriété enfant gauche < parent < enfant droit

Trois cas selon que nœud à supprimer : est une feuille, a un enfant ou a deux enfants

(1) Nœud à supprimer est une feuille : La feuille supprimée et aucun traitement supplémentaire n ’est nécessaire

(2) Nœud à supprimer a un enfant : - Soit N le nœud à supprimer, P son parent, X son enfant - Le traitement consiste à rendre P parent direct de X

Exemple : Après suppression de 5 de , on obtient

2

5

7

9

3

1

2

7

9

3

1



Opérations de suppressionOpérations de suppression (suite)

Suppression du minimum : removeMin

- recherche du minimum, à l ’aide de findMin

- suppression du minimum : on est dans le cas 1 ou 2 (voir page 14) car le minimum a au plus un enfant qui, s ’il existe, est droit

Suppression du maximum : removeMax

- recherche du maximum, à l ’aide de findMax

- suppression du maximum : on est dans le cas 1 ou 2 (voir page 14) car le maximum a au plus un enfant qui, s ’il existe, est gauche



Opérations de suppressionOpérations de suppression (suite)

(2) Nœud à supprimer a deux enfants : Soit alors : - N le nœud à supprimer - ��le sous-arbre droit de N - X le plus petit nœud de �

- On recherche X, en appliquant findMin à �

- On remplace la valeur de N par celle de X

- On supprime X à l ’aide de (au choix) : - remove(X) appliqué à la racine - removeMin, appliqué à � Remarque : Pour la suppression de X, on se retrouve dans le cas 1 ou 2

Exemple : Après suppression de 2 de , on obtient

2

5

7

9

3

1

4

3

5

7

91

4



Implantation du nœud d ’un ABRImplantation du nœud d ’un ABR ([1], Fig. 18.5)

Trois champs : - element = valeur du nœud - left et right = références sur enfants gauche et droitConstructeurs : - 1er : initialise : - element par argument, et left et right à null

- 2nd : initialise les 3 champs par argumentsChamps ��, color, level présentés ultérieurement

package DataStructures;

import Supporting.*;import Supporting.Comparable;

class BinaryNode {

// Constructors BinaryNode( Comparable theElement ) { this( theElement, null, null ); }

BinaryNode( Comparable theElement, BinaryNode lt, BinaryNode rt ) { element = theElement; left = lt; right = rt; }

// Friendly data; accessible by other package routines Comparable element; BinaryNode left; BinaryNode right;

// Balancing information; only one is used at a time int size = 1; // For BinarySearchTreeWithRank int color = 1; // For red-black tree int level = 1; // For AA-tree}



Implantation d ’ABRImplantation d ’ABR ([1], Fig. 18.6 et 18.7)

Champ root : racine de l ’ABR

Implante interface SearchTree (voir page 6)package DataStructures;

import Supporting.*;import Exceptions.*;import Supporting.Comparable;

public class BinarySearchTree implements SearchTree {

public BinarySearchTree ( ) { root = null; }

public Comparable find ( Comparable x ) throws ItemNotFound {

return find( x, root ).element; }

public Comparable findMin ( ) throws ItemNotFound { return findMin( root ).element; }

public Comparable findMax ( ) throws ItemNotFound { return findMax( root ).element; }

public void insert ( Comparable x ) throws DuplicateItem {

root = insert( x, root ); }

public void remove ( Comparable x ) throws ItemNotFound {

root = remove( x, root ); }

public void removeMin ( ) throws ItemNotFound { root = removeMin( root ); }

public void printTree ( ) { if( root == null )

System.out.println( "Empty tree" ); else printTree( root );

public boolean isEmpty ( ) { return root == null; }

public void makeEmpty ( ) { root = null; }

protected BinaryNode find ( Comparable x, BinaryNode t ) throws ItemNotFound

{ /* Voir page 20 */ }

protected BinaryNode findMin ( BinaryNode t ) throws ItemNotFound

{ /* voir page 21 */ }

protected BinaryNode findMax ( BinaryNode t ) throws ItemNotFound

{ /* voir page 21 */ }

protected BinaryNode insert ( Comparable x, BinaryNode t ) throws DuplicateItem { /* voir page 22 */ }

protected BinaryNode remove ( Comparable x, BinaryNode t ) throws ItemNotFound

{ /* voir page 24 */ }

protected BinaryNode removeMin ( ) throws ItemNotFound

{ /* voir page 23 */ }

protected void printTree ( ) { /* implantation non présentée */

protected BinaryNode root;}



Implantation d ’ABR : Implantation d ’ABR : méthodes public et méthodes public et protectedprotected

Opérations : find, findMin, findMax, insert, remove, removeMin, printTree

Pour chacune des sept opérations ci-dessus, on a défini : - une méthode public - une méthode protected

Chaque méthode protected s ’applique à un ABR dont la racine est spécifiée en argument (BinaryNode t)

Chaque méthode public : - s ’applique à l ’ABR dont la racine est spécifiée par root - fait appel à sa méthode protected « jumelle »

Tout le travail est fait par les méthodes protected, celles-ci sont simples grâce à la récursivité

Les méthodes sont protected (au lieu de private) car on utilisera ultérieurement une classe qui : - dérive de BinarySearchTree

- utilise ces méthodes



Implantation de Implantation de find find ([1], Fig. 18.8)

protected BinaryNode find( Comparable x, BinaryNode t )throws ItemNotFound

{ while( t != null ) if( x.compares( t.element ) < 0 ) t = t.left; else if( x.compares( t.element ) > 0 ) t = t.right; else return t; // Match

throw new ItemNotFound( "SearchTree find" ); }



Implantation de Implantation de findMin findMin et et findMax findMax ([1], Fig. 18.9)

findMin

findMax

protected BinaryNode findMin( BinaryNode t ) throws ItemNotFound{ if( t == null ) throw new ItemNotFound( "SearchTree findMin" );

while( t.left != null ) t = t.left; return t; }

protected BinaryNode findMax( BinaryNode t ) throws ItemNotFound { i f( t == null ) throw new ItemNotFound( "SearchTree findMax" );

while( t.right != null ) t = t.right; return t; }



Implantation de insert Implantation de insert ([1], Fig. 18.10)

protected BinaryNode insert( Comparable x, BinaryNode t )throws DuplicateItem

{ if( t == null )

t = new BinaryNode( x, null, null ); else if( x.compares( t.element ) < 0 ) t.left = insert( x, t.left ); else if( x.compares( t.element ) > 0 ) t.right = insert( x, t.right ); else throw new DuplicateItem( "SearchTree insert" ); return t; }



Implantation de Implantation de removeMin removeMin ([1], Fig. 18.11)

protected BinaryNode removeMin( BinaryNode t ) throws ItemNotFound { if( t == null ) throw new ItemNotFound( "SearchTree removeMin" ); if( t.left != null ) t.left = removeMin( t.left ); else t = t.right; return t; }



Implantation de Implantation de remove remove ([1], Fig. 18.12)

protected BinaryNode remove( Comparable x, BinaryNode t )throws ItemNotFound

{ if( t == null ) throw new ItemNotFound( "SearchTree remove" ); if( x.compares( t.element ) < 0 ) t.left = remove( x, t.left ); else if( x.compares( t.element ) > 0 ) t.right = remove( x, t.right ); else if( t.left != null && t.right != null ) // Two children { t.element = findMin( t.right ).element; t.right = removeMin( t.right ); } else t = ( t.left != null ) ? t.left : t.right; return t; }



Recherche du Recherche du KKièmeième élémentélément

Taille d ’un nœud N = nombre de ses descendants +1 = nombre de nœuds de l ’ABR de racine N

Si on connaît la taille de chaque nœud d ’un ABR, on peut rechercher le Kième

élément d ’un ABR

Le champ size de BinaryNode (voir page 17) est utilisé pour stocker les taillesdes nœuds

On peut alors définir une classe BinarySearchTreeWithRank qui : - dérive de BinarySearchTree (voir page 18) - gère le champ size

Cette classe va alors : - contenir : - une méthode findKth qui est public

- une méthode findKth qui est protected - redéfinir les méthodes protected : insert, removeMin, remove afin de gérer le champ size



Principe de la recherche du Principe de la recherche du KKièmeième élémentélément

Méthode récursive

Soit : - un nœud X - L et R les sous-arbres gauche et droit de X - SL et SR les tailles des sous-arbres gauche et droit de X

Recherche du Kième élément de l ’ABR de racine X :

- Si K < SL + 1 alors : - élément recherché = Kième élément de L

- Si K > SL + 1 alors : élément recherché = (K - SL - 1) ième élément de R

- Si K = SL + 1 alors X est l ’élément recherché

SLSR

K < SL + 1

X

SLSR

K = SL + 1

X

SLSR

K > SL + 1

X



Implantation de Implantation de findKth findKth ([1], Fig. 18.14 et 18.15)

Les méthodes redéfinies dans la classe BinarySearchTreeWithRank sont présentées dans [1], Fig. 18.16, 18.17 et 18.18.

La gestion de size par ces méthodes est simple

public Comparable findKth( int k ) throws ItemNotFound { return findKth( k, root ).element; }

protected BinaryNode findKth( int k, BinaryNode t ) throws ItemNotFound { if( t == null ) throw new ItemNotFound( "BSTWithRank findKth" ); int leftSize = ( t.left != null ) ? t.left.size : 0;

if( k <= leftSize ) return findKth( k, t.left ); if( k == leftSize + 1 ) return t; return findKth( k - leftSize - 1, t.right ); }



ABR complètement équilibréABR complètement équilibréLa profondeur d ’un nœud X est la longueur du chemin reliant la racine à X

Dans ABR complètement équilibré, un nœud d ’une profondeur p est parent seulement si tous les nœuds de profondeur p-1 ont leur deux enfants

La longueur du plus long chemin d ’un ABR est appelée hauteur de l ’ABR

La hauteur h d ’un ABR complètement équilibré de N nœuds =Exemples :

À l ’autre extrême, un ABR est dit complètement déséquilibré si chaque nœud a au plus un enfantUn ABR complètement déséquilibré ressemble à une liste chaînéeLa hauteur d ’un ABR complètement déséquilibré de N nœuds = N

2

5

7

9

3

12

5

7

3

111

139

ABR équilibré : N = 8, h = 3 ABR non équilibré : N = 6, h = 3

Nlog



Analyse des opérations d ’ABRAnalyse des opérations d ’ABR

Le coût de chaque opération (recherche, insertion, suppression) est proportionnel au nombre de nœuds accédés durant l ’opération

Les nœuds accédés durant une opération sont sur un même chemin allant de la racine vers une feuille

Dans le pire cas, le coût de chaque opération est donc proportionnel à la longueur du plus long chemin

On a : - Meilleur cas si ABR complètement équilibré : coût = O( logN )

- Pire cas si ABR complètement déséquilibré : coût = O( N )

- Moyen cas : coût est 38% pire que le meilleur cas, donc O( logN )

Le pire cas se produit si (mais pas seulement si) l ’entrée est triée, c.-à-d. l ’ABR est construit par une séquence de insert de données préalablement triées

Pour éviter le pire cas ( ou des cas proches du pire cas), on a défini des structures d ’ABRs garantissant un équilibre « suffisant »Nous allons étudier trois types d ’ABR suffisamment équilibrésDans la suite, la hauteur d ’un ABR vide est -1



Les AVLLes AVL

Un AVL = un ABR avec la condition d ’équilibre suivante :

Pour chaque nœud N, les hauteurs des sous-arbres gauche et droit de N diffèrent d ’au plus 1

Exemples :

8

10

12

16

144

62

AVL

8

10

12

16

144

62

Après insertion de 1 dans l ’AVL précédent,l ’ABR obtenu n ’est plus un AVL car lacondition ci-dessus n ’est plus respectéepour les nœuds 8 et 12

1



Hauteur et déséquilibre d ’un AVLHauteur et déséquilibre d ’un AVL

Hauteur : Le pire cas donne une hauteur d ’environ 44% supérieure au meilleur cas Donc, dans le pire cas Hauteur 1.44 logN

Déséquilibre : - si on supprime ou insère un élément dans un AVL avec la méthode générale (voir page 13-16), celui-ci peut perdre sa structure d ’AVL; dans ce cas : - nous dirons que l ’AVL a été déséquilibré. - les nœuds « fautifs » de l ’AVL déséquilibré sont eux-aussi dits déséquilibrés

Il faut donc utiliser des méthodes d ’insertion et suppression plus complexes qui garantissent la structure d ’AVL

Méthode d ’insertion (nous n ’étudierons pas la suppression) Après insertion d ’un nœud (par la méthode générale), les seuls nœuds qui peuvent être déséquilibrés sont ceux situés sur le chemin reliant la racine au nœud ajouté

≅

≅



Équilibrage d ’un AVLÉquilibrage d ’un AVL

On considère un AVL qui a été déséquilibré après insertion

Rappelons que les seuls nœuds déséquilibrés sont sur un même cheminqui part de la racine au point d ’insertion (voir page précédente)

Soit alors X le nœud déséquilibré le plus profond (càd le plus loin de la racine)Le ré-équilibrage de X va impliquer le ré-équilibrage de tout l ’arbre

Pour le ré-équilibrage de X, nous pouvons avoir les quatre cas suivants :

1. Insertion faite dans le sous-arbre gauche de l ’enfant gauche de X

2. Insertion faite dans le sous-arbre droit de l ’enfant gauche de X

3. Insertion faite dans le sous-arbre gauche de l ’enfant droit de X

4. Insertion faite dans le sous-arbre droit de l ’enfant droit de X

Les cas 1 et 4 sont symétriques, et de même les cas 2 et 3 sont symétriques

Il y a donc en théorie deux cas : - Cas e (1, 4) : insertion vers l ’extérieur (gauche et droit) - Cas i (2, 3) : insertion vers l ’intérieur (gauche et droit)



Insertion vers l ’extérieur : rotation simpleInsertion vers l ’extérieur : rotation simpleCas e gauche (cas 1) : ci-dessous, le sous-arbre A contient élément inséré

k1

k2

BC

A

k1

k2

B CA

Avant rotation : nœud k2 déséquilibré Après rotation simple de l ’arbre de racine k2 Note : le parent de k2 avant rotation devient parent de k1 après rotation

Cas e droit (cas 4) : ci-dessous, le sous-arbre A contient élément insérék2 k1

BA

k2k1

BA

C

Avant rotation : nœud k1 déséquilibré Après rotation simple de l ’arbre de racine k1 Note : le parent de k1 avant rotation devient parent de k2 après rotation

C



Implantation rotation simpleImplantation rotation simple ([1], Fig. 18.24 et 18.27)

Cas e gauche (cas 1) :

Cas e droit (cas 4) :

static BinaryNode withLeftChild( BinaryNode k2 ) { BinaryNode k1 = k2.left; k2.left = k1.right; k1.right = k2; return k1; }

static BinaryNode withRightChild( BinaryNode k1 ){ BinaryNode k2 = k1.right; k1.right = k2.left; k2.left = k1; return k2; }



Exemple d ’insertion avec rotation simpleExemple d ’insertion avec rotation simple

AVL avant insertion AVL après insertion de 1 et avant rotation simple: les nœud 8 et 12 sont déséquilibrés

AVL après rotation simple (cas e gauche : k1 = 4, k2 = 8)

8

10

12

16

144

62

8

10

12

16

144

621

4

12

16

142 8

1106



Insertion vers l ’intérieur : rotation doubleInsertion vers l ’intérieur : rotation double

Rotation simple ne suffit pas

Par exemple, cas i gauche (cas 2) : le sous-arbre Q contient le nœud inséré

k1

k2

PR

Q

k2

PR

Q

Avant rotation : nœud k2 déséquilibré

k1

Après rotation : nœud k1 déséquilibré

Solution : rotation double = deux rotations simples



Après 1ère rotation simple du sous-arbre de racine k1 Nœud k3 reste déséquilibréNœud k2 possiblement déséquilibré

Rotation double : Rotation double : cas i gauche (cas 2)

k1

k3

AD

Ci-dessous, l ’élément inséré est dans B ou C

k2

B C

Avant rotation : Nœud k3 déséquilibré

k2

k3

A

Dk1

BC

k1

k2

A D

k3

CB

Après 2ème rotation simple du sous-arbre de racine k3

Implantation ([1], Fig. 18.32)

static BinaryNode doubleWithLeftChild( BinaryNode k3 ) { k3.left = withRightChild( k3.left ); return withLeftChild( k3 ); }



Rotation double : Rotation double : cas i droit (cas 3)

Ci-dessous, l ’élément inséré est dans B ou C

Après 1ère rotation simple du sous-arbre de racine k3 Nœud k1 reste déséquilibréNœud k2 possiblement déséquilibré

k3

k1

DA

k2

CB

Avant rotation : Nœud k1 déséquilibré

k2

k1

D

Ak3

CB

k1

k2

DA

k3

B C

Après 2ème rotation simple du sous-arbre de racine k1

Implantation ([1], Fig. 18.33)

static BinaryNode doubleWithRightChild( BinaryNode k1 ) { k1.right = withLeftChild( k1.right ); return withRightChild( k1 ); }



AVL avant insertion AVL après insertion de 5 et avant rotation double: les nœuds 8 et 12 sont déséquilibrés

AVL après rotation double (cas i gauche : k1 = 4, k2 = 6, k3 = 8)

8

10

12

16

144

62

8

10

12

16

144

62

5

6

12

16

144 8

2 105

Exemple d ’insertion avec rotation double Exemple d ’insertion avec rotation double ([1], ([1], FigFig. 18.30). 18.30)



Parcours effectués lors d ’une insertion dans AVLParcours effectués lors d ’une insertion dans AVL

Premier parcours : Parcours de l ’AVL vers le bas à partir de la racine pour trouver le point d ’insertion

Second parcours : Après insertion, il faut parcourir l ’arbre vers le haut à partir du point d ’insertion jusqu ’à la racine pour :

- mettre à jour les hauteurs- ré-équilibrage possible (rotation simple ou double)

On va proposer d ’autres structures d ’arbres qui évitent ce double parcourstout en garantissant une hauteur maximale en O( logN )



Les arbres rouges et noirs (ARN, Les arbres rouges et noirs (ARN, RedRed-Black)-Black)

Un ARN = un ABR avec les propriétés suivantes :

(1) chaque nœud a une des deux couleurs : rouge ou noir

(2) la racine est noire

(3) On ne peut pas avoir deux nœuds rouges consécutifs sur un chemin

(4) Tous les chemins partant d ’un même nœud vers une feuille quelconque ont le même nombre de nœuds noirs

Ces propriétés garantissent une hauteur logarithmique, c.-à-d. hauteur = O( logN )



Exemple d ’ARN Exemple d ’ARN ([1], Fig. 18.34))

30

15

10

5

20 60

70

85

90806550

5540

nœud rouge

nœud noir



Insertion Insertion BottomBottom-Up (dans ARN)-Up (dans ARN)

- Élément inséré doit être rouge, sinon règle 4 (voir page 41) non respectée

- Si parent du nœud inséré est noir alors insertion terminée

- Si parent du nœud inséré est rouge alors il faut ajuster l ’arbre de manière à : - retrouver la règle 3 - garder la règle 4

L ’ajustement est fait par : - changements de couleurs - rotations

Il y a 3 cas dans l ’ajustement (avec leurs symétriques) : Soit alors : - X l ’élément inséré, - P le parent (rouge) de X, - S le « frère » de P

- G le grand-parent (noir) de X (càd le parent de P et S)

Cas 1 : S est noir et X est enfant extérieur de P

Cas 2 : S est noir et X est enfant intérieur de P

Cas 3 : S est rouge



Insertion Insertion BottomBottom-Up : cas 1-Up : cas 1(1) On procède d ’abord comme pour Cas e de AVL (voir page 33) en effectuant rotation simple de l ’arbre de racine G(2) On effectue ensuite changements de couleurs suivants : G rouge et P noir

Si X enfant extérieur gauche ( cas e gauche ) :

P

G

B

C

A

X

S

ED

P

BA

X G

C S

ED

Si X enfant extérieur droit ( cas e droit ) :

P

G

B

C

A

X

S

E D

P

B A

XG

CS

E D



Insertion Insertion BottomBottom-Up : cas 2-Up : cas 2(1) On procède d ’abord comme pour Cas i de AVL (voir pages 37 et 38) en effectuant rotation double de l ’arbre de racine G(2) On effectue ensuite changements de couleurs suivants : G rouge et X noir

Si X enfant intérieur gauche ( cas i gauche ) :

P

G

C

A

B

X

S

ED

X

BA

P G

C S

ED

Si X enfant intérieur droit ( cas i droit ) :

P

G

C

A

B

X

S

E D

X

B A

PG

CS

E D



Insertion Insertion BottomBottom-Up : cas 3 (S est rouge)-Up : cas 3 (S est rouge)(1) On effectue d ’abord rotation simple ou double (comme dans cas 1 ou 2), selon que X enfant extérieur ou intérieur de P(2) On effectue ensuite changement de couleur suivant : - si X enfant extérieur de P alors : X devient noir - si X enfant intérieur de P alors : P devient noir

P

G

B

C

A

X

S

ED

P

BA

X G

C S

ED

Exemple : X enfant extérieur gauche de P

Exemple : X enfant intérieur gauche de P

P

G

C

A

B

X

S

ED

X

BA

P G

C S

ED



Insertion Insertion BottomBottom-Up : cas 3 (S est rouge)-Up : cas 3 (S est rouge) (suite)

Soit R la nouvelle racine du sous-arbre obtenu et soit H le parent de R

On constate que R est rouge

Si H est noir alors la transformation est terminée

Si H est rouge alors on refait la transformation (cas 1, 2 ou 3) avec R et H jouant le rôle de X et P

Ainsi, on peut avoir à remonter l ’arbre au complet jusqu ’à la racine (qui est noire)ce qui n ’est pas meilleur que les AVL



Insertion Top-DownInsertion Top-Down

Motivation : Éviter de remonter l ’arbre lors d ’une insertion et ainsi avoir des performances meilleures que : - AVL

- ARN Bottom-Up

Principe : Lors de la descente de l ’arbre pour trouver le point d ’insertion, des changements de couleurs et rotations (simples ou doubles) sont effectuées pour garantir qu ’après insertion, on sera toujours dans les cas 1 ou 2 (pages 44 et 45)

Procédure : - Si un nœud X (noir) a deux enfants rouges alors : - X devient rouge - ses deux enfants deviennent noirs - Si le parent P de X est rouge alors on effectue une rotation comme dans les cas 1 ou 2 (page 44 et 45)



50

Exemple d ’insertionExemple d ’insertion30

15

10

5

20 60

70

85

90806550

5540

Soit l ’ARN suivant auquel on veut insérer 45

Lors du parcours vers le bas, on atteint le nœud 50 qui est noir et dont les deux enfants sont rouges. Après inversion des couleurs, on obtient :

30

15

10

5

20 60

70

85

908065

5540

Règle 3 non respectée car 50 et 60 rouges



30

15

10

5

20 50

60

70

655540

Après rotation simple du sous-arbre de racine 70

Après insertion de 45 (rouge), on obtient :

Exemple d ’insertionExemple d ’insertion (suite)

85

9080

30

15

10

5

20 50

60

70

655540 85

908045



Suppression Top-DownSuppression Top-Down

Problème : Si nœud à supprimer est :

- rouge alors suppression comme dans ABR (pages 14-16) est correcte

- noir alors suppression comme dans ABR ne permet pas de respecter la règle 4

Solution : Lors de la descente de l ’ARN pour trouver l ’élément à supprimer, des changements de couleurs et rotations (simples ou doubles) sont effectuées pour garantir que le nœud à supprimer est rouge



Implantation de ARN Top-DownImplantation de ARN Top-Down

On définit une classe RedBlack qui implante l ’interface SearchTree (page 6)

Le squelette de RedBlack : [1], Fig. 18.42 et 18.43

Constructeur et initialiseur statique : [1], Fig. 18.44

Méthodes public : findMin : [1], Fig. 18.46 findMax : similaire à findMax find : [1], Fig. 18.47 insert : [1], Fig. 18.48 remove : non implantée removeMin : non implantée

isEmpty, makeEmpty, printTree : [1], Fig. 18.42

Méthodes private : printTree : [1], Fig. 18.45 handleReorient : [1], Fig. 18.49, appelée dans insert lorsqu ’un

nœud a deux enfants rouges, effectue rotations et changement de couleurs

rotate : [1], Fig. 18.50, effectue rotation appropriée,

Remarque : certains champs sont statiques car analogues à variables globales



Arbres AAArbres AA

Motivation : Rendre code des opérations plus simple que ARN Top-Down

Restriction par rapport aux ARN : Enfants gauches sont noirs

Cette restriction simplifie beaucoup les opérations d ’insertion (insert) et surtout desuppressions (remove, removeMin)

Au lieu d ’associer une couleur à un nœud, on lui associe un niveau



Niveau d ’un Niveau d ’un noeudnoeud

Transformation d ’un ARN en AA : Niveau d ’un nœud N est égal :

- à 1 si N est une feuille

- au niveau de son parent si N est rouge

- au niveau de son parent -1 si N est noir

Niveau de N représente le nombre de liens gauches de N à une feuille

Donc : - Niveau enfant gauche = (niveau de son parent - 1) - Niveau enfant droit = (niveau de son parent) ou (niveau de son parent - 1)

Représentation graphique d ’un AA : exemple

L ’ARN devient l ’AAA

B C

D E

A C

B D E

niveau 2

niveau 1

Lien horizontal représente un nœud et son enfant de même niveau



7030

15

205 10

50

35 40

60

6555 9080

85

Propriétés d ’un AAPropriétés d ’un AA

Les propriétés des couleurs d ’un ARN impliquent :

(1) les liens horizontaux sont vers la droite (car seuls les enfants droits peuventêtre rouges et ainsi au même niveau que leurs parents)

(2) Il est impossible d ’avoir deux liens horizontaux consécutifs (car deuxnœuds consécutifs ne peuvent pas être tous les deux rouges)

(3) Les nœuds aux niveaux > 1 ont deux enfants

(4) Si un nœud n ’a pas un lien horizontal à droite, alors ses deux enfants sont au même niveau

Exemple :

niveau 2

niveau 1

niveau 3

70, 60, 10 et 40 correspondent à des nœuds rouges



Insertion dans un AAInsertion dans un AA

Le nœud inséré par la méthode générale (page 13) est au niveau 1

Après insertion, on peut avoir : - un lien horizontal vers la gauche - deux liens horizontaux (vers la droite) consécutifs

On définit alors les deux opérations suivantes : - skew pour supprimer un lien horizontal à gauche - split pour supprimer deux liens horizontaux (à droite) consécutifs

Lorsque les deux opérations sont requises, alors skew doit être faite en premier

Un skew peut créer deux liens horizontaux à droite consécutifs

Un split peut créer : - un lien horizontal à gauche, ou - deux liens horizontaux à droite consécutifs

Il faut donc itérer jusqu ’à ce qu ’on n ’ait plus : - ni lien horizontal à gauche - ni deux liens horizontaux à droite consécutifs



P X P X

Opérations Opérations skew skew et et splitsplit

Skew :

A B C A B C

Et le parent de X devient parent de P

Split :

X

R

A B

X R

A B

Et le parent de X devient parent de R

G G



Exemple d ’insertionExemple d ’insertion

7030

15

205 10

50

35 40

60

6555 9080

85

On considère l ’exemple de la page 55

Après insertion de 45, on obtient :

45

Après split en 35, on obtient 7030

15

205 10

50

35

40 60

6555 9080

85

45



Après skew en 50, on obtient 7030

15

205 10

50

35

40 60

6555 9080

85

45


Après split en 40, on obtient : 7030

15

205 10

50

35

40 60

6555 9080

85

45

(50 est au même niveau que 30 et 70)



Après skew en 70, on obtient : 7030

15

205 10

50

35

40 60

6555 9080

85

45


Après split en 30, on obtient :

7030

15

205 10

50

35

40 60

6555 9080

85

45



Suppression dans un AASuppression dans un AATrois cas : élément à supprimer :

- est une feuille (donc de niveau 1)

- a un seul enfant (donc aussi de niveau 1)

- a deux enfants (de niveau > 1)

Pour les trois cas, on procède d ’abord comme pour ABR (voir pages 14-16)Donc suppression s ’effectue réellement uniquement sur feuilles ou nœuds à un enfant (c.-à-d. sur nœud de niveau 1)

Après une suppression d ’un nœud X de niveau 1, si le niveau du parent est 2alors il faut remettre à jour les niveaux en « descendant » certains nœuds vers le bas

Exemple : soit l ’AA 2 5

1 3 64 7

Après suppression de 1 et mise à jour des niveaux, on obtient l ’AA « écrasé » 2 5

36

47



Après suppression et mise à jour des niveaux, on peut obtenir des : - liens horizontaux à gauche - des liens horizontaux à droite consécutifsIl faut alors appliquer des opérations skew et split

Une séquence de trois skew et deux split garantit l ’équilibre

Exemple : sur exemple (de la page précédente)

Après skew :

Après skew

Après split :

Après split :

Suppression dans un AASuppression dans un AA (suite)

2 53

64

7

2 53 64

7

2 53 64 7

2 5

3

64 7

2

53

64 7



Implantation de AAImplantation de AA

On définit une classe AABlack qui implante l ’interface SearchTree (page 6)

Le squelette de RedBlack : [1], Fig. 18.65 et 18.66

Méthodes présentées dans [1] : insert : [1], Fig. 18.67 skew : [1], Fig. 18.68 split : [1], Fig. 18.69

remove : [1], Fig. 18.70

Toutes les méthodes de AATree ont été implantées (voir site web de [1])

notes de cours - usherbrooke.ca · université de sherbrooke chapitre 9 : les arbres binaires de...

Documents