algoritmi e strutture dati - uniroma1.itfiii/materiale_leonardi/bst.pdfalberi binari di ricerca...

algoritmi e strutture dati

DizionariAlberi binari di ricerca (BST)

maggio 2003 ASD 02-03 2

Dizionari

Associa Informazioni a ChiaviTre operazioni fondamentali: Insert(key) Remove(key) Search(key)

Diverse implementazioni possibili

maggio 2003 ASD 02-03 3

Dizionari – Tipo di dato astratto

public interface Dictionary_adt {

void insert(Comparable key );

void remove(Comparable key );

Object search(Comparable key ) ;

}

maggio 2003 ASD 02-03 4

concetto di chiave

insieme di campi di un record checaratterizza l'intero record es.: {, , ,

, }il è una possibile chiave

spesso in una struttura dati vengonomemorizzate coppie (,), in cui è unriferimento per l'accesso ad un insieme diinformazioni

maggio 2003 ASD 02-03 5

chiavi

in Java le chiavi sono spesso realizzatecome riferimenti Comparable solo se occorre stabilire ordinamenti fra

chiavi

talvolta, a scopo esemplificativo, siusano come chiavi stringhe o interi facilita la descrizione di una struttura dati

maggio 2003 ASD 02-03 6

interface Comparablerichiede metodo int compareTo(Object o)returns a negative integer, zero, or a positive integeras this object is less than, equal to, or greater thanthe specified Object o The implementor must ensure sgn(x.compareTo(y)) == -

sgn(y.compareTo(x)) for all x and y. (This implies thatx.compareTo(y) must throw an exception iffy.compareTo(x) throws an exception.)

The implementor must also ensure that the relation istransitive: (x.compareTo(y)>0 && y.compareTo(z)>0)implies x.compareTo(z)>0

Finally, the implementer must ensure thatx.compareTo(y)==0 implies that sgn(x.compareTo(z)) ==sgn(y.compareTo(z)), for all z

da: documentazione API JFC

maggio 2003 ASD 02-03 7

interface Comparable /2

It is strongly recommended, but not strictlyrequired that (x.compareTo(y)==0) ==(x.equals(y)). Generally speaking, any classthat implements the Comparable interfaceand violates this condition should clearlyindicate this fact. The recommendedlanguage is "Note: this class has a naturalordering that is inconsistent with equals"

da: documentazione API JFC

maggio 2003 ASD 02-03 8

albero binario di ricerca

albero binario che soddisfa la seguenteproprietà

per ogni nodo, tutte le chiavi nelsuo sottoalbero sinistro sono ≤della chiave v associata al nodo etutti le chiavi nel suo sottoalberodestro sono ≥ di v

maggio 2003 ASD 02-03 9

albero binario di ricerca/2

49

91

57

8222

17

20

88

94

49

91

47

8222

17

20

88

94errato!ok

maggio 2003 ASD 02-03 10

albero binario di ricerca/3

indicato spesso come BST (binary searchtree)utilizzabile quando le chiavi appartengono aun universo totalmente ordinatoipotesi semplificativa di lavoro: chiavistrettamente minori nei sottoalberi sinistri estrettamente maggiori nei sotto alberi destri

maggio 2003 ASD 02-03 11

rappresentazione dei nodi

in molti casi può essere la stessa usatanegli alberi binari (classe BinaryNode) in alternativa, la si può estendere

per le variabili membro possiamo usarelo specificatore di accesso private oprotected le conseguenze sono differenti

maggio 2003 ASD 02-03 12

rappresentazionecollegata dei nodi/1

public class BSTNode {

protected Comparable key;protected BSTNode leftChild;protected BSTNode rightChild;

public BSTNode() { leftChild = rightChild = null; }

public BSTNode(Comparable el) { this(el,null,null); }

maggio 2003 ASD 02-03 13


protected BSTNode(Comparable el, BSTNode lt, BSTNode rt) { key = el; leftChild = lt; rightChild = rt; }

public Comparable getKey() { return key; }

public BSTNode getLeftChild() { return leftChild; }

public BSTNode getRightChild() { return rightChild; }

public void visit() {

maggio 2003 ASD 02-03 14


System.out.print(key.toString()); }

public boolean isLeaf() { return (leftChild == null) && (rightChild == null); }}

maggio 2003 ASD 02-03 15

BST – Tipo di dato astratto

public class BSTree implements Dictionary_adt { protected BSTNode root = null; protected int size = 0;

/** * Creates an empty BSTree */ public BSTree(){ }

maggio 2003 ASD 02-03 16

elementi o nodi?

il metodo che implementa l’operazione searchpuò 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), …

maggio 2003 ASD 02-03 17

ricerca in un BST

public BSTNode search(BSTNode p, Comparableel) {

if(p == null) return null; if(el.compareTo(p.key) == 0) return p; if (el.compareTo(p.key) < 0) return this.search(p.leftChild, el); else return this.search(p.rightChild, el); }

maggio 2003 ASD 02-03 18

ricerca in un BST/2

public BSTNode iterativeSearch(BSTNode p,Comparable el) {

while (p != null) if (el.compareTo(p.key) == 0) return p; else if (el.compareTo(p.key) < 0) p = p.leftChild; else p = p.rightChild; return null; }

in questo caso, la versione iterativa non richiede l'uso di una pila: perché?

maggio 2003 ASD 02-03 19

costo della ricerca in un BST

BST di n nodicaso peggiore O(n)

caso medio dipende dalla distribuzione

caso migliore O(1) (poco interessante)

49

52

56

67

77

83

54

75

21

maggio 2003 ASD 02-03 20

costo della ricerca in un BST/2

nel caso di distribuzione uniformedelle chiavi il valore atteso dell'altezzadell'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 uniformementedistribuite ha un costo atteso diricerca O(lg n)

maggio 2003 ASD 02-03 21

analisi del caso medio

IPL (internal path length):somma lungh. percorsi radice-nodo,per tutti i nodi

lungh. media percorso radice-nodo:IPL/(#nodi)

maggio 2003 ASD 02-03 22

analisi del caso medio/2

supp. chiavi 1,…,n presenti in un BST di n nodi(senza perdita di generalità)

Pn(i): lungh. percorso medio in BST di n nodi aventechiave i in radice (IPL/#nodi)Pn: percorso medio in BST di n nodi (IPL/#nodi)

se k(radice) = i allora– sottoalbero sx ha i – 1

chiavi– sottoalbero dx ha n – i

chiavi

maggio 2003 ASD 02-03 23

ricerca predecessore in BST

data una chiave a, trovare la chiaveb = pred(a), ovvero la più grande fra lechiavi < a operazione sfruttata nell'algoritmo di eliminazione

dove si trova b rispetto a? se esiste sottoalbero sinistro si trova in tale

sottoalbero se non esiste sottoalbero sinistro si trova sul

percorso radice – nodo contenente a

maggio 2003 ASD 02-03 24

ricerca predecessore in BST /2

Esiste un sottoalbero sinistrodi u.cerchiamo pred(k(u)) nelsottoalbero di radice unon può essere nel sottoalberodel figlio destro (chiavi > k(u))il max nel sottoalbero del figliosinistro è un candidato si tratta del "nodo più a destra",

individuabile scendendo sempre adestra in tale sottoalbero, fino atrovare un nodo senza figliodestro

u

v

w non qui

x

maggio 2003 ASD 02-03 25


Non esiste unsottoalbero sinistro di ucerchiamo pred(k(u)) sulcammino verso la radicenon può essere fuori dalpercorso radice – u (perle proprietà del BST)E’ il primo nodo con chiaveminore di u che si incontrasul cammino verso la radice

u

v

maggio 2003 ASD 02-03 26


public BSTNode predecessor(BSTNode p, Comparable el) { BSTNode pred = null; while(p != null) if(el.compareTo(p.key)

maggio 2003 ASD 02-03 27


costo ricerca predecessoreproporzionale all'altezza dell'alberonel caso peggiore O(n)

la ricerca del successore si realizza inmodo analogo e simmetrico.costo O(n)

maggio 2003 ASD 02-03 28

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

maggio 2003 ASD 02-03 29

inserimento in un BST/2

public void insert(BSTNode node) { BSTNode p = root, prev = null; Comparable el = node.getKey(); while (p != null) { // find a place for insert new node; prev = p; if (p.key.compareTo(el) < 0) p = p.rightChild; else p = p.leftChild; }

maggio 2003 ASD 02-03 30


if (root == null) // tree is empty; root = node; else if (prev.key.compareTo(el) < 0){ prev.rightChild = node; } else { prev.leftChild = node; } this.size++; }

maggio 2003 ASD 02-03 31


la fase 1 termina quando siraggiunge un nodo del BSTprivo del figlio in cuiavrebbe avuto sensocontinuare la ricerca non necessariamente una

foglia è il nodo inserito che diviene

foglia

la fase 2 si limita acollegare una nuova foglia

60

49

52

56

67

77

83

54

75

21

60

maggio 2003 ASD 02-03 32


caso peggiorecosto 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 )

49

52

56

67

77

83

54

75

21

60

maggio 2003 ASD 02-03 33

costo dell'inserimentoin un BST

ogni inserimento introduce una nuovafogliail costo è (proporzionale a) lalunghezza del ramo radice-fogliainteressato all'operazionenel caso peggiore: O(n)

maggio 2003 ASD 02-03 34

cancellazione da un BST

tre casi

cancellazione di una foglia

cancellazione di un nodo con un solo figlio

cancellazione di un nodo con due figli

maggio 2003 ASD 02-03 35

cancellazione da un BST/2

cancellazione di una foglia individuare nodo genitore e metterne a null la

variabile membro opportuna (leftChild orightChild); se foglia = radice (unico nodo)mettere a null il riferimento alla radice

individuare genitore significa effettuare unaricerca (come nella fase 1 dell'inserimento) un approccio alternativo è basato sulla tramatura

dell'albero (i nodi contengono altri riferimenti, ad es.,al genitore)

maggio 2003 ASD 02-03 36


cancellazione di 83

49

52

56

67

77

83

54

75

21

60

49

52

56

67

83

54

75

21

60

49

52

56

67

77

54

75

21

6077

maggio 2003 ASD 02-03 37


cancellazione di un nodo u con un solofiglio v

individuare genitore w di u; se u è radice v divienela nuova radice

se esiste w, sostituire al collegamento(w,u) il collegamento (w,v)

w

uv

w

uv

w

uv

u v

w

maggio 2003 ASD 02-03 38


cancellazione di 52

49

52

56

67

77

54

75

21

60

49

56

67

77

54

75

21

60

49

52

56

67

77

54

75

21

60

maggio 2003 ASD 02-03 39


cancellazione di un nodo u con duefigli

(ci si riconduce ad uno dei casi precedenti)individuare predecessore v (o successore)di u v non può avere due figli, altrimenti non sarebbe

predecessore (successore)

copiare la chiave di v al posto di quella di ucancellare nodo v v è foglia oppure ha un solo figlio: caso già

trattato

maggio 2003 ASD 02-03 40


u

v

u

v copi

a ch

iave

w w w

u u

w

canc

ella

v v

maggio 2003 ASD 02-03 41


public Comparable remove(Comparable el) { BSTNode p = root; BSTNode parent = null; while(p != null){ if(el.compareTo(p.key) > 0) parent = p; p = p.rightChild; } else if(el.compareTo(p.key) < 0) { parent = p; p = p.leftChild; } else break; if(p == null) return; // el not in tree

maggio 2003 ASD 02-03 42


// 1st case: p is leaf if(p.isLeaf()) if(parent == null) // p is root, too root = null; else if(parent.rightChild == p)

// p is rightChild parent.rightChild = null; else // p is leftChild parent.leftChild = null;

maggio 2003 ASD 02-03 43


// 2nd case: p has one child else if(p.leftChild == null)

// p has only a rightChild if(parent == null) // p is root, too root = p.rightChild; else if(parent.rightChild == p)

// p is rightChild parent.rightChild = p.rightChild; else // p is leftChild parent.leftChild = p.rightChild;

maggio 2003 ASD 02-03 44


else if(p.rightChild == null)// p has only a leftChild

if(parent == null) // p is root, too root = p.leftChild; else if(parent.rightChild == p)

// p is rightChild parent.rightChild = p.leftChild; else // p is leftChild parent.leftChild = p.leftChild;

maggio 2003 ASD 02-03 45


// 3rd case: p has 2 children (then it has a predecessor!) else {Comparable pred = this.predecessor(p.leftChild,

p.key).key; this.remove(pred); // removing node doesn't have two children! p.key = pred; } size--; }

maggio 2003 ASD 02-03 46

u

costo della cancellazionein un BST

la cancellazione di un nodointerno richiedel'individuazione del nodo dacancellare nonché del suopredecessore (osuccessore)nel caso peggiore entrambii costi sono lineari:O(n) + O(n) = O(n)

n/2

n/2da cancellare

predecessore

v

algoritmi e strutture dati - uniroma1.itfiii/materiale_leonardi/bst.pdfalberi binari di ricerca...

Documents