Roadmap. Ricorsione: funzioni ricorsive. Definizione di fattoriale. Definizione dei numeri Fibonacci

Transcript

1 Modulo di Roadmap 0. Primi passi con Java 1. Buone abitudini 2. Tipi di dati primitivi 3. Uso di classi 4. Leggere e scrivere 5. Definire metodi 7. Array e Collection 8. Progetto di classi 9. Ereditarietà 10. Eccezioni 11. Stream 12. Ricorsione 6. Strutture di controllo Ricorsione: funzioni ricorsive Definizione di fattoriale 0! = 1 n! = n(n - 1)! Definizione dei numeri Fibonacci Fib(0) = 0 Fib(1) = 1 Fib(n) = Fib(n-1) + Fib(n-2) Ricorsione 1

2 Modulo di Strutture dati ricorsive Una lista è: la lista vuota ( ) oppure un insieme costituito dal primo elemento della lista e da un altra lista (il resto della lista) Un albero è: un singolo nodo oppure l'insieme costituito da un singolo nodo e da altri alberi (sottoalberi di quel nodo) Gli alberi Nodo radice Figli del nodo radice X Figli del nodo X Nodi foglia Ricorsione 2

3 Modulo di Caratteristiche della ricorsione La definizione di un'entità contiene un riferimento all'entità stessa Tramite una regola finita è possibile definire un insieme infinito di oggetti Per essere corretta dal punto di vista logico,, la definizione ricorsiva deve presentare diverse alternative, tra le quali almeno una non deve contenere l'autoriferimento Vi sono entità "naturalmente" ricorsive,, per le quali risulta innaturale (o impossibile) immaginare una definizione non ricorsiva Roadmap 12. Ricorsione Metodi ricorsivi Ricorsione 3

4 Modulo di Metodi ricorsivi E' possibile definire metodi ricorsivi, cioè invocare, all'interno del corpo di un metodo,, lo stesso metodo Perchè la definizione ricorsiva sia corretta (e non dia luogo a cicli infiniti) ) è necessario che: sia presente una condizione di terminazione, cioè sia possibile un'esecuzione non ricorsiva del metodo ad ogni chiamata ricorsiva, si effettui un passo di ricorsione, cioè ci si avvicini alla condizione di terminazione Calcolo del fattoriale con ricorsione public static int factorial(int int n) if (n == 0) return 1; else int result = n * factorial(n - 1); return result; Ricorsione 4

5 Modulo di Calcolo del fattoriale con ricorsione factorial(5) * factorial(4) 24 4 * factorial(3) 6 3 * factorial(2) 2 2 * factorial(1) 1 1 * factorial(0) 1 Calcolo del fattoriale con iterazione public static int factorial (int n) if (n == 0) return 1; else int result = 1 for (int i = 2; i <= n; i++) result = result * i; return result; i result Ricorsione 5

6 Modulo di Calcolo Fibonacci ricorsivo public static int fibonacci(int int n) if (n <= 1) return n; else int result= fibonacci(n (n-1) + fibonacci(n (n-2); return result; Calcolo Fibonacci ricorsivo fib(5) fib(4) fib(3) fib(2) fib(3) fib(2) fib(1) fib(1) fib(0) fib(2) fib(1) fib(1) fib(0) fib(1) fib(0) Ricorsione 6

7 Modulo di Calcolo Fibonacci iterativo public static int fibonacci(int int n) if (n <= 1) return n; else int fib = 1; int fibmeno1 = 0; int temp; for (int( i = 1; i <= n - 1; i++) temp = fib; fib = fib + fibmeno1; fibmeno1 = temp; return fib; Calcolo Fibonacci iterativo i fib fibmeno1 temp int fib = 1; int fibmeno1 = 0; int temp; for (int( i = 1; i <= n - 1; i++) temp = fib; fib = fib + fibmeno1; fibmeno1 = temp; Ricorsione 7

8 Modulo di Roadmap 12. Ricorsione Metodi ricorsivi Ricorsione e iterazione Ricorsione e iterazione Ricorsione e iterazione rappresentano due scelte alternative per risolvere problemi che richiedano l'esecuzione ripetuta di certe operazioni I termini di confronto sono: la semplicità di codifica l'efficienza di esecuzione Il confronto va fatto caso per caso ma, in linea di massima: la ricorsione privilegia la semplicità di codifica l'iterazione privilegia l'efficienza di esecuzione Ricorsione 8

9 Modulo di Ricorsione e iterazione L'uso dell'iterazione è da preferire quando: la soluzione iterativa e ricorsiva sono paragonabili dal punto di vista della complessità l'occupazione di memoria generata dalla ricorsione viene evitata tramite la soluzione iterativa Ricorsione e iterazione L'uso della ricorsione è da preferire quando: la complessità della soluzione iterativa è decisamente superiore a quella della soluzione ricorsiva l'occupazione di memoria è necessaria alla soluzione del problema (ad ogni passo si deve tener traccia dello stato) ) e si verificherebbe anche nella soluzione iterativa Ricorsione 9

10 Modulo di Usa la testa, non le gambe! Per verificare la correttezza di una procedura ricorsiva non conviene cercare di ricostruire laboriosamente e macchinosamente la sua esecuzione da parte dell'elaboratore Bisogna invece verificare la correttezza logica della condizione di terminazione e del passo di ricorsione Roadmap 12. Ricorsione Metodi ricorsivi Ricorsione e iterazione Esempi Ricorsione 10

11 Modulo di Permutazioni (o anagrammi) Data una String di lunghezza arbitraria se ne vogliono generare tutte le permutazioni (che sono n!) P.e. data la parola cena avremo 24 permutazioni: cena cean cnea cnae caen cane ecna ecan enca enac eacn eanc ncea ncae neca neac nace naec acen acne aecn aenc ance anec Permutazioni: visione ricorsiva L insieme di permutazioni può essere visto come N insiemi (uno per ogni lettera della parola, in questo caso 4) Ognuno di questi insiemi può essere ottenuto fissando la lettera iniziale e calcolando le permutazioni delle lettere rimanenti Ricorsione 11

12 Modulo di Il metodo main import java.util util.*; public class Permutazioni final static private String MESSAGGIO = "Inserire la parola di cui calcolare le permutazioni:"; public static void main(string [] args) String inserita = MyUtil.leggiString leggistring(messaggio); Vector <String> > risultato = permutazioni(inserita); for (String permutazione : risultato) System.out.println println(permutazione); //... METODO PERMUTAZIONI Il metodo ricorsivo public static Vector<String String> > permutazioni(string dapermutare) Vector<String String> > prodotto = new Vector<String String>(); if (dapermutare.length() <= 1) prodotto.add add(dapermutare); else for (int i = 0; i < dapermutare.length length(); i++) char iniziale = dapermutare.charat charat(i); String unodimeno=dapermutare dapermutare.substring(0,i)+ dapermutare.substring substring(i+1); Caso base: se la stringa da permutare è vuota o contiene un solo carattere, l unica permutazione è la stringa stessa Vector<String String> subprodotto = permutazioni(unodimeno unodimeno); for (String subpermutazione : subprodotto) prodotto.add add(iniziale + subpermutazione); // for // else return prodotto; Si ritorna il risultato Scansione della stringa Si seleziona il carattere iniziale ed ottiene la stringa con i restanti caratteri Chiamata ricorsiva su stringa più corta Si unisce il carattere iniziale a ciascuna subpermutazione generata ricorsivamente e si aggiunge al Vector Ricorsione 12

13 Modulo di La torre di Hanoi Un labirinto Ricorsione 13