1. COLLEZIONI E GENERICI
Talk 2

2. COLLEZIONI

3. LE COLLEZIONI SONO
STRUTTURE DATI
• Programmare non è più solo scrivere algoritmi ma permettere
a strutture dati diverse di interagire tra loro.
• Unastruttura dati è un modo di organizzare informazioni per
permetterne un uso efficiente (Wikipedia).

4. ORGANIZZARE
INFORMAZIONI
• Singnifica dare ai miei dati una struttura. Dipende da come sono fatti.
• Dipende da cosa devo farci!
• Insiemi lineari: per un accesso casuale a dati omogenei.
• Mappe: per creare associazioni tra chiavi e valori.
• Alberi: per gestire strutture ricorsive.
• Code: first-in, first-out.
• Stack: last-in, first-out.

5. STRUTTURE DATI NELLA VITA
VERA
• L’elenco del telefono è un dizionario.
• Il vocabolario è un dizionario.
• Gli indici delle Pagine Gialle formano un albero.
• Il cestone dei giochi è uno stack.
• Al semaforo c’è la coda.

6. COLLEZIONI
Insieme
Lista
Mappa
Stack
Queue

7. DIGRESSIONE: LA
NOTAZIONE O(...)
f(x) è O(g(x)) se esistono c > 0 e un x0 tali che
f(x) < c g(x) per x > x0
1000000n^2 + 1000000n + 1000 è O(n^2)

8. INSIEMI - SET
• Una collezione non ordinata di elementi omogenei.
• Non ha senso la ricerca per indice.
• Non contiene duplicati.
• Inserimenti e rimozioni lenti O(log n), ricerche veloci O(log n).

9. LISTE
• Collezione ordinata di elementi omogenei.
• Permette la ricerca per indice.
• Supporta elementi vuoti e duplicati.

10. LISTE BASATE SU ARRAY
• Aggiunte velocissime O(1) a meno che non sia necessario
ingrandire la lista (richiede la duplicazione dell’array).
• Inserimenti e rimozioni lentissimi (richiede la duplicazione
dell’array).
• Ricerche lentissime O(n).
• Ricerche per indice velocissime O(1).

11. LISTE CONCATENATE
• Aggiunte velocissime O(1) e costanti.
• Inserimenti e rimozioni lenti O(n).
• Ricerche lente O(n).
• Ricerche per indice lente O(n).

12. MAPPE
•È un insieme di coppie chiave-valore.
• Ricerca per chiave veloce O(log n).
• Ricerca per valore impossibile.
• Non permette chiavi vuote o duplicate.
• Permette valori vuoti o duplicati.

13. STACK
• Variante della lista.
• Realizza LIFO: push() e pop().
• Ambedue le operazioni sono O(1).

14. QUEUE
• Variante della lista.
• Realizza FIFO: add() e remove().
• Ambedue le operazioni sono O(1).

15. ABBIAMO VISTO
• Complessità computazionale.
• Varie collezioni.

16. GENERICI
Syntactic sugar

17. PROBLEMA
class List {!
public void add(Object obj) {!
...!
}!
public Object get(int index) {!
...!
}!
}!
!
//==============================!
List list = new List();!
list.add(new Pippo());!
!
Pippo pippo = list.get(0);
Pippo pippo = (Pippo) list.get(0);

18. IL PROBLEMA CRESCE
List list = new List();!
list.add(new Pippo());!
Pippo pippo = (Pippo) list.get(0);!
!
//===================================!
list.add(new Pluto());!
Pippo pippo = (Pippo) list.get(1);

19. SOLUZIONE
class List<T> {!
public void add(T obj) {!
...!
}!
public T get(int index) {!
...!
}!
}

20. SOLUZIONE
List<Pippo> list = new List<Pippo>();!
list.add(new Pippo());!
Pippo pippo = list.get(0);
list.add(new Pluto());
List<Pluto> list2 = new List<Pluto>();!
list2.add(new Pluto());!
Pluto pluto = list2.get(0);

21. ESERCIZIO
• Implementate una lista concatenata generica. Adesso.

22. DOMANDE?
Prossima puntata: Iterazione e ricorsione.
Stay tuned!