PlanLangage Java• Sous-classes et visibilitéAlgorithmique• Arbres de recherche• Arbres AVL• Union-Find

(1)

Plan Langage Java

• Sous-classes et visibilité Algorithmique

• Arbres de recherche

• Arbres AVL

• Union-Find

(2)

X, Petite classe 5 X, Petite classe 7

Sous-classes

class Vehicule {

int nbRoues, vitesse;

void Accelerer()

{ vitesse += 100; } }

class Voiture extends Vehicule { // Sous-classe de Vehicule

boolean airbag;

}

Vehicule maVoiture = new Voiture();

maVoiture.Accelerer();

maVoiture.Airbag = false;

(3)

Visibilité

On peut modifier la visibilité des variables et des méthodes.

Modificateur Visibilité private La classe

par défaut Le paquetage

protected Le paquetage et les sous-classes, même

en dehors du paquetage public Toutes les classes

class Exemple

{ private int monParametre;

protected maMethode();

}

(4)

Remarque importante

Même si une classe est déclarée

"public", ses variables et méthodes ne sont pas automatiquement

"public"...

(5)

Parcours d'arbres

Préfixe : 1, 2, 4, 8, 9, 5, 10, 3, 6, 7 (VGD)

Infixe : 8, 4, 9, 2, 10, 5, 1, 6, 3, 7 (GVD)

Suffixe : 8, 9, 4, 10, 5, 2, 6, 7, 3, 1 (GDV)

1

2 3

4 5 6 7

8 9 10

(6)

public class Arbre {

int contenu;

Arbre filsG;

Arbre filsD;

Arbre(int v, Arbre a, Arbre b) {

this.contenu = v;

this.filsG = a;

this.filsD = b;

}

static void ParcoursPrefixe(Arbre a) { if (a != null)

{

System.out.print(a.contenu + " ");

ParcoursPrefixe(a.filsG);

ParcoursPrefixe(a.filsD);

} }

(7)

static void ParcoursInfixe(Arbre a) {

if (a != null) {

ParcoursInfixe(a.filsG);

ParcoursInfixe(a.filsD);

} }

static void ParcoursSuffixe(Arbre a) { if (a != null)

{

ParcoursSuffixe(a.filsG);

ParcoursSuffixe(a.filsD);

} }

(8)

Propriété de base : Pour chaque noeud de valeur v, les noeuds du sous-arbre gauche ont une valeur

< v et ceux du sous-arbre droit ont une valeur > v.

Arbres de recherche

10 13

8 14 16 21

12 19

15

17

(9)

Exercices

(1) Montrer que le parcours infixe ordonne les nœuds par valeur croissante.

(2) Montrer que si un nœud a deux fils, son successeur dans l'ordre infixe n'a pas de fils gauche et son prédécesseur n'a pas de fils droit.

(3) Montrer que le successeur du nœud n est le sommet le plus à gauche dans le sous-arbre droit issu de n.

(10)

Arbre Recherche(int v, Arbre a) { if (a == null || v == a.contenu)

return a;

if (v < a.contenu)

return Recherche(v, a.filsG);

return Recherche(v, a.filsD);

}

Recherche

(11)

Arbre ajouter(int v, Arbre a) { if (a == null)

a = new Arbre(v, null, null);

else if (v <= a.contenu)

a.filsG = ajouter(v, a.filsG);

elsea.filsD = ajouter(v, a.filsD);

return a;

}

Ajout d'un élément

(12)

Suppression

(a) Le noeud est une feuille : on le supprime

10

8 14 16 21

12 19

15

13 17 10

8 14 16 21

12 19

15

17

(b) Le noeud a un seul fils : on le supprime

10

8 13 16 21

12 19

15

13 17 10

8 14 16 21

12 19

15

17

(13)

(c) Le noeud s a deux fils : on supprime son successeur t (qui n'a pas de fils gauche), mais on remplace la valeur de s par celle de t.

10 13

8 14 16 21

12 19

15

17 10 13

8 14 16 21

12 19

15

17

10 13

8 14 17 21

12 19

16

(14)

{

if (a == null) return a;

if (v == a.contenu)

return supprimerRacine(a);

if (v < a.contenu)

a.filsG = supprimer(v, a.filsG);

else // v > a.contenu

a.filsD = supprimer(v, a.filsD);

return a;

}

static Arbre dernierFils(Arbre a) {

if (a.filsD == null) return a;

return dernierFils(a.filsD);

}

static Arbre supprimerRacine(Arbre a) {

if (a.filsG == null) return a.filsD;

if (a.filsD == null) return a.filsG;

Arbre b = dernierFils(a.filsG);

a.contenu = b.contenu;

a.filsG = supprimer(a.contenu, a.filsG);

return a;

}

(15)

• O(log n) si l'arbre est équilibré

• O(n) si l'arbre est filiforme

• D'où l'intérêt des arbres équilibrés!

• Arbre AVL (Adel'son-Vel'skii et Landis) : pour tout noeud, la

différence de hauteur entre les sous-arbres gauche et droit est égale à -1, 0 ou 1.

Exemple : les tas

Hauteur d'un arbre AVL : O(log n) Temps de calcul

(16)

public class ArbreAVL {

int contenu;

ArbreAVL filsG;

ArbreAVL filsD;

int bal;

ArbreAVL(int v,

ArbreAVL a, ArbreAVL b) {

contenu = v;

filsG = a;

filsD = b;

}

(17)

Théorème. Soit un arbre AVL de hauteur h à n sommets. Alors

log₂(1 + n) ≤ 1 + h ≤ 1,44 log₂(1 + n)

Preuve. Pour une hauteur h donnée, le nombre maximum de sommets est atteint pour l'arbre complet à 2^h+1 - 1 sommets.

Hauteur 0 : • Hauteur 1 :

Hauteur 2 :

Donc n ≤ 2^h+1 -1 et log₂(1 + n) ≤ 1 + h

•

• •

•

(18)

Soit N(h) le nombre minimum de sommets d'un arbre AVL de hauteur h. On a

N(0) = 1 N(1) = 2

N(h) = 1 + N(h-1) + N(h-2)

Donc F(h) = N(h) + 1 vérifie F(0) = 2 F(1) = 3 F(h) = F(h-1) + F(h-2) d'où F(h) = F_h+3 =

1 [(^{1 +}^√⁵)^h+3 - (^{1 -}^√⁵)^h+3]

h-1 h-2

√ 5 2 2

(19)

Rotation simple

h-1 h-2

X Y

Z h-2

•

u • v

x

•

h-1 X

Y Z ^h-2

•

u

v x

•

u ≤ x ≤ v

(20)

Double rotation

u ≤ v ≤ x ≤ w

x

h-2

X

V

Z h-2

•

u •

v

w

•

W

• •

v

w u

X

• •

V W h-2

• •

• x

•

Z

(21)

8

13

2 12 21 28

3 25

20

14

+ 2

8

13

2 12

3

14 2 8 13

3 14

12

(22)

Données : une partition de l'ensemble {1, ..., K}

• Trouver la classe d'un élément

• Faire l'union de deux classes.

Partitions

Une première solution :

Représenter la partition par un tableau classe tel que classe[i]

soit la classe de l'élément i.

Trouver : O(1) Union : O(n)

(23)

Deuxième solution : utilisation d'une forêt.

10

6

8 4

5 9

1

7 11 3

2

Trouver : O(n)

Union : proportionnel à la hauteur de l'arborescence

On représente la forêt par un tableau t tel que t[s] = père de s (si s est une racine, t[s] = s)

(24)

Union pondérée

Règle : Lors de l'union, la racine de l'arbre de moindre taille devient fils de la racine de l'arbre de plus grande taille.

6

10

8 4

5 9

1

7 11 3

2

On part de la partition de {1, ..., K}

en K classes.

1 2 … K

(25)

Notons t_i(x) la taille (= nombre de noeuds) et h_i(x) la hauteur du sommet x après la i-ème opération d'union pondérée. On a t₀(x) = 1 et h₀(x) = 0.

Lemme. On a t_i(x) ≥ 2^hi(x) et h_n(x) ≤ log₂(n + 1).

Preuve.

(a) Si h_i(x) = 0, alors t_i(x) = 1

(b) à suivre …

x

(26)

Lemme. On a t_i(x) ≥ 2^hi(x) et h_n(x) ≤ log₂(n + 1).

Preuve (suite).

(b) Si h_i(x) > 0, soit y un fils de x. On a h_i(y) = h_i(x) - 1. Si y est devenu un fils de x lors de la j-ième union (j ≤ i), on a

t_j-1(x) ≥ t_j-1(y)^{, d'où} t_j(y) = t_j-1(y) ^et t_j(x) ≥ 2t_j(y). Ensuite, la taille de y ne varie plus, mais celle de x peut croître.

De même, la hauteur de y ne varie plus, donc h_i(y) = h_j-1(y). Par hypothèse de récurrence, t_j-1(y) ≥ 2^hj-1(y), donc

t_j(y) = t_j-1(y) ≥ 2^hj-1(y) = 2^hi(y) ^et

t_j(x) ≥ t_j(x) ≥ 2.t_j(y) ≥ 2.2^hi(y)= 2^hi(x)

Comme t_n(x) ≤ n+1, on a la seconde inégalité.

x y

(27)

Corollaire. Une suite de n-1

"unions" et de m "trouver" se réalise en temps O(n + m log n).

(28)

Compression des chemins

On comprime un chemin en faisant de chaque nœud traversé un fils de la racine :

10

8 4

5 9

1

10

8

4 9

5

1

Prop. Une suite de n-1 "unions" et de m "trouver" (m ≥ n) se réalise en temps O(m.α(n,m)), où α est l'inverse d'une sorte de fonction d'Ackermann. En pratique, α(n,m)

≤ 2.