Strutture dati elementari

1
Strutture dati elementari

• Pile
• Code
• Liste concatenate
• Alberi medianti puntatori

2
Pile (Stacks)

• Cè una politica LIFO (last-in, first-out), ossia
  lelemento rimosso dalla pila è quello che è
  stato più recentemente inserito
• Operazioni
• PUSH(S,x) (inserisci)
• POP(S) (elimina,rimuovi)
• STACK-EMPTY(S) (controlla
• se è vuota)
• Una pila con al più n elementi può essere
  rappresentata da un vettore S1,, n. La
  variabile topS punto allultimo elemento
  inserito.

S
topS
6
5
4
3
2
1
3
Pile
PUSH(S,8)

• PUSH(S,x)
• if topSN
• then overflow
• else topS ? topS1
• StopS ? x

1
2
3
4
5
6
3
7
9
topS3
La pila consiste di topS elementi, ossia di un
vettore S1,, topS . N è il numero massimo di
elementi che la pila può contenere. S1
rappresenta lelemento alla base della pila,
mentre StopS è lelemento alla cima.
1
2
3
4
5
6
3
7
9
topS4
1
2
3
4
5
6
3
7
9
8
topS4
4
Pile
POP(S)

• POP(S,x)
• if STACK-EMPTY(S)
• then underflow
• else topS ? topS -1
• return StopS 1

1
2
3
4
5
6
3
7
9
8
topS4

• STACK-EMPTY(S)
• if topS 0
• then return TRUE
• else return FALSE

1
2
3
4
5
6
3
7
9
8
return 8
topS3
Se la pila è vuota viene generato un errore di
underflow. Se topS supera N, la pila va in
overflow. Tutte e tre le operazioni richiedono
tempo O(1).
5
Code (Queues)

• Cè una politica FIFO (first-in, first-out),
  ossia lelemento rimosso dalla coda è quello che
  è stato inserito da più tempo
• Operazioni
• ENQUEUE(S,x) (inserisci)
• DEQUEUE(S) (elimina,rimuovi)
• Una coda con al più n elementi può essere
  rappresentata da un vettore Q1,, n. Le
  variabili headQ e tailQ puntano
  rispettivamente alla testa della coda e alla
  posizione dove il nuovo elemento sarà inserito.

Q
3
4
5
6

headQ
tailQ
6
Code (Queues)
ENQUEUE(Q,5)

• ENQUEUE(Q,x)
• QtailQ ? x
• if tailQ lengthQ
• then tailQ ? 1
• else tailQ ? tailQ 1

1
2
3
4
5
6
7
8
9
10
3
9
6
8
headQ3
tailQ7
Inizialmente si avrà headQtailQ1. Quando
headQtailQ la coda è vuota. Un tentativo di
prendere un elemento dalla coda genererà una
situazione di underflow.
1
2
3
4
5
6
7
8
9
10
3
9
6
8
5
tailQ8
headQ3
Quando headQtailQ1 la coda è piena. Un
tentativo di inserire un elemento dalla coda
genererà una situazione di overflow.
7
Code (Queues)
DEQUEUE(Q,5)

• DEQUEUE(Q)
• x ? QheadQ
• if headQ lengthQ
• then headQ ? 1
• else headQ ? headQ 1
• return x

1
2
3
4
5
6
7
8
9
10
3
9
6
8
5
headQ3
tailQ8
1
2
3
4
5
6
7
8
9
10
3
9
6
8
5
return 3
tailQ8
headQ4
I casi di underflow e di overflow non sono
trattati nel pseudo-codice. Le operazioni ENQUEUE
e DEQUEUE richiedono tempo O(1).
8
Liste concatenate
key
headL
4
12
8
-
9
-
prev
next

• Le liste concatenate consistono in un insieme di
  elementi disposti luno di seguito allaltro.
• Diversamente dai vettori (anche detti array) gli
  elementi non sono indicizzati, ma legati tra loro
  linearmente attraverso dei puntatori.
• I puntatori allinterno di un elemento x possono
  puntare allelemento successivo (nextx) o a
  quello successivo (prevx).
• Le liste concatenate sono una struttura di dati
  semplice e flessibile, soprattutto se si devono
  rappresentare un insieme di elementi
  dinamicamente variabile.

9
Doubly linked list
NIL
NIL
key
headL
4
12
8
-
9
-
prev
next

• Un Doubly linked list è anche detto lista
  concatenata bidirezionale.
• Ogni elemento x ha una chiave (keyx), un
  puntatore allelemento successivo (nextx) e un
  puntatore allelemento precedente (prevx).
• headL punta al primo elemento della lista L.
  Questo primo elemento ha prevxNIL, quindi non
  ha un elemento che lo precede.
• Lultimo elemento ha nextxNIL, quindi non ha
  un successore.
• Quando headLNIL si è in presenza di una lista
  vuota.

10
Doubly linked list
NIL
NIL
key
headL
4
12
8
-
9
-
prev
next

• Operazioni
• LIST-SEARCH(L,k)
• Cerca il primo elemento con chiave k nella
  lista L.
• LIST-INSERT(L,x)
• Inserisci un elemento x con chiave keyx
  nella lista L.
• LIST-DELETE(L,x)
• Elimina lelemento x con chiave keyx e
  puntatori (prevx, nextx) nella lista L.

11
Doubly linked list
Per una lista di n elementi richiede tempo T(n)
nel caso peggiore, poiché si deve scorrere
lintera lista.

• LIST-SEARCH(L,k)
• x ? headL
• while x ? NIL and keyx ? k
• do x ? nextx
• return x

LIST-SEARCH(L,12)
headL
4
12
8
-
9
-
x
keyx9
headL
4
12
8
-
9
-
x
keyx4
headL
4
12
8
-
9
-
x
keyx12 TROVATO!
12
Doubly linked list
Per una lista di n elementi richiede tempo O(1),
poiché richiede un numero costante di passi.

• LIST-INSERT(L,x)
• nextx ? headL
• if headL ? NIL
• then prevheadL ? x
• headL ? x
• prevx ? NIL

LIST-INSERT(L,x) keyx 5
4
9
-
headL
8
-
5
x
4
9
headL
5
8
-
x
4
9
headL
5
-
8
-
x
13
Doubly linked list
Per una lista di n elementi richiede tempo O(1),
poiché richiede un numero costante di passi. Non
comprende la ricerca dellelemento da rimuovere.

• LIST-DELETE(L,x)
• if prevx ? NIL
• then nextprevx ? nextx
• else headL ? nextx
• if nextx ? NIL
• then prevnextx ? prevx

LIST-DELETE(L,x) keyx 9
4
9
headL
5
-
8
-
x
4
9
headL
5
-
8
-
x
4
headL
5
-
8
-
14
Luso di una sentinella
nilL
4
5
8
nilL

• La sentinella è un oggetto che aiuta a
  semplificare le condizioni di confine della
  lista.
• Consiste di un oggetto nullo (nilL) che punta
  allinizio e alla fine della lista e viene
  puntato a sua volta dal primo e dallultimo
  elemento della lista.
• Quando nilL punta e viene punato solo da se
  stesso la lista L è vuota.

15
Luso di una sentinella

• Le operazioni con la presenza della sentinella

• LIST-DELETE(L,x)
• nextprevx ? nextx
• prevnextx ? prevx

• LIST-INSERT(L,x)
• nextx ? nextnilL
• prevnextnilL ? x
• nextnilL ? x
• prevx ? nilL

Il codice risulta più compatto. nextnilL
prende il posto di headL.

• LIST-SEARCH(L,k)
• x ? nextnilL
• while x ? nilL and keyx ? k
• do x ? nextx
• return x

16
Luso di una sentinella

• Luso della sentinella rende il codice più
  compatto e semplice.
• Non rende il codice più efficiente, anche se può
  ridurre il tempo di esecuzione di qualche
  costante.
• Luso della sentinella può dare un significativo
  incremento delluso della memoria, soprattutto se
  si usano molte liste. Questo è dovuto alluso di
  elemento in più per ogni lista.

17
Liste concatenate
key
4
12
8
-
9
headL
next

• Ci possono essere anche liste unidirezionali che
  usano un solo link (o puntatore). Si chiamano
  Singly Linked Lists.
• Le Singly Link Lists rendono la procedura di
  rimozione di un elemento pari a T(n) nel caso
  peggiore, perché deve essere individuato
  lelemento precedente.
• Si possono costruire anche liste circolari da una
  Doubly Linked Lists, quando il primo elemento
  della testa punta allultimo e viceversa.

5
headL
4
8
18
Rappresentazione di alberi binari

• Un albero binario è un albero dove ogni nodo può
  avere al massimo due figli.
• Si usano i campi px, leftx e rightx per
  puntare rispettivamente al padre e ai due figli
  del nodo x. Se un figlio non esiste, allora il
  valore del puntatore è nil.
• rootT punta alla radice dellalbero, che ha
  pxnil. Se rootTnil, allora lalbero è vuoto.

px
leftx
rightx
19
Rappresentazione di alberi binari
Ecco un esempio. Le foglie sono i nodi senza
figli, ossia leftxrightxnil.
rootT
-
-
-
-
-
-
-
-
-
20
Rappresentazione di alberi

• Una possibile rappresentazione
• leftx punta al figlio più a sinistra
• rightx punta al fratello alla sua destra, se
  esiste.

rootT
-
-
-
-
-
-
-
-
-
-
-
-