Slide del corso di Algoritmi e Calcolo Parallelo per il corso di laurea magistrale in Ingegneria Matematica 2012/2013 - Politecnico di Milano

1. Strutture Dati Elementari
Algoritmi e Calcolo Parallelo
Prof. Pier Luca Lanzi

2. Riferimenti
•
•
2
Bertossi Alan A., Montresor Alberto. “Algoritmi e
strutture di dati” (seconda edizione), CittàStudi 2010
Stanley B. Lippman, Barbara E. Moo, Josee Lajoie
“C++ Primer”, 5th Edition Addison-Wesley
Prof. Pier Luca Lanzi

3. Tipo di Dato Astratto
•
•
•
3
Dato
In un linguaggio di programmazione, un dato è un
valore che una variabile può assumere

Tipo di dato astratto
Un modello matematico, dato da una collezione di
valori e un insieme di operazioni ammesse su questi
valori

Tipi di dati primitivi
Forniti direttamente dal linguaggio
Esempi: int (+,-,*,/, %), boolean (!, &&, ||)


Prof. Pier Luca Lanzi

4. Liste
•
4
Liste (List, Linked List)
Una sequenza di nodi, contenenti dati arbitrari e 1-2
puntatori all'elemento successivo e/o precedente
La contiguità nella lista non implica la contiguità in
memoria


•
•
Costo operazioni
Tutte le operazioni hanno costo O(1)

Realizzazione possibili
Bidirezionale/Monodirezionale
Con sentinella/Senza sentinella
Circolare /Non circolare



Prof. Pier Luca Lanzi

5. Esempi di Linked Liste
Prof. Pier Luca Lanzi
5

6. Liste puntate (Linked List)
•
6
Sequenza di nodi, contenenti dati (qualsiasi) arbitrari e 1-2 reference
(puntatori, link) all'elemento successivo e/o precedente
•
Liste puntate semplici
•
Liste puntate doppie
•
Liste circolari
Prof. Pier Luca Lanzi

7. Liste Puntate Semplici (Linked List)
Prof. Pier Luca Lanzi
7

8. Liste Puntate Semplici (Linked List)
Inserimento
8
Cancellazione
Prof. Pier Luca Lanzi

9. Liste Puntate Semplici e Doppie
(Linked List)
Ricerca
9
Inserimento in testa
LIST-SEARCH(L, k)
1 x ← head[L]
2 while (x ≠ NIL
&& key[x] ≠ k)
3
do x ← next[x]
4 return x
Prof. Pier Luca Lanzi
LIST-INSERT(L, x)
1 next[x] ← head[L]
2 if head[L] ≠ NIL
3
prev[head[L]] ← x
4 head[L] ← x
5 prev[x] ← NIL

10. List - Circolare, Bidirezionale,
con Sentinella
Prof. Pier Luca Lanzi
10

11. Liste nella STL C++
•
•
Sono implementate come liste bidirezionali
Vantaggi
Inserimento e cancellazione di un elemento sono efficienti (Θ(1))
Spostamento di elementi nella stessa lista o fra liste è efficiente
(Θ(1))
L‟iterazione sugli elementi della lista nelle due direzioni è efficiente
(Θ(n))
Svantaggi
Non permettono l‟accesso diretto agli elementi della struttura (e.g.
A[i])
Ad esempio, per accedere all‟elemento i di una lista bisogna
scorrerla dall‟inizio fino all‟elemento cercato (Θ(n))
Richiedono la memorizzazione dei collegamenti fra elementi
(maggiore memoria rispetto ai vettori)
Riferimenti
http://www.cplusplus.com/reference/stl/list/



•



•
11

Prof. Pier Luca Lanzi

12. Liste nella STL C++
•
Iteratori: begin(), end(), rbegin(), rend()
•
Capacità: empty, size, max_size, resize
•
12
Accesso agli elementi: front, back
•
•
Modificatori: push_front, pop_front, push_back, pop_back, insert,
erase, swap, clear
Operazioni: splice, remove, remove_if, unique, merge, sort, reverse
Prof. Pier Luca Lanzi

13. Liste – Implementazione con Vettori
•
•
•
13
E‟ possibile realizzare una lista con vettori
La posizione equivale all‟indice nel vettore
Le operazioni insert e remove hanno costo O(n)
Tutte le altre operazioni hanno costo O(1)



Problema
Spesso non si conosce a priori quanta memoria serve per memorizzare la
lista
Se ne alloca una certa quantità, per poi accorgersi che non è sufficiente.
Soluzione
Si alloca un vettore di dimensione maggiore, si ricopia il contenuto del
vecchio vettore nel nuovo e si rilascia il vecchio vettore



Prof. Pier Luca Lanzi

14. Liste – Implementazione con Vettori
(Espansione/Contrazione)
•
•
14
Espansione (due approcci)
Raddoppiare la capienza del vettore
Incrementare il vettore di un fattore costante


Contrazione
E‟ opportuno contrarre il vettore quando il fattore di
carico α = size/capacity diventa troppo piccolo
size è il numero di elementi attualmente presenti
capacity è la dimensione del vettore
L‟operazione richiede l‟allocazione, la copia, e la deallocazione




Prof. Pier Luca Lanzi

15. Pile/Stack
•
•
•
20
Insieme dinamico in cui l‟elemento rimosso
dall‟operazione di cancellazione è predeterminato:
“quello che per meno tempo è rimasto nell‟insieme”
Politica “last in, first out” (LIFO)
Operazioni previste (tutte realizzabili in O(1))
Prof. Pier Luca Lanzi

16. Stack (o Pila)
•
•
21
Una pila o stack è un insieme dinamico in cui l‟elemento rimosso
dall‟operazione di cancellazione è predeterminato: “quello che per
meno tempo è rimasto nell‟insieme” politica “last in, first out” (LIFO)
Operazioni previste
void push(Item)
Item pop()


 Item top()
 boolean isEmpty()
// inserisce un elemento
// rimuove l„elemento
// in cima
// legge l‟item in cima
// non rimuove l'item
// true se la pila è vuota
Prof. Pier Luca Lanzi

17. Applicazione e Implementazione
•
Possibili utilizzi
Nei linguaggi con procedure:
gestione dei record di attivazione
Nei linguaggi stack-oriented: le
operazioni elementari prendono
uno-due operandi dallo stack e
inseriscono il risultato nello stack
Notazione RPN: 3 4 + 7 -



•
Possibili implementazioni
Tramite liste bidirezionali
(puntatore all'elemento top)
Tramite vettore
(dimensione limitata, overhead più basso)


Prof. Pier Luca Lanzi
22
top

18. Stack (Pseudocodice)
Prof. Pier Luca Lanzi
23

19. Stack nella STL C++
•
•
Funzioni
empty
size
top
push
Pop





Esempi
http://ideone.com/QUyf6
https://ideone.com/zh4ho


Prof. Pier Luca Lanzi
24

20. Code/Queue
•
25
Insieme dinamico in cui l‟elemento rimosso
dall‟operazione di cancellazione è predeterminato:
“quello che per più tempo è rimasto nell‟insieme”
•
Politica di gestione “first in, first out” (FIFO)
•
Operazione previste O(1)
Prof. Pier Luca Lanzi

21. Code/Queue
•
26
Applicazioni
Nei sistemi operativi, i processi in attesa di utilizzare
una risorsa vengono gestiti tramite una coda FIFO
Visita dei grafi


•
Implementazioni
Liste monodirezionali: puntatore head (inizio della
coda), per estrazione; puntatore tail (fine della coda),
per inserimento
Array circolari: dimensione limitata, overhead più basso


Prof. Pier Luca Lanzi

22. Coda/Queue – Implementazione con
Vettori Circolari
•
•
27
La “finestra” dell‟array occupata
dalla coda si sposta lungo l‟array!
3
6
Dettagli implementativi
head
L'array circolare può
essere implementato
con un'operazione di
head
modulo
Bisogna prestare attenzione
ai problemi di overflow
(buffer pieno)
head+n
54
43


Prof. Pier Luca Lanzi
6
3
54
43
head+
n

23. Coda/Queue – Implementazione con
Vettori Circolari
head+n
3
6
54
3
6
54
6
33
54
enqueue(12)
43 12
head+n
head
head+n
43
head+n
head
28
dequeue() → 3
43 12
head
enqueue (15, 17, 33)
6
54
43 12 15 17
head
Prof. Pier Luca Lanzi

24. Coda/Queue - Pseudocodice
Prof. Pier Luca Lanzi
29

25. Code/Queue nella STL C++
•
•
30
Funzioni
empty
size
front: accesso al prossimo elemento della coda
back: accesso all‟ultimo elemento
push: inserisce un elemento in coda
pop: cancella il prossimo elemento






Costuttore
template < class T, class Container = deque<T> > class
queue;
Prof. Pier Luca Lanzi