1 / 20

Strutture dati elementari

Strutture dati elementari. Pile Code Liste concatenate Alberi medianti puntatori. Pile (Stacks). C’è una politica LIFO (last-in, first-out), ossia l’elemento rimosso dalla pila è quello che è stato più recentemente inserito Operazioni: PUSH(S,x) ( inserisci ) POP(S) ( elimina,rimuovi )

kyrene
Download Presentation

Strutture dati elementari

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Strutture dati elementari Pile Code Liste concatenate Alberi medianti puntatori

  2. Pile (Stacks) • C’è una politica LIFO (last-in, first-out), ossia l’elemento 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 S[1,…, n]. La variabile top[S] punto all’ultimo elemento inserito. S … top[S] 6 5 4 3 2 1

  3. Pile PUSH(S,8) PUSH(S,x) • if top[S]=N • then “overflow” • elsetop[S] ← top[S]+1 • S[top[S]]← x 1 2 3 4 5 6 3 7 9 top[S]=3 La pila consiste di top[S] elementi, ossia di un vettore S[1,…, top[S] ]. N è il numero massimo di elementi che la pila può contenere. S[1] rappresenta l’elemento alla base della pila, mentre S[top[S] ] è l’elemento alla cima. 1 2 3 4 5 6 3 7 9 top[S]=4 1 2 3 4 5 6 3 7 9 8 top[S]=4

  4. Pile POP(S) POP(S,x) • if STACK-EMPTY(S) • then “underflow” • else top[S] ← top[S] -1 • return S[top[S] + 1] 1 2 3 4 5 6 3 7 9 8 top[S]=4 STACK-EMPTY(S) • if top[S] = 0 • thenreturn TRUE • elsereturn FALSE 1 2 3 4 5 6 3 7 9 8 return 8 top[S]=3 Se la pila è vuota viene generato un errore di “underflow”. Se top[S] 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 l’elemento 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 Q[1,…, n]. Le variabili head[Q] e tail[Q] puntano rispettivamente alla testa della coda e alla posizione dove il nuovo elemento sarà inserito. Q 3 4 5 6 … head[Q] tail[Q]

  6. Code (Queues) ENQUEUE(Q,5) ENQUEUE(Q,x) • Q[tail[Q]] ← x • if tail[Q] = length[Q] • then tail[Q] ← 1 • elsetail[Q] ← tail[Q] + 1 1 2 3 4 5 6 7 8 9 10 3 9 6 8 head[Q]=3 tail[Q]=7 Inizialmente si avrà head[Q]=tail[Q]=1. Quando head[Q]=tail[Q] 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 head[Q]=3 tail[Q]=8 Quando head[Q]=tail[Q]+1 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 ← Q[head[Q]] • if head[Q] = length[Q] • then head[Q] ← 1 • else head[Q] ← head[Q] + 1 • return x 1 2 3 4 5 6 7 8 9 10 3 9 6 8 5 head[Q]=3 tail[Q]=8 1 2 3 4 5 6 7 8 9 10 3 9 6 8 5 return 3 head[Q]=4 tail[Q]=8 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 head[L] - 9 4 8 - 12 • Le liste concatenate consistono in un insieme di elementi disposti l’uno di seguito all’altro. • Diversamente dai vettori (anche detti array) gli elementi non sono indicizzati, ma legati tra loro linearmente attraverso dei puntatori. • I puntatori all’interno di un elemento x possono puntare all’elemento successivo (next[x]) o a quello successivo (prev[x]). • Le liste concatenate sono una struttura di dati semplice e flessibile, soprattutto se si devono rappresentare un insieme di elementi dinamicamente variabile. prev next

  9. Doubly linked list NIL NIL key head[L] - 9 4 8 - 12 • Un Doubly linked list è anche detto lista concatenata bidirezionale. • Ogni elemento x ha una chiave (key[x]), un puntatore all’elemento successivo (next[x]) e un puntatore all’elemento precedente (prev[x]). • head[L] punta al primo elemento della lista L. Questo primo elemento ha prev[x]=NIL, quindi non ha un elemento che lo precede. • L’ultimo elemento ha next[x]=NIL, quindi non ha un successore. • Quando head[L]=NIL si è in presenza di una lista vuota. prev next

  10. Doubly linked list NIL NIL key head[L] - 9 4 8 - 12 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 key[x] nella lista L. • LIST-DELETE(L,x) Elimina l’elemento x con chiave key[x] e puntatori (prev[x], next[x]) nella lista L. prev next

  11. Doubly linked list Per una lista di n elementi richiede tempo Θ(n) nel caso peggiore, poiché si deve scorrere l’intera lista. LIST-SEARCH(L,k) • x ← head[L] • while x ≠ NIL and key[x] ≠ k • do x ← next[x] • return x LIST-SEARCH(L,12) head[L] - 9 4 8 - 12 x key[x]=9 head[L] - 9 4 8 - 12 x key[x]=4 head[L] - 9 4 8 - 12 x key[x]=12 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) • next[x] ← head[L] • if head[L] ≠ NIL • then prev[head[L]] ← x • head[L] ← x • prev[x] ← NIL LIST-INSERT(L,x) key[x] = 5 head[L] 8 - - 9 4 x 5 head[L] 5 9 4 8 - x head[L] 5 9 4 - 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 dell’elemento da rimuovere. LIST-DELETE(L,x) • if prev[x] ≠ NIL • then next[prev[x]] ← next[x] • else head[L] ← next[x] • if next[x] ≠ NIL • then prev[next[x]] ← prev[x] LIST-DELETE(L,x) key[x] = 9 head[L] 5 9 4 - 8 - x head[L] 5 9 4 - 8 - x head[L] 5 4 - 8 -

  14. L’uso di una sentinella • La sentinella è un oggetto che aiuta a semplificare le condizioni di confine della lista. • Consiste di un oggetto nullo (nil[L]) che punta all’inizio e alla fine della lista e viene puntato a sua volta dal primo e dall’ultimo elemento della lista. • Quando nil[L] punta e viene punato solo da se stesso la lista L è vuota. nil[L] 5 4 8 nil[L]

  15. L’uso di una sentinella Le operazioni con la presenza della sentinella: LIST-DELETE’(L,x) • next[prev[x]] ← next[x] • prev[next[x]] ← prev[x] LIST-INSERT’(L,x) • next[x] ← next[nil[L]] • prev[next[nil[L]]] ← x • next[nil[L]] ← x • prev[x] ← nil[L] Il codice risulta più compatto. next[nil[L]] prende il posto di head[L]. LIST-SEARCH’(L,k) • x ← next[nil[L]] • while x ≠ nil[L] and key[x] ≠ k • do x ← next[x] • return x

  16. L’uso di una sentinella • L’uso 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. • L’uso della sentinella può dare un significativo incremento dell’uso della memoria, soprattutto se si usano molte liste. Questo è dovuto all’uso di elemento in più per ogni lista.

  17. Liste concatenate key head[L] 9 4 8 - 12 • 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 Θ(n) nel caso peggiore, perché deve essere individuato l’elemento precedente. • Si possono costruire anche liste circolari da una Doubly Linked Lists, quando il primo elemento della testa punta all’ultimo e viceversa. next head[L] 5 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 p[x], left[x] e right[x] per puntare rispettivamente al padre e ai due figli del nodo x. Se un figlio non esiste, allora il valore del puntatore è nil. root[T] punta alla radice dell’albero, che ha p[x]=nil. Se root[T]=nil, allora l’albero è vuoto. p[x] left[x] right[x]

  19. Rappresentazione di alberi binari Ecco un esempio. Le foglie sono i nodi senza figli, ossia left[x]=right[x]=nil. root[T] - - - - - - - - -

  20. Rappresentazione di alberi • Una possibile rappresentazione: • left[x] punta al figlio più a sinistra • right[x] punta al fratello alla sua destra, se esiste. root[T] - - - - - - - - - - - -

More Related