Binary Search Trees (BST)

Transcript

1 Università degli Studi di Bologna Facoltà di Ingegneria Fondamenti di Informatica T2 Modulo 2 Corso di Laurea in Ingegneria Informatica Anno accademico 200/2009 Binary Search Trees (BST) Also Known As Alberi Binari di Ricerca Un BST è un particolare tipo di albero binario in cui: I nodi contengono elementi appartenenti ad un insieme munito di un ordine totale (insieme totalmente ordinato) Per ogni nodo: i sottoalberi sinistro e destro sono BST; il sottoalbero sinistro contiene solo elementi minori (o uguali) dell elemento contenuto nel nodo; il sottoalbero destro contiene solo elementi maggiori (o uguali) dell elemento contenuto nel nodo. 2

2 Binary Search Trees (BST) I BST servono per gestire insiemi ordinati in modo ottimizzato consentendo di avere maggiore velocità in : Ricerche (se alberi ben bilanciati) Inserimenti e cancellazioni Può valere la pena di bilanciare un albero sbilanciato dopo vari inserimenti/cancellazioni per ottenere maggiore velocità nella ricerca In qualche caso, necessità di iterare su tutti gli elementi contenuti 3 Algoritmi sui BST Alcuni algoritmi interessanti Ricerca Inserimento Cancellazione Le operazioni che modificano l albero devono lasciare inalterate le proprietà di ordinamento 4

3 Algoritmi - Ricerca Per le proprietà dei Binary Search Trees, è possibile decidere, per ogni nodo, se proseguire la ricerca a sinistra o a destra Ricerca di 13 Nota: il numero di passi/confronti da compiere è, al più, pari all altezza dell albero! Algoritmi - Ricerca Versione ricorsiva 1. Se l elemento da cercare è minore dell elemento contenuto nella radice del sotto-albero corrente a. Cercare nel sottoalbero di sinistra b. Altrimenti, cercare nel sottoalbero di destra Versone iterativa 1. Sia x un nodo temporaneo ed, a questo, sia inizialmente assegnata la radice dell albero 2. Finché x non è nullo e non contiene il nodo cercato Confrontare il valore contenuto in x con il nodo cercato a. Se è uguale, restituire il valore trovato b. Se è minore, assegnare ad x il figlio destro e procedere con 2 c. Se è maggiore, assegnare ad x il figlio sinistro e procedere con 2 6

4 Algoritmi - Inserimento L algoritmo di inserimento è simile a quello di ricerca Cerca, nell albero, la posizione corretta di inserimento, ovvero il nodo che diventerà il padre di quello da inserire Una volta trovato il nodo, appende il nuovo nodo come figlio sinistro/destro in modo da mantenere la proprietà di ordinamento dell albero Inserimento di Algoritmi Inserimento Versione Ricorsiva 1. Sia x il nodo che identifica il sotto-albero in cui inserire l elemento e 2. Se x è nullo (albero vuoto), restituire un nuovo nodo contenente l elemento da inserire e terminare 3. Se e è minore dell elemento contenuto in x 1. Assegnare al sotto-albero sinistro di x il risultato dell inserimento di e nel sotto-albero sinistro corrente 2. Altrimenti, assegnare al sotto-albero destro di x il risultato dell inserimento di e nel sotto-albero destro corrente 4. Restituire x Versione Iterativa Fatelo da voi! Hints Scrivere un algoritmo di ricerca che restituisca l ipotetico nodo padre del nodo da inserire (non fallisce mai!) Inserire nel nodo trovato mantenendo le proprietà dell albero di ricerca

5 Algoritmi - Rimozione Caso 1: il nodo da rimuovere è una foglia (1) Ricerca del nodo Rimozione dal padre Algoritmi Rimozione Caso 2: il nodo da rimuovere ha un solo figlio Ricerca del nodo Rimozione dal padre e il padre punta ora all unico figlio del nodo rimosso

6 Algoritmi Rimozione Caso 3: il nodo da rimuovere ha due figli Ricerca del nodo Sostituzione del valore del nodo da rimuovere con il valore del più piccolo fra i valori maggiori (il nodo più a sinistra del sotto-albero di destra) Realizzazione Fra gli elementi contenuti nei nodi dell albero deve essere definita una relazione d ordine totale Tale relazione può essere realizzata in Java facendo in modo che questo elementi siano Comparable Le operazioni sul BST lavoreranno su oggetti Comparable

7 Realizzazione Il Nodo Il nodo dell albero sarà realizzato tramite la classe generica BinaryNode<T extends Comparable<T>> (il tipo su cui si può istanziare il generico DEVE implementare Comparable) caratterizzata da: un elemento Comparable<T>; un BinaryNode radice del sottoalbero di sinistra: un BinaryNode radice del sottoalbero di destra. UML Parametro generico e sue caratteristiche 13 Realizzazione L Albero Per una questione di praticità una classe di front-end verso la struttura ad albero Se non ci fosse, l albero vuoto sarebbe BynaryNode<X> emptytree = null In tal caso è impossibile effettuare operazioni sull albero vuoto: impossibile collocare il metodo isempty() impossibile invocare i metodi di visita che possono dare un output anche in caso di albero vuoto (es. rapprentazione stringa dell albero con visita pre/in/post fissa) 14

8 Realizzazione UML BinarySearchTree<T extends Comparable<T>> è la classe di front-end BinaryNode fa parte dello stato interno del sotto-sistema albero e non è visibile da fuori 15 Quali operazioni? Già riportate nel diagramma UML Tutte le operazioni di modifica preservano l ordinamento Inserimento insert Cancellazione remove rimuove un elemento specificato Svuotamento makeempty Ricerca find ricerca un elemento findmin ricerca l elemento minimo findmax ricerca l elemento massimo L albero è vuoto? isempty 16

9 Il codice Note L inserimento (insert), accetta duplicati La ricerca (find*), in presenza di duplicati, restituisce il primo elemento che corrisponde L eliminazione di un elemento (remove) pretende che l elemento sia presente (altrimenti eccezione) Alcuni metodi realizzati in modo iterativo; Semplici anche in versione iterativa ricerche Altri realizzati in modo ricorsivo; in versione iterativa sarebbero stati troppo complicati Inserimento, cancellazione 17 Codice BinarySearchTree - Inserimento public void insert(t x) root = insert(x, root); protected BinaryNode<T> insert(t x, BinaryNode<T> t) if (t == null) t = new BinaryNode<T>(x); else if (x.compareto(t.getelement()) < 0) t.setleft(insert(x, t.getleft())); else if (x.compareto(t.getelement()) > 0) t.setright(insert(x, t.getright())); return t; 1

10 Codice BinarySearchTree - Cancellazione public void remove(t x) root = remove(x, root); 19 Codice BinarySearchTree - Cancellazione protected BinaryNode<T> remove(comparable<t> x, BinaryNode<T> t) if (t == null) throw new ItemNotFoundException(x.toString()); if (x.compareto(t.getelement()) < 0) t.setleft(remove(x, t.getleft())); Rimozione di un else if (x.compareto(t.getelement()) > 0) nodo con due figli t.setright(remove(x, t.getright())); else if (t.getleft()!= null && t.getright()!= null) t.setelement(findmin(t.getright()).getelement()); t.setright(removemin(t.getright())); Rimozione di una foglia o di un nodo con un solo figlio else t = (t.getleft()!= null)? t.getleft() : t.getright(); return t; 20

11 Codice BinarySearchTree - Svuotamento public void makeempty() root = null; 21 Codice BinarySearchTree - Ricerca public T find(t x) return elementat(find(x, root)); private T elementat(binarynode<t> t) return t == null? null : t.getelement(); 22

12 Codice BinarySearchTree - Ricerca private BinaryNode<T> find(comparable<t> x, BinaryNode<T> t) while (t!= null) if (x.compareto(t.getelement()) < 0) t = t.getleft(); else if (x.compareto(t.getelement()) > 0) t = t.getright(); else return t; return null; 23 Codice BinarySearchTree - Ricerca Minimo public T findmin() return elementat(findmin(root)); protected BinaryNode<T> findmin(binarynode<t> t) if (t!= null) while (t.getleft()!= null) t = t.getleft(); Ricerca la foglia più a sinistra return t; 24

13 Codice BinarySearchTree - Ricerca Massimo public T findmax() return elementat(findmax(root)); protected BinaryNode<T> findmax(binarynode<t> t) if (t!= null) while (t.getright()!= null) t = t.getright(); Ricerca la foglia più a destra return t; 25 Codice BinarySearchTree - Test Albero Vuoto public boolean isempty() return root == null; 26

14 Visite Due dimensioni: 1. Ordine di lettura in verticale Pre-order: prima la radice poi i nodi figli In-order: prima il primo nodo figlio, poi la radice, poi il secondo nodo figlio Post-order: prima il primo nodo figlio, poi il secondo nodo figlio, poi la radice 2. Ordine di lettura in orizzontale Leftmost: il primo nodo figlio è il sotto-nodo di sinistra Rightmost: il primo nodo figlio è il sotto-nodo di destra 27 Visite Esempio Visita in-order, leftmost Visita in-order, rightmost Visita post-order, rightmost

15 Visite Implementazione Metodi ricorsivi su BinaryNode i metodi omonimi su BinarySearchTree delegano ai corrispondenti metodi su BinaryNode Un metodo per ogni ordine di visita in verticale (pre/in/post-order) Un parametro per indicare l ordine di visita in orizzontale (leftmost, rightmost) class trees public enum NavigationType LEFTMOST, RIGHTMOST, «interface» BinarySearchTreeNavigator + doaction(t) : void pre/in/post public void YorderNavigation (BinarySearchTreeNavigator nav, NavigationType type) Decide che cosa fare dell elemento contenuto nel nodo che si sta navigando metodo void doonelement(comparable) 29 Realizzazione UML 30

16 Codice BinarySearchTree - Visite Metodi per visitare l albero: ciascun metodo delega al corrispondente metodo su BinaryNode public void preordernavigation( BinarySearchTreeNavigator<T> nav, NavigationType type) if (root!= null) root.preordernavigation(nav, type); public void inordernavigation( BinarySearchTreeNavigator<T> nav, NavigationType type) if (root!= null) root.inordernavigation(nav, type); 31 Codice BinarySearchTree - Visite public void postordernavigation( BinarySearchTreeNavigator<T> nav, NavigationType type) if (root!= null) root.postordernavigation(nav, type); 32

17 Codice BinaryNode - Pre-order public void preordernavigation(binarysearchtreenavigator<t> nav, NavigationType type) nav.doaction(element); Prima la radice BinaryNode<T> first = getfirst(type); BinaryNode<T> last = getlast(type); if (first!= null) first.preordernavigation(nav, type); if (last!= null) last.preordernavigation(nav, type); poi i nodi figli nell ordine indicato da type 33 Codice BinaryNode - In-order public void inordernavigation(binarysearchtreenavigator<t> nav, NavigationType type) BinaryNode<T> first = getfirst(type); BinaryNode<T> last = getlast(type); if (first!= null) first.inordernavigation(nav, type); nav.doaction(element); poi la radice Prima il primo nodo figlio if (last!= null) last.inordernavigation(nav, type); ed infine il secondo nodo figlio 34

18 Codice BinaryNode - Post-order public void postordernavigation(binarysearchtreenavigator<t> nav, NavigationType type) BinaryNode<T> first = getfirst(type); BinaryNode<T> last = getlast(type); if (first!= null) first.postordernavigation(nav, type); Prima i due nodi figli if (last!= null) last.postordernavigation(nav, type); nav.doaction(element); poi la radice 35 Codice BinaryNode - Leftmost / Rightmost private BinaryNode<T> getfirst(navigationtype type) switch (type) Fornisce il primo nodo da case LEFTMOST: navigare a seconda del return left; tipo di navigazione case RIGHTMOST: scelto return right; default: throw new IllegalStateException(); 36

19 Codice BinaryNode - Leftmost / Rightmost private BinaryNode<T> getlast(navigationtype type) switch (type) Fornisce il secondo nodo case LEFTMOST: da navigare a seconda del return right; tipo di navigazione case RIGHTMOST: scelto return left; default: throw new IllegalStateException(); 37 Codice Test - ListBSTNavigator package trees.tests; public class ListBSTNavigator<T> implements BinarySearchTreeNavigator<T> ArrayList<T> list = new ArrayList<T>(); public void doaction(t c) list.add(c); public List<T> getlist() ArrayList<T> result = new ArrayList<T>(); result.addall(list); return result; 3

20 Codice Test - Visita Albero public void testprefixnavigation() ListBSTNavigator<Integer> nav = new ListBSTNavigator<Integer>(); BinarySearchTree<Integer> t = new BinarySearchTree<Integer>(); t.insert(5); t.insert(3); t.insert(2); t.insert(4); t.insert(7); t.insert(); t.preordernavigation(nav, NavigationType.LEFTMOST); Creazione dell albero binario Viene effettuata una visita di tipo pre-order, leftmost 39 Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(5, result.get(0)); assertequals(3, result.get(1)); assertequals(2, result.get(2)); assertequals(4, result.get(3)); assertequals(7, result.get(4)); assertequals(, result.get(5)); Viene recuperata la lista dei nodi visitati dal navigator Viene effettuato un controllo sull ordine dei nodi visitati, per testare il funzionamento dell algoritmo pre-order, leftmost 40

21 Codice Test - Visita Albero public void testinfixnavigation() ListBSTNavigator<Integer> nav = new ListBSTNavigator<Integer>(); BinarySearchTree<Integer> t = new BinarySearchTree<Integer>(); t.insert(5); t.insert(3); t.insert(2); t.insert(4); t.insert(7); t.insert(); t.inordernavigation(nav, NavigationType.LEFTMOST); Creazione dell albero binario Viene effettuata una visita di tipo in-order, leftmost 41 Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(2, result.get(0)); assertequals(4, result.get(1)); assertequals(3, result.get(2)); assertequals(, result.get(3)); assertequals(7, result.get(4)); assertequals(5, result.get(5)); Viene recuperata la lista dei nodi visitati dal navigator Viene effettuato un controllo sull ordine dei nodi visitati, per testare il funzionamento dell algoritmo in-order, leftmost 42

22 Codice Test - Visita Albero public void testinfixnavigation_rightmost() ListBSTNavigator<Integer> nav = new ListBSTNavigator<Integer>(); BinarySearchTree<Integer> t = new BinarySearchTree<Integer>(); t.insert(5); t.insert(3); t.insert(2); t.insert(4); t.insert(7); t.insert(); t.inordernavigation(nav, NavigationType.RIGHTMOST); Creazione dell albero binario Viene effettuata una visita di tipo in-order, rightmost 43 Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(, result.get(0)); assertequals(7, result.get(1)); assertequals(5, result.get(2)); assertequals(4, result.get(3)); assertequals(3, result.get(4)); assertequals(2, result.get(5)); Viene recuperata la lista dei nodi visitati dal navigator Viene effettuato un controllo sull ordine dei nodi visitati, per testare il funzionamento dell algoritmo pre-order, rightmost 44

23 Altri Alberi Il problema di BST è che normalmente NON sono bilanciati: Inserimenti e cancellazioni sbilanciano l albero Se l albero non è correttamente bilanciato le operazioni (tutte) costano parecchio Soluzione: alberi che si autobilanciano AVL (Adel'son-Vel'skii-Landis) Red-Black 45 Alberi AVL Un albero AVL è un Albero Binario di Ricerca bilanciato Un nodo si dice bilanciato quando l altezza del sotto-albero sinistro differisce dall altezza sottoalbero destro di al più una unita Un albero si dice bilanciato quando tutti i nodi sono bilanciati Le operazioni sono le stesse che si possono eseguire su un albero binario di ricerca 46

24 Rotazioni Si supponga di disporre di un albero sbilanciato è possibile bilanciarlo tramite opportune rotazioni 15 Ruotare il nodo verso sinistra in modo che diventi la radice dell albero il padre di () diventa il suo sotto-albero sinistro Rotazioni Rotazione 1: il nodo diventa la radice 15 Ruotare il nodo 15 verso sinistra in modo che diventi la radice dell albero il padre di 15 () diventa il suo sotto-albero sinistro, il sottoalbero sinistro di 15 (13) diventa il sotto-albero destro di

25 Rotazioni Rotazione 2: il nodo 15 diventa la radice e l albero risulta bilanciato Alberi AVL Si supponga di partire con un albero bilanciato, secondo la definizione data in precedenza Una serie di inserimenti/cancellazioni può sbilanciare l albero Opportune rotazioni sono in grado di ribilanciare l albero Naturalmente i costi di inserimento/cancellazione crescono di molto ma la ricerca rimane sempre molto efficiente! 50

26 Per giocare un po Bellissima applet java (codice disponibile) per giocare con alberi di ricerca di vario tipo, con possibilità di inserire, cancellare, ruotare e vedere come si comportano i vari tipi di alberi supportati Esercizi MOLTO consigliati: Calcolare l altezza di un albero Calcolare il bilanciamento di un nodo (differenza fra le altezze dei sotto-alberi sinistro e destro) 51 Iterazione È fondamentale poter disporre della possibilità di iterare sull albero BinarySearchTree<MyType> mytree = new BinarySearchTree<MyType>(); for (MyType element : mytree) dosomething(element); Ma come si rende l albero iterabile? 52

27 Iterabili, Iteratori Per rendere una classe iterabile, è sufficiente che essa implementi l interfaccia generica Iterable<T> Iterable<T> contiene un metodo (iterator()) che restituisce un iteratore sulla struttura, ovvero un oggetto che implementa l interfaccia Iterator<T> Iterator<T> è dotata di tre metodi: boolean hasnext() indica se l iteratore è in grado di fornire un ulteriore elemento T next() restituisce l elemento successivo void remove() rimuove l elemento corrente (l ultimo restituito) metodo opzionale (eventualmente sollevare un eccezione di tipo UnsupportedOperationException 53 Iterazione ma sugli alberi ci sono diverse possibilità di iterazione, pre/in/post order Ognuna di queste iterazioni deve essere implementata da un iteratore diverso Quale di questi iteratori viene restituito dall albero quando viene invocato il metodo iterator()? Qual è il tipo di iterazione più sensata per un BST? Visita/Iterazione in-order/leftmost: Propone gli elementi dell albero mostrandoli in ordine ascendente rispetto alla loro relazione d ordine totale 54

28 Iterazione e le altre modalità di iterazione? Esporre metodi per ottenere un oggetto iterabile che restituisca l iteratore opportuno: Iterator<T> getpreorderiterable(); Iterator<T> getinorderiterable(); Iterator<T> getpostorderiterable(); 55 Iteratori Non è possibile lavorare con la ricorsione: ogni volta che si desidera far avanzare l iteratore, occorre invocare il metodo next() Occorre mantenere lo stato necessario per continuare l iterazione dal punto in cui si è arrivati Quale stato? Usando la ricorsione si ha a disposizione lo stack dei record di attivazione occorre, almeno, usare uno stack in cui inserire (in qualche modo) i nodi da visitare! 56

29 Inizializzazione Iteratore Pre-Order Inserire nello stack la radice dell albero Elemento successivo (next()) Attenzione all ordine! Estrarre un nodo dallo stack (pop) Inserire nello stack prima il figlio destro, poi il figlio sinistro (se esistono) Restituire l elemento contenuto nel nodo estratto Considerazioni Il top dello stack è il nodo che contiene il successivo elemento da analizzare (restituire) Se lo stack è vuoto, fine dell iterazione 57 Pre-Order GO!!! Situazione dopo l inizializzazione Stack: Stack Top

30 Pre-Order GO!!! Esecuzione next() una volta Stack: 3 Output: Stack Top Pre-Order GO!!! Esecuzione next() due volte Stack: 5 2 Output: 3 Stack Top

31 Pre-Order GO!!! Esecuzione next() tre volte Stack: 5 Output: 3 2 Stack Top Pre-Order GO!!! Esecuzione next() quattro volte Stack: 6 Output: Stack Top eccetera 62

32 package trees; Codice Iterable Pre-order class PreorderIterable<T extends Comparable<T>> implements Iterable<T> private BinaryNode<T> root; public PreorderIterable(BinaryNode<T> root) this.root = public Iterator<T> iterator() return new PreorderIterator<T>(root); 63 Codice Iterator Pre-order class PreorderIterator<T extends Comparable<T>> implements Iterator<T> private Stack<BinaryNode<T>> nodestovisit; public PreorderIterator(BinaryNode<T> root) this.nodestovisit = new Stack<BinaryNode<T>>(); public boolean hasnext() return!nodestovisit.isempty(); Inserisce nello stack la radice dell albero 64

33 Codice Iterator public T next() if (!hasnext()) throw new NoSuchElementException(); BinaryNode<T> currentnode = nodestovisit.pop(); T result = currentnode.getelement(); if (currentnode.getright()!= null) nodestovisit.push(currentnode.getright()); if (currentnode.getleft()!= null) nodestovisit.push(currentnode.getleft()); Estrae un nodo dallo stack return result; restituisce l elemento contenuto nel nodo estratto inserisce nello stack prima il figlio destro, poi quello sinistro 65 Codice Iterator public void remove() throw new UnsupportedOperationException(); Operazione non supportata 66

34 Inizializzazione Iteratore In-Order Inserire nello stack la sequenza composta dalla lista che parte dalla radice ed arriva al nodo più a sinistra dell albero Elemento successivo (next()) Estrarre un nodo dallo stack (pop) Inserire nello stack la sequenza composta dalla lista che parte dal figlio di destra termina al nodo più a sinistra del sottoalbero Restituire l elemento contenuto nel nodo estratto Considerazioni Il top dello stack è il nodo che contiene il successivo elemento da analizzare (restituire) Se lo stack è vuoto, fine dell iterazione 67 In-Order GO!!! Situazione dopo l inizializzazione Stack: 3 2 Stack Top

35 In-Order GO!!! Esecuzione next() una volta Stack: 3 Output: 2 Stack Top In-Order GO!!! Esecuzione next() due volte Stack: 5 Output: 2 3 Stack Top

36 In-Order GO!!! Esecuzione next() tre volte Stack: 6 Output: Stack Top In-Order GO!!! Esecuzione next() quattro volte Stack: Output: Stack Top eccetera 72

37 package trees; Codice Iterable In-order Class InorderIterable<T extends Comparable<T>> implements Iterable<T> private BinaryNode<T> root; public InorderIterable(BinaryNode<T> root) this.root = public Iterator<T> iterator() return new InorderIterator<T>(root); 73 Codice Iterator In-order Class InorderIterator<T extends Comparable<T>> implements Iterator<T> private Stack<BinaryNode<T>> nodestovisit; public InorderIterator(BinaryNode<T> root) this.nodestovisit = new Stack<BinaryNode<T>>(); pushleft(root); 74

38 Codice Iterator In-order private void pushleft(binarynode<t> node) while (node!= null) nodestovisit.push(node); node = node.getleft(); Inserisce nello stack la sequenza composta dalla lista che parte dalla radice ed arriva al nodo più a sinistra dell albero 75 Codice Iterator public boolean hasnext() public T next() if (!hasnext()) throw new NoSuchElementException(); BinaryNode<T> currentnode = nodestovisit.pop(); pushleft(currentnode.getright()); return currentnode.getelement(); Estrae un nodo dallo stack, restituisce l elemento contenuto nel nodo estratto inserisce nello stack la sequenza composta dalla lista che parte dal figlio di destra e termina al nodo più a sinistra del sotto-albero e 76

39 Codice Iterator public void remove() throw new UnsupportedOperationException(); Operazione non supportata 77 Iteratore Post-Order Inizializzazione Inserire nello stack la sequenza composta dalla lista che parte dalla radice ed arriva alla foglia più a sinistra dell albero Per trovare la foglia più a sinistra, non è detto che si debba andare solo a sinistra! 7

40 La foglia più a sinistra Qual è la foglia più a sinistra? Questa! Se il nodo corrente è null, terminare 2. Inserire il nodo corrente nello stack 3. Se il nodo corrente ha un figlio sinistro, tale figlio diventa il nodo corrente ripartire da Se il nodo corrente ha un figlio destro, tale figlio diventa il nodo corrente Perché la foglia più a sinistra? Navigazione leftmost post-order: prima i nodi figli (più a sinistra), poi i nodi padre 79 Iteratore Post-Order Elemento successivo (next()) Sia il nodo corrente, il nodo contenente l ultimo valore restituito Ottenere un riferimento al nodo in cima allo stack (peek) Se il figlio destro del nodo prelevato dallo stack è diverso dal nodo corrente Inserire nello stack la sequenza composta dalla lista che parte dal figlio di destra ed arriva alla foglia più a sinistra del sotto-albero relativo Estrarre il nuovo nodo corrente dallo stack (pop) e restituire l elemento contenuto Considerazioni Il top dello stack è il nodo che contiene la radice del sotto-albero che si sta analizzando Se lo stack è vuoto, fine dell iterazione 0

41 Post-Order GO!!! Situazione dopo l inizializzazione Stack: 3 2 Stack Top Nodo Corrente: null Post-Order GO!!! Esecuzione next() una volta Vecchio Nodo Corrente: null Stack Peek: 2 Stack: 3 Stack Top Output: 2 Nodo Corrente:

42 Post-Order GO!!! Esecuzione next() due volte Vecchio Nodo Corrente: 2 Stack Peek: 3 Stack: 3 5 Output: 2 6 Nodo Corrente: 6 Stack Top [6 entra ed esce dallo stack] Post-Order GO!!! Esecuzione next() tre volte Vecchio Nodo Corrente: 6 Stack Peek: 5 Stack: 3 Output: Nodo Corrente: 5 Stack Top

43 Post-Order GO!!! Esecuzione next() quattro volte Vecchio Nodo Corrente: 5 Stack Peek: 3 Stack: Output: Nodo Corrente: 3 Stack Top Post-Order GO!!! Esecuzione next() cinque volte Vecchio Nodo Corrente: 3 Stack Peek: Stack: 15 Output: Nodo Corrente: 13 Stack Top [13 entra ed esce dallo stack] eccetera 6

44 package trees; Codice Iterable Post-order Class PostorderIterable<T extends Comparable<T>> implements Iterable<T> private BinaryNode<T> root; public PostorderIterable(BinaryNode<T> root) this.root = public Iterator<T> iterator() return new PostorderIterator<T>(root); 7 Codice Iterator Post-order Class InorderIterator<T extends Comparable<T>> implements Iterator<T> private Stack<BinaryNode<T>> nodestovisit; private BinaryNode<T> currentnode; public PostorderIterator(BinaryNode<T> root) this.currentnode = null; this.nodestovisit = new Stack<BinaryNode<T>>(); pushleftorright(root);

45 Codice Iterator Post-order private void pushleftorright(binarynode<t> node) while (node!= null) nodestovisit.push(node); if (node.getleft()!= null) node = node.getleft(); else node = node.getright(); Inserisce nello stack la sequenza composta dalla lista che parte dalla radice ed arriva alla foglia più a sinistra dell albero 9 Codice Iterator public boolean hasnext() public T next() if (!hasnext()) throw new NoSuchElementException(); BinaryNode<T> nextnode = nodestovisit.peek(); if (nextnode.getright()!= currentnode) pushleftorright(nextnode.getright()); currentnode = nodestovisit.pop(); return currentnode.getelement(); Ottiene un riferimen to al nodo in cima allo stack, inserisce nello stack la sequenza composta dalla lista che parte dal figlio di destra ed arriva alla foglia più a sinistra del sotto-albero relativo e estrae il nuovo nodo corrente dallo stack e restituisce l elemento contenuto in esso 90

46 Codice Iterator public void remove() throw new UnsupportedOperationException(); Operazione non supportata 91 Codice BinarySearchTree Oggetti Iterable public Iterable<T> getpreorderiterable() return new PreorderIterable<T>(root); public Iterable<T> getinorderiterable() return new InorderIterable<T>(root); Metodi che restituiscono i tre oggetti di tipo Iterable public Iterable<T> getpostorderiterable() return new PostorderIterable<T>(root); 92

47 Per giocare un po Esercizi MOLTO consigliati Realizzare gli iteratori rightmost 93