Esercizi su programmazione ricorsiva 1. Pericle Perazzo 23 marzo 2012

Transcript

1 su programmazione ricorsiva 1 Pericle Perazzo pericle.perazzo@iet.unipi.it 23 marzo 2012

2 Ripasso di programmazione ricorsiva Ripasso di programmazione ricorsiva Algoritmo ricorsivo: algoritmo espresso in termini di se stesso. Programmazione iterativa e programmazione ricorsiva sono equivalenti. Vantaggi/svantaggi rispetto a programmazione iterativa: meno efficiente più semplice ed elegante per risolvere alcuni problemi Condizioni necessarie per la correttezza: presenza di uno o più casi base convergenza verso i casi base

3 Relazioni di ricorrenza lineari Ripasso di programmazione ricorsiva T 0 = a T n = bn k T n 1 con n 0 T n O n k 1

4 o 1 Scrivere una funzione ricorsiva che controlla se una stringa è palindroma (ovvero se rigirandola non cambia, es. ossesso è palindroma). Esempi di frasi palindrome: I verbi brevi ( iverbibrevi ) Aceto nell'enoteca ( acetonellenoteca ) I topi non avevano nipoti ( itopinonavevanonipoti )

5 o 1 Soluzione Definizione ricorsiva di palindromicità: Una stringa nulla è palindroma. Esempio:. Una stringa di un carattere è palindroma. Esempio: a. Una stringa tale che il primo e l'ultimo carattere sono uguali e la sottostringa nel mezzo è palindroma, è palindroma. Esempio: ossesso.

6 o 1 Soluzione bool palindroma(const string& s, int start, int len) { if (len <= 1) return true; if (s[start]==s[start+len-1] && palindroma(s, start+1, len-2)) return true; else return false; } T 0 =T 1 = a T n = b T n 2 T n O n

7 Strumenti per l'esercitazione BaseList<T> IntList

8 Classe IntList IntList realizza un semplice lista di interi ( IntList.h, IntList.cpp ). Ogni elemento è rappresentato da una struttura Elem, che contiene: L'etichetta (int info), Il puntatore all'elemento successivo (Elem* next) All'interno della classe è definito il puntatore all'elemento di testa (Elem* head).

9 Classe IntList Per fare debugging, sono definiti gli operatori put to (<<) e get from (>>). È possibile usarli per immettere una lista da tastiera e stamparla a video. IntList mia_lista; cin >> mia_lista; // acquisisce da tastiera // nel formato: [1,3,12,0,2] // (vengono ignorati gli spazi) /* Elaborazioni varie... */ cout << mia_lista; // stampa a video // nel formato: [1,3,12,0,2]

10 Classe IntList Per programmare in modo ricorsivo su classi conviene operare nel seguente modo: 1. Risolvere l'esercizio con una funzione private (es. _esercizio). 2. Per fare ricorsione, dichiararla static, e che prenda come argomento il puntatore di testa (Elem* head). 3. Per fare debugging, definire una funzione public (es. esercizio) che non fa altro che richiamare la funzione private con argomento il puntatore di testa. Chiamare tale funzione dal main.

11 Classe IntList IntList.h : class IntList{ private: static void _esercizio(elem* l); public: void esercizio(){_esercizio(head);} }; IntList.cpp : void IntList::_esercizio(Elem* l){ //... _esercizio(l->next); //... }

12 o 2 Aggiungere a IntList una funzione ricorsiva che somma ad ogni elemento tutti i successivi. Esempio la lista: deve diventare:

13 o 2 Soluzione int IntList::_esercizio2(Elem* head){ if (head == NULL) return 0; head->info += _esercizio2(head->next); return head->info; } T 0 = a T n = b T n 1 T n O n

14 o 3 Aggiungere a IntList una funzione ricorsiva che rimuove dalla lista tutti i doppioni. Esempio la lista: deve diventare: Suggerimento: sviluppare una funzione di appoggio deleteall(elem*& l, int x) che cancella tutti gli elementi di etichetta x dalla lista l.

15 o 3 Soluzione void IntList::deleteAll(Elem*& head, int x){ if (head == NULL) return; if (head->info == x){ // cancello l'elemento di testa: Elem* a = head; head = head->next; delete a; deleteall(head, x); } else // non lo cancello: deleteall(head->next, x); } void IntList::_esercizio3(Elem* head){ if (head == NULL) return; deleteall(head->next, head->info); _esercizio3(head->next); }

16 o 3 Soluzione T 0 = a T n = bn T n 1 T n O n 2 Per ottenere una complessità minore bisogna ricorrere a tecniche di ordinamento

17 o 4 Aggiungere a IntList una funzione ricorsiva che conta le vette, cioè gli elementi che sono maggiori di tutti i successivi. Esempi: vette = vette = 3 Si suppone che tutte le etichette siano positive.

18 o 4 Soluzione int IntList::max(const Elem* head){ if (head == NULL) return 0; int maxsucc = max(head->next); if (head->info > maxsucc) // l'elemento di testa e' il massimo: return head->info; else // l'elemento di testa NON e' il massimo: return maxsucc; } int IntList::_esercizio4(const Elem* head){ if (head == NULL) return 0; int maxsucc = max(head->next); if (head->info > maxsucc) // l'elemento di testa e' una vetta return 1 + _esercizio4(head->next); else // l'elemento di testa non e' una vetta return _esercizio4(head->next); }

19 o 4 Soluzione T 0 = a T n = bn T n 1 T n O n 2

20 o 4 Soluzione alternativa int IntList::_esercizio4b(const Elem* head, int& max){ if (head == NULL){ max = 0; return 0; } int countpeakssucc; countpeakssucc = _esercizio4b(head->next, max); if (head->info > max){ // l'elemento di testa e' una vetta: max = head->info; return 1 + countpeakssucc; } else return countpeakssucc; } T 0 = a T n = b T n 1 T n O n