Binary Search Trees (BST) Algoritmi sui BST. Algoritmi - Ricerca. Fondamenti di Informatica T2 Modulo 2. Università di Bologna A.A.

Transcript

1 Università degli Studi di Bologna Facoltà di Ingegneria Fondamenti di Informatica T Modulo Corso di Laurea in Ingegneria Informatica Anno accademico 00/009 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. 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 Algoritmi sui BST Alcuni algoritmi interessanti Ricerca Inserimento Cancellazione Le operazioni che modificano l albero devono lasciare inalterate le proprietà di ordinamento 4 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 Nota: il numero di passi/confronti da compiere è, al più, pari all altezza dell albero! 1 5 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. 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 c. Se è maggiore, assegnare ad x il figlio sinistro e procedere con 6 Università di Bologna A.A. 00/009

2 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 16 Algoritmi Inserimento Versione Ricorsiva 1. Sia x il nodo che identifica il sotto-albero in cui inserire l elemento e. Se x è nullo (albero vuoto), restituire un nuovo nodo contenente l elemento da inserire e terminare. 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. 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 Algoritmi - Rimozione Caso 1: il nodo da rimuovere è una foglia (1) Ricerca del nodo Rimozione dal padre Algoritmi Rimozione Caso : 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 Algoritmi Rimozione Caso : 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 11 Università di Bologna A.A. 00/009

3 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 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) 1 14 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 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 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 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; 17 1 Università di Bologna A.A. 00/009

4 Codice BinarySearchTree - Cancellazione public void remove(t x) root = remove(x, root); 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; 19 0 Codice BinarySearchTree - Svuotamento public void makeempty() root = null; 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(); 1 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; 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(); return t; Ricerca la foglia più a sinistra 4 Università di Bologna A.A. 00/009

5 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 Codice BinarySearchTree - Test Albero Vuoto public boolean isempty() return root == null; return t; 5 6 Due dimensioni: Visite Visite Esempio 5 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. 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 Visita in-order, leftmost Visita in-order, rightmost Visita post-order, rightmost 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 Realizzazione UML 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) 9 0 Università di Bologna A.A. 00/009

6 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); 1 Codice BinarySearchTree - Visite public void postordernavigation( BinarySearchTreeNavigator<T> nav, NavigationType type) if (root!= null) root.postordernavigation(nav, type); 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 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); if (last!= null) last.inordernavigation(nav, type); poi la radice Prima il primo nodo figlio ed infine il secondo nodo figlio 4 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); if (last!= null) last.postordernavigation(nav, type); nav.doaction(element); poi la radice Prima i due nodi figli 5 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(); 6 Università di Bologna A.A. 00/009

7 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(); 7 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; Codice Test - Visita Albero public void testprefixnavigation() ListBSTNavigator<Integer> nav = new ListBSTNavigator<Integer>(); BinarySearchTree<Integer> t = new BinarySearchTree<Integer>(); t.insert(5); t.insert(); t.insert(); t.insert(4); t.insert(7); t.insert(); Creazione dell albero binario t.preordernavigation(nav, NavigationType.LEFTMOST); Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(5, result.get(0)); assertequals(, result.get(1)); assertequals(, result.get()); assertequals(4, result.get()); 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 Viene effettuata una visita di tipo pre-order, leftmost 9 40 Codice Test - Visita Albero public void testinfixnavigation() ListBSTNavigator<Integer> nav = new ListBSTNavigator<Integer>(); BinarySearchTree<Integer> t = new BinarySearchTree<Integer>(); t.insert(5); t.insert(); t.insert(); t.insert(4); t.insert(7); t.insert(); Creazione dell albero binario Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(, result.get(0)); assertequals(4, result.get(1)); assertequals(, result.get()); assertequals(, result.get()); 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 t.inordernavigation(nav, NavigationType.LEFTMOST); Viene effettuata una visita di tipo in-order, leftmost 41 4 Università di Bologna A.A. 00/009

8 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(); t.insert(); 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 4 Codice Test - Visita Albero List<Integer> result = nav.getlist(); assertequals(, result.get(0)); assertequals(7, result.get(1)); assertequals(5, result.get()); assertequals(4, result.get()); assertequals(, 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, rightmost 44 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 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 Rotazioni Si supponga di disporre di un albero sbilanciato è possibile bilanciarlo tramite opportune rotazioni Ruotare il nodo verso sinistra in modo che diventi la radice dell albero il padre di () diventa il suo sotto-albero sinistro 15 Rotazioni Rotazione 1: il nodo diventa la radice 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 (1) diventa il sotto-albero destro di Università di Bologna A.A. 00/009

9 Rotazioni Rotazione : il nodo 15 diventa la radice e l albero risulta bilanciato 15 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! 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) 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? 51 5 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 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 5 54 Università di Bologna A.A. 00/009

10 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(); 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! Iteratore Pre-Order Pre-Order GO!!! Inizializzazione 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 Situazione dopo l inizializzazione Stack: Stack Top Considerazioni Il top dello stack è il nodo che contiene il successivo elemento da analizzare (restituire) Se lo stack è vuoto, fine dell iterazione Pre-Order GO!!! Pre-Order GO!!! Esecuzione next() una volta Stack: Output: Stack Top Esecuzione next() due volte Stack: 5 Output: Stack Top Università di Bologna A.A. 00/009

11 Pre-Order GO!!! Esecuzione next() tre volte Stack: 5 Output: Stack Top Pre-Order GO!!! Esecuzione next() quattro volte Stack: 6 Output: 5 Stack Top eccetera 6 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 = root; 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>>(); this.nodestovisit.push(root); public Iterator<T> iterator() public boolean hasnext() return new PreorderIterator<T>(root); return!nodestovisit.isempty(); 6 64 Inserisce nello stack la radice dell albero Codice Iterator Pre-order 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 Codice Iterator Pre-order public void remove() throw new UnsupportedOperationException(); Operazione non supportata return result; restituisce l elemento contenuto nel nodo estratto inserisce nello stack prima il figlio destro, poi quello sinistro Università di Bologna A.A. 00/009

12 Iteratore In-Order Inizializzazione 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 In-Order GO!!! Situazione dopo l inizializzazione Stack: Stack Top In-Order GO!!! Esecuzione next() una volta Stack: Output: Stack Top In-Order GO!!! Esecuzione next() due volte Stack: 5 Output: Stack Top In-Order GO!!! Esecuzione next() tre volte Stack: 6 Output: 5 Stack Top In-Order GO!!! Esecuzione next() quattro volte Stack: Output: 5 6 Stack Top eccetera 7 Università di Bologna A.A. 00/009

13 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 = root; public Iterator<T> iterator() return new InorderIterator<T>(root); 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); 7 74 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 In-order public boolean hasnext() return!nodestovisit.isempty(); public T next() if (!hasnext()) throw new NoSuchElementException(); Estrae un nodo dallo stack, BinaryNode<T> currentnode = nodestovisit.pop(); 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 pushleft(currentnode.getright()); restituisce return currentnode.getelement(); l elemento contenuto nel nodo estratto 76 Codice Iterator In-order Iteratore Post-Order public void remove() throw new UnsupportedOperationException(); Operazione non supportata 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! 77 7 Università di Bologna A.A. 00/009

14 La foglia più a sinistra Qual è la foglia più a sinistra? Questa! Se il nodo corrente è null, terminare. Inserire il nodo corrente nello stack. 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 Post-Order GO!!! Situazione dopo l inizializzazione Stack: Stack Top Nodo Corrente: null Post-Order GO!!! Esecuzione next() una volta Vecchio Nodo Corrente: null Stack Peek: Stack: Stack Top Output: Nodo Corrente: Post-Order GO!!! Esecuzione next() due volte Vecchio Nodo Corrente: Stack Peek: Stack: 5 Stack Top Output: 6 Nodo Corrente: 6 [6 entra ed esce dallo stack] Post-Order GO!!! Esecuzione next() tre volte Vecchio Nodo Corrente: 6 Stack Peek: 5 Stack: Stack Top Output: 6 5 Nodo Corrente: Università di Bologna A.A. 00/009

15 Post-Order GO!!! Esecuzione next() quattro volte Vecchio Nodo Corrente: 5 Stack Peek: Stack: Stack Top Output: 6 5 Nodo Corrente: Post-Order GO!!! Esecuzione next() cinque volte Vecchio Nodo Corrente: Stack Peek: Stack: 15 Stack Top Output: Nodo Corrente: 1 [1 entra ed esce dallo stack] eccetera 6 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 = root; 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); public Iterator<T> iterator() return new PostorderIterator<T>(root); 7 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 Post-order public boolean hasnext() return!nodestovisit.isempty(); public T next() if (!hasnext()) throw new NoSuchElementException(); Ottiene un riferimen to al nodo in cima allo stack, BinaryNode<T> nextnode = nodestovisit.peek(); if (nextnode.getright()!= currentnode) pushleftorright(nextnode.getright()); 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 currentnode = nodestovisit.pop(); estrae il nuovo nodo return currentnode.getelement(); corrente dallo stack e restituisce l elemento contenuto in esso 90 Università di Bologna A.A. 00/009

16 Codice Iterator Post-order public void remove() throw new UnsupportedOperationException(); Operazione non supportata 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); 91 9 Per giocare un po Esercizi MOLTO consigliati Realizzare gli iteratori rightmost 9 Università di Bologna A.A. 00/009