Esercizi di Algoritmi e Strutture Dati - Moreno Marzolla

Esercizi di Algoritmi e Strutture DatiMoreno Marzollamarzolla@cs.unibo.itUltimo aggiornamento: 29 novembre 20101 Rotazioni semplici in ABRSi consideri l’operazione di rotazione semplice applicata ad un Albero Binariodi Ricerca (ABR). Dimostrare che l’operazione di rotazione semplice, comedefinita a lezione, preserva la proprietà di ordinamento degli ABR. In altre parole,dimostrare che un ABR, dopo una singola operazione di rotazione semplicerispetto ad un qualsiasi nodo x, è ancora un ABR.SoluzioneConsideriamo la figura seguente:X Y/ \ / \Y T3 T1 X/ \ / \T1 T2 T2 T3Supponiamo di effettuare una rotazione semplice verso destra, usando Xcome perno. Prima della rotazione, valgono le seguenti relazioni:Y ≤ XT 1 ≤ YT 2 ≥ YT 2 ≤ XT 3 ≥ X(dove per semplicità usiamo la notazione T 1 ≤ Y per indicare che per ogninodo Z di T 1 vale la relazione Z ≤ Y ). È possibile verificare che tutte questerelazioni valgono anche nell’albero di destra (quello ottenuto dopo la rotazione),che quindi è ancora un ABR.1

2 Costruzione di ABRDimostrare che qualsiasi algoritmo basato su confronti per la costruzione di unABR con n nodi ha complessità asintotica Ω(n log n).Soluzione Supponiamo che sia possibile costruire un ABR con n nodi, utilizzandoconfronti, in tempo strettamente inferiore a Ω(n log n). Ricordiamoche, dato un ABR con n nodi, è possibile ottenere la lista ordinata delle chiaviin esso contenute mediante una visita simmetrica (detta anche visita inordine)dell’albero. La visita simmetrica ha costo Θ(n). Quindi, se potessimocostruire un ABR in tempo inferiore a Ω(n log n), riusciremmo anche aordinare un insieme di n elementi, usando solo confronti, in tempo inferiorea Ω(n log n), il che è impossibile dato il limite inferiore alla complessità delproblema dell’ordinamento mediante confronti3 Visita di un ABRL’operazione di visita di un ABR con n nodi può essere implementata determinandol’elemento minimo dell’ABR, e poi invocando n − 1 volte l’operazionesuccessor(). Fornire una giustificazione intuitiva del fatto che questo algoritmodi visita abbia complessità asintotica Θ(n).SoluzioneRicordiamo l’algoritmo per determinare il successore di un nodoalgorithm successor(nodo v) -> nodoif (v == null) thenreturn null;endifif (v.right != null) thenreturn min(v.right);elsep = v.parentwhile (p != null && v == p.right) dov = p;p = v.parent;endwhilereturn p;endifdove la procedura min() determina il nodo con chiave minima in un alberoradicato nel nodo v, ed è definita comealgorithm min(nodo v) -> nodowhile (v != null && v.left != null) dov = v.left;endwhile2

eturn v;Se proviamo a “visualizzare” il comportamento dell’operazione di visita implementatamediante determinazione dell’elemento minimo seguita da n − 1 invocazionidella procedura successor(), osserviamo che ciascun arco dell’alberoviene attraversato esattamente due volte: una volta “in discesa”, ad opera dellaprocedura min(), e una volta “in salita” ad opera della procedura successor(),che nel ramo else risale di figlio in padre fino alla prima “svolta a destra”. Èanche importante osservare che una volta attraversato in discesa e in salita, unarco non viene più attraversato. Osserviamo anche che vengono eseguite O(1)operazioni elementari per ogni attraversamento di arco.A questo punto, osserviamo che un albero on n nodi ha esattamente n − 1archi (si dimostra per induzione, e vale per qualsiasi albero, non solo per alberibinari). Quindi il costo dell’operazione di visita implementata come sopra è2(n − 1) = Θ(n).4 Incremento di chiavi in un albero AVLSi consideri un albero AVL contenente n chiavi numeriche. Supponiamo chele chiavi siano tutte distinte tra loro. Vogliamo implementare l’operazioneincrementaChiave(k, d) il cui scopo è quello di incrementare il valore dellachiave k di una quantità d (che potrebbe anche essere negativa), facendolo diventarek + d. Al termine di questa operazione, la struttura dati risultantedeve ancora essere un albero AVL. Per l’ipotesi di unicità delle chiavi, il nodocontenente la chiave k, se esiste, è sempre unico; supponiamo anche che ilvalore k + d sia unico. Descrivere un algoritmo per realizzare l’operazioneincrementaChiave(k,d), stimandone poi il costo computazionale.Soluzione Esiste una soluzione banale, che consiste nel rimuovere il nodo conchiave k (che per ipotesi è unico) e inserire un nuovo nodo con chiave k + d. Ilcosto complessivo risulta essere O(log n).5 Implementazione di un albero AVLA lezione abbiamo visto che per una corretta implementazione degli alberi AVLè necessario conoscere l’altezza dei sottoalberi radicati in ciascun nodo. Infatti,questa informazione consente poi di capire quali sono i sottoalberi “pesanti”,e quindi procedere alle operazioni di ribilanciamento appropriate. Ricordiamoche l’altezza di un albero è la massima profondità cui si trova una sua foglia.L’albero composto da un singolo nodo (la radice) ha altezza 0.1. Consideriamo innanzitutto un generico ABR (non bilanciato). Supponiamoche ciascun nodo v abbia un attributo intero v.h che corrispondeall’altezza del sottoalbero radicato in v. Mostrare come sia possibile estenderele operazioni di inserimento e rimozione di nodi di un ABR per3

mantenere in modo efficiente il valore corretto di v.h per ciascun nodo.Tale modifica non deve alterare il costo computazionale delle operazionidi inserimento e rimozione, che devono mantenersi O(h) nel caso pessimo,essendo h l’altezza totale dell’albero.2. Consderiamo ancora un generico ABR. Dimostrare come l’operazione dirotazione semplice può essere estesa per mantenere il valore corretto di v.hper ciascun nodo. Dopo tale modifica, il costo dell’operazione di rotazionesemplice deve essere O(h) nel caso pessimo, essendo h l’altezza totaledell’albero.3. Usare i due punti precedenti per dimostrare come sia possibile mantenerel’informazione sull’altezza di ciascun sottoalbero in un albero AVL senzaalterare il costo computazionale delle operazioni di inserimento e rimozionedi nodi.SoluzioneAssumiamo che un oggetto nodo v abbia gli attributi seguenti:v.left riferimento al figlio sinistro (oppure null);v.right riferimento al figlio destro (oppure null);v.parent riferimento al padre (oppure null se v è la radice);v.h altezza dell’albero radicato in v.Definiamo come prima cosa l’algoritmo aggiusta_h(v). L’algoritmo funzionacome segue: assume che i figli del nodo v (se esistono) abbiano il valorecorretto dell’attributo h (quindi, assume di conoscere in maniera esatta l’altezzadei sottoalberi radicati nei figli, sempre se non sono vuoti). In base a questainformazione, calcola il valore di v.h.algoritmo aggiusta_h(Nodo v)if ( v.left == null && v.right == null ) thenv.h = 0;elseif( v.left == null ) then // v.right != nullv.h = v.right.h + 1;elseif( v.right == null ) then // v.left != nullv.h = v.left.h + 1;elsev.h = max( v.left.h, v.right.h ) + 1;endifA questo punto è facile definire un’altra procedura, che chiameremo aggiusta_h_ricche risale ricorsivamente da un nodo v fino alla radice dell’albero, ricalcolandoil valore dell’attributo h di tutti i nodi visitati:4

algoritmo aggiusta_h_ric(Nodo v)while ( v != null ) doaggiusta_h(v);v = v.parent;endwhileOra siamo in grado di ricalcolare il valore di h in caso di inserimento orimozione di nodi.Nel caso di inserimento in un ABR, sappiamo che il nuovo nodo venga inseritoin una foglia v. Dopo l’inserimento, chiamiamo semplicemente l’operazioneaggiusta_h_ric(v) che ricalcola tutte le altezze da v fino alla radice dell’albero.Il costo complessivo è O(h) nel caso pessimo, essendo h l’altezza dell’albero.Nel caso di rimozione, è necessario distinguere i tre casi:• Il nodo rimosso v era una foglia. Sia p il padre di v (se esiste). Dopo averstaccato v, si invoca aggiusta_h_ric(p) e l’algoritmo termina.• Il nodo rimosso v ha un unico figlio w. Sia p il padre di v. Il nodo w vienereso figlio di p (al posto di v, e si invoca l’operazione aggiusta_h_ric(p).L’algoritmo termina.• Il nodo rimosso v ha due figli. Si individua il nodo predecessore w, ilquale non ha figlio destro. Sia p il padre di w. È possibile rimuoverew attaccando il padre p all’unico figlio di w. Il nodo w si sostituiscea v. A questo punto si invoca aggiusta_h_ric(p), essendo sicuri chenel cammino da p alla radice la procedura attraversa anche la posizioneprecedentemente occupata dal nodo v che è stato rimosso (posizione oraoccupata da w).Nel caso della rotazione semplice, consideriamo il caso di rotazione sempliceverso destra rispetto ad un nodo x. Si può eseguire la procedura seguente:x/ \y t3/ \t1 t2y = x.left;t1 = y.left;t2 = y.right;t3 = x.right;y.right = x;x.left = t2;x.right = t3;aggiusta_h_ric(x);5

6 Attraversamento in-ordine iterativoScrivere un algoritmo iterativo per effettuare la visita in-ordine di un alberobinario (non necessariamente di ricerca).Soluzione Per implementare l’algoritmo di visita in-ordine facciamo uso diuno stack (pila). Gli elementi che inseriamo nello stack sono coppie < n, b >,essendo n un riferimento ad un nodo dell’albero, e b un valore booleano che puòessere true o false.algoritmo inordine-iter(Nodo t)Stack S;S.push( );while (!S.empty()) do := S.pop(); // estrai dallo stackif (f==true) thenvisita il nodo n;elseif (n.right != null) thenS.push( );endifS.push( );if (n.left != null) thenS.push( );endifendifendwhileL’idea dell’algoritmo è la seguente: ogni nodo n viene inizialmente inseritonello stack con flag settato a false. Quando un nodo v con flag settato a falseviene estratto dallo stack, inseriamo prima il figlio destro, poi il nodo v con flagsettato a true, e quindi il figlio sinistro. Quando estraiamo dallo stack un nodocon flag settato a true, è giunto il momento di “visitare” il nodo, che non verràulteriormente reinserito.7 Albero inversoDato un albero binario, i cui nodi contengono elementi interi, si scriva unaprocedura di complessità ottima per ottenere lalbero inverso, ovvero un alberoin cui il figlio destro (con relativo sottoalbero) è scambiato con il figlio sinistro(con relativo sottoalbero).Soluzionealgoritmo inverti(Nodo t)if (t == NULL) then6

eturn;else// scambia i figli sinistro e destroNodo tmp = t.left;t.left = t.right;t.right = tmp;inverti(t.left);inverti(t.right;endifL’algoritmo viene inizialmente invocato passando come parametro un riferimentoalla radice dell’albero da invertire.8 Cancellazione di nodi da ABRL’operazione di cancellazione da un ABR commutativa? Nel senso che cancellareprima x e poi y, oppure cancellare prima y e poi x, produce lo stessoABR?SoluzioneConsideriamo il seguente ABR6/4/ \2 5/ \1 36/2/ \1 3Rimuovendo prima il valore 5, poi il valore 4 si ottiene il seguente ABRSe invece rimuoviamo prima il valore 4, poi il valore 5 si ottiene il seguenteABR6/3/2/17

9 Verifica ABR(Questo esercizio è stato assegnato nella prova scritta del 20/9/2010) Si consideriun albero binario B in cui a ciascun nodo v è associata una chiave numerica(reale) v.key. Non ci sono chiavi ripetute, e tutte le chiavi appartengonoall’intervallo [a, b].1. Scrivere un algoritmo efficiente che dato in input l’albero B e gli estremi ae b, restituisce true se e solo se B rappresenta un albero binario di ricerca.Non consentito usare variabili globali.2. Calcolare il costo computazionale nel caso ottimo e nel caso pessimodell’algoritmo di cui al punto 1. Disegnare un esempio di albero che produceun caso pessimo, e un esempio di albero che produce il caso ottimo.Soluzione Innanzitutto è utile ricordare che in un ABR i valori delle chiavicontenute nel sottoalbero sinistro di un nodo v sono tutti minori o uguali av.key, mentre i valori delle chiavi contenute nel sottoalbero destro di v sonotutti maggiori o uguali di v.key.Una possibile soluzione è la seguentealgoritmo checkABR(nodo v, float a, float b) -> boolif ( v == null ) thenreturn true;elsereturn (a