ppt

Algoritmi e strutture dati
•Alberi binari di ricerca (BST)
albero binario di ricerca
• albero binario che soddisfa la
seguente proprietà
per ogni nodo, tutte le chiavi nel
suo sottoalbero sinistro sono 
della chiave v associata al nodo e
tutti le chiavi nel suo sottoalbero
destro sono  di v
Algoritmi e strutture dati
2
albero binario di ricerca/2
49
22
17
49
82
57
20
22
88
ok
17
94
82
47
20
91
88
errato!
94
91
Algoritmi e strutture dati
3
albero binario di ricerca/3
• indicato spesso come BST (binary
search tree)
• utilizzabile quando le chiavi
appartengono a un universo
totalmente ordinato
• ipotesi semplificativa di lavoro: chiavi
strettamente minori nei sottoalberi
sinistri e strettamente maggiori nei
sotto alberi destri
Algoritmi e strutture dati
4
rappresentazione dei nodi
• in molti casi può essere la stessa
usata negli alberi binari (classe
BinaryNode)
– in alternativa, la si può estendere
• per le variabili membro possiamo
usare lo specificatore di accesso
private o protected
– le conseguenze sono differenti
Algoritmi e strutture dati
5
rappresentazione
collegata dei nodi
public class BSTNode {
/* Qui può essere presente un campo info */
protected Comparable key;
// interface Comparable richiede metodo compareTo
BSTNode left, right; // rappr. minima
public BSTNode() {…}
public BSTNode(Object el) {…}
public BSTNode(Object el, BSTNode lt,
BSTNode rt) {…}
public void visit() { key.visit(); }
public boolean isLeaf() {…}
Algoritmi e strutture dati
}
6
operazioni sui BST
public interface BST {
void clear();
boolean isEmpty();
BSTNode search(BSTNode p, Comparable el);
void insert(BSTNode node);
boolean isInTree(Comparable el);
int getSize();
void inorder(BSTNode p);
void preorder(BSTNode p);
void postorder(BSTNode p);
void breadthFirst();
int treeHeight(BSTNode radice);
void delete(Comparable el);
}
Algoritmi e strutture dati
9
altre operazioni sui BST
BSTNode
BSTNode
BSTNode
BSTNode
minimum(BSTNode v);
maximum(BSTNode v);
successor(BSTNode v);
predecessor(BSTNode v);
D.: quali sono gli elementi max. e min. ?
Algoritmi e strutture dati
10
elementi o nodi?
• il metodo che implementa l’operazione
search può restituire elementi (Object) o
nodi (BSTNode)
– Object
• viene rafforzato l’incapsulamento
• variabili membro protected
– BSTNode
• operazioni su sottoalberi
• variabili membro private e metodi
accessori/modificatori
• il dilemma vale anche per altri metodi
– successor, delete (parametro formale), …
Algoritmi e strutture dati
11
ricerca in un BST
BSTNode search(BSTNode p, Comparable el) {
while (p != null)
if (el.equals(p.key))
return p;
else if (el.compareTo(p.key)<0)
p = p.left;
else p = p.right;
return null; /* Se non lo trova */
}
Algoritmi e strutture dati
12
Versione ricorsiva
BSTNode search(BSTNode p, Comparable el) {
if(p == null)
return null;
if (el.compareTo(p.key)<0)
return search(p.left, el);
else
if (el.compareTo(p.key)>0)
return search(p.right,el);
else return p;/* Trovato !! */
}
Algoritmi e strutture dati
13
costo della ricerca in un BST
BST di n nodi
• caso peggiore
– O(n)
49
21 52
56
54 67
• caso medio
77
– dipende dalla distribuzione
75
83
• caso migliore
– O(1) (poco interessante)
Algoritmi e strutture dati
14
costo della ricerca in un BST/2
• nel caso di distribuzione uniforme
delle chiavi il valore atteso
dell'altezza dell'albero è O(lg n)
– N.B. L'altezza di un albero binario di n
nodi varia in {lg2 n + 1,…, n}
un BST con chiavi uniformemente
distribuite ha un costo atteso di
ricerca O(lg n)
Algoritmi e strutture dati
15
inserimento in un BST
nuovo nodo u viene inserito come foglia
• fase 1: cerca il nodo genitore v
• fase 2: inserisci u come figlio di v
Algoritmi e strutture dati
18
inserimento in un BST/2
public void insert(Comparable el) {
BSTNode p = root, prev = null;
while (p != null) {
prev = p;
if (p.key.compareTo(el)<0)
p = p.right;
else p = p.left;
}
if (root == null) // albero vuoto;
root = new BSTNode(el);
else if (prev.key.compareTo(el)<0)
prev.right = new BSTNode(el);
else prev.left = new BSTNode(el);
}
Algoritmi e strutture dati
fase 1
fase 2
19
inserimento in un BST/3
• la fase 1 termina quando
si raggiunge un nodo del
BST privo del figlio in
cui avrebbe avuto senso
continuare la ricerca
– non necessariamente una
foglia
• la fase 2 si limita a
collegare una nuova
foglia
Algoritmi e strutture dati
60
49
21 52
56
54 67
77
75
83
20
inserimento in un BST/4
caso peggiore
• costo fase 1: O(n )
• costo fase 2: O(1)
• costo totale: O(n )
caso medio (distrib. unif.)
• costo fase 1: O(lg n )
• costo fase 2: O(1)
• costo totale: O(lg n )
Algoritmi e strutture dati
49
21 52
56
54 67
60 77
75
83
21
costo dell'inserimento
in un BST
• ogni inserimento introduce una nuova
foglia
• il costo è (proporzionale a) la
lunghezza del ramo radice-foglia
• nel caso peggiore O(n )
Algoritmi e strutture dati
22
cancellazione da un BST
tre casi
1.
cancellazione di una foglia
2. cancellazione di un nodo con un solo figlio
3. cancellazione di un nodo con due figli
Algoritmi e strutture dati
23
cancellazione da un BST/2
cancellazione di una foglia
• basta individuare il nodo genitore e
mettere a null la variabile membro
opportuna (left o right)
• individuare il genitore significa
sostanzialmente effettuare una ricerca
(come nella fase 1 dell'inserimento)
– un approccio alternativo è basato sulla
tramatura dell'albero (i nodi contengono altri
riferimenti, ad es., al genitore)
Algoritmi e strutture dati
24
cancellazione da un BST/3
cancellazione di 83
49
49
49
21 52
21 52
21 52
56
56
56
54 67
54 67
54 67
60 77
60 77
60 77
75
75
75
83
83
Algoritmi e strutture dati
25
cancellazione da un BST/4
cancellazione di un nodo u con un solo figlio v
• individuare genitore w di u
– se u è radice v diviene la nuova radice
• se esiste w, sostituire al collegamento
(w,u ) il collegamento (w,v )
v
u
v
w
w
w
w
u
v
Algoritmi e strutture dati
u
v
u
26
cancellazione da un BST/4
cancellazione di 52
49
49
49
21 52
21 52
21 56
56
56
54 67
54 67
54 67
60 77
60 77
75
75
Algoritmi e strutture dati
60 77
75
27
cancellazione da un BST/5
cancellazione di un nodo u con due figli (ci si
riconduce ad uno dei casi precedenti –
cancellazione per copiatura)
• individuare predecessore v (o successore)
di u (secondo il valore della chiave)
– v non può avere due figli, altrimenti non sarebbe
predecessore (successore)
• copiare la chiave di v al posto di quella di u
• cancellare nodo v
– v è foglia o ha un solo figlio
Algoritmi e strutture dati
28
cancellazione per copiatura
u
u
v
w
u
u
v
w
Algoritmi e strutture dati
w
v
w
29
Cancellazione per copiatura/2
public void deleteByCopying(Comparable el) {
BSTNode node, p = root, prev = null;
while (p != null && !p.key.equals(el)) {
prev = p;
if (p.key.compareTo(el)<0)
p = p.right;
else p = p.left;
}
node = p;
/* Cerca il nodo */
/* Continua alla prossima slide ..... */
Algoritmi e strutture dati
30
Cancellazione per copiatura/3
/* Dalla slide precedente .... */
if (p != null && p.key.equals(el)) {
if (node.right == null)
node = node.left;
else if (node.left == null)
node = node.right;
/* Casi semplici: il nodo ha un solo figlio */
/* Continua .... */
Algoritmi e strutture dati
31
Cancellazione per copiatura/4
/* Dalla slide precedente .... */
else { /* Due figli .... */
BSTNode tmp = node.left;
BSTNode previous = node;
while (tmp.right != null) {
previous = tmp;
tmp = tmp.right;
}
node.key = tmp.key;
/* Copia anche info se presente */
if (previous == node)
previous.left = tmp.left;
else previous.right = tmp.left;
} /* Continua ... */
Algoritmi e strutture dati
32
Cancellazione per copiatura/5
/* Dalla slide precedente .... */
if (p == root) /* Trova padre nuovo nodo */
root = node;
else if (prev.left == p)
prev.left = node;
else prev.right = node;
}
else if (root != null)
System.out.println(“Elemento assente”);
else System.out.println(“Albero vuoto");
}
Algoritmi e strutture dati
33
costo della cancellazione
in un BST
• la cancellazione di un
nodo interno richiede
l'individuazione del nodo
da cancellare nonché del
suo predecessore (o
successore)
• nel caso peggiore
entrambi i costi sono
lineari: O(n ) + O(n ) =
O(n )
da cancellare
n/2
u
v
n/2
predecessore
Algoritmi e strutture dati
34
Cancellazione per fusione
u: nodo da cancellare
x: nodo predecessore di u
u
v
v
w
x
w
x
Algoritmi e strutture dati
35
Domande
• Si implementi il metodo di visita in
ordine simmetrico
• Cosa produce la visita simmetrica se
le chiavi sono stringhe?
• Perché per implementare le basi di
dati si usano alberi e non array?
Algoritmi e strutture dati
36