Catena (linked list) Catena. Catena vuota. Nodo di una catena. Catena. Fondamenti di Informatica 1 Settimana 7. Marcello Dalpasso 1

Transcript

1 atena (linked list) atena (linked list) La catena o lista concatenata (linked list) non è un nuovo DT, ma è una struttura dati alternativa all array per la realizzazione di DT Una catena è un insieme ordinato di nodi ogni nodo è un oggetto che contiene un riferimento ad un elemento (il ) un riferimento al nodo successivo nella catena () 1 2 atena atena vuota header Per agire sulla catena è sufficiente memorizzare il riferimento al suo primo nodo è comodo avere anche un riferimento all ultimo nodo Il campo dell ultimo nodo contiene Vedremo che è comodo avere un primo nodo senza dati, chiamato header 3 header Per capire bene il funzionamento della catena, è necessario avere ben chiara la rappresentazione della catena vuota contiene il solo nodo header, che ha in entrambi i suoi campi head e tail puntano entrambi a tale header 4 atena header Per accedere in sequenza a tutti i nodi della catena si parte dal riferimento inizio e si seguono i riferimenti contenuti nel campo di ciascun nodo non è possibile scorrere la lista in senso inverso la scansione termina quando si trova il nodo con il valore nel campo 5 Nodo di una catena public class ListNode { private Object element; private ListNode ; //stranezza public ListNode(Object e, ListNode n) { element = e; = n; public ListNode() { this(, ); // novità public Object getelement() { return element; public ListNode getnext() { return ; public void setelement(object e) { element = e; public void setnext(listnode n) { = n; 6 Marcello Dalpasso 1

2 uto-riferimento public class ListNode private ListNode ; //stranezza Nella definizione della classe ListNode notiamo una stranezza la classe definisce e usa riferimenti ad oggetti del tipo che sta definendo iò è perfettamente lecito e si usa molto spesso quando si rappresentano strutture a definizione ricorsiva come la catena 7 Invocare un costruttore da un altro costruttore La classe ListNode ha due costruttori il primo crea un nuovo nodo con lo stato assegnato dai parametri ricevuti il secondo crea un nuovo nodo con entrambe le variabili di stato inizializzate a, cioè è un caso particolare del primo! public class ListNode public ListNode(Object e, ListNode n) { element = e; = n; public ListNode() { element = ; = ; 8 Invocare un costruttore da un altro costruttore Questo accade spesso se ci sono più costruttori un costruttore viene utilizzato per costruire oggetti il cui stato iniziale può essere considerato come un caso particolare di quello inizializzato da un altro costruttore È bene invocare il costruttore più generale dal costruttore che ne costituisce un caso particolare come al solito, per evitare di copiare codice public class ListNode public ListNode(Object e, ListNode n) { element = e; = n; public ListNode() { this(, ); 9 Invocare un costruttore da un altro costruttore public class ListNode public ListNode(Object e, ListNode n) { element = e; = n; public ListNode() { this(, ); Per farlo si usa la parola chiave this seguita da una coppia di parentesi tonde che racchiudono i parametri da fornire all altro costruttore che si vuole invocare (come se si invocasse un metodo) Questo si può fare solo all interno di un costruttore e deve essere il suo primo enunciato sintassi simile a super( ) 10 Invocare un costruttore da un altro costruttore Vantaggio: non si devono ripetere gli enunciati di inizializzazione, che possono essere molti Vantaggio: il codice è molto più comprensibile! ttenzione: non confondere this( ) con this usato come riferimento al parametro implicito ttenzione: non avrebbe senso invocare l altro costruttore con new (avremmo due oggetti ) atena I metodi utili per una catena sono addfirst per inserire un oggetto all inizio della catena addlast per inserire un oggetto alla fine della catena removefirst per eliminare il primo oggetto della catena removelast per eliminare l ultimo oggetto della catena Spesso si aggiungono anche i metodi getfirst per esaminare il primo oggetto getlast per esaminare l ultimo oggetto public class ListNode public ListNode(Object e, ListNode n) { element = e; = n; Si osservi che non vengono mai restituiti né public ListNode() // SGLITO { new ListNode(, ); ricevuti riferimenti ai nodi, ma sempre ai dati 11 contenuti nei nodi 12 Marcello Dalpasso 2

3 atena Infine, che anche la catena è un contenitore, ci sono i metodi isempty per sapere se la catena è vuota makeempty per rendere vuota la catena Si definisce l eccezione EmptyLinkedListException Si noti che, non essendo la catena un DT, non viene definita un interfaccia la catena non è un DT perché nella sua definizione abbiamo esplicitamente indicato OME la struttura dati deve essere realizzata, e non semplicemente il suo comportamento 13 atena public class LinkedList implements ontainer { private ListNode head, tail; public LinkedList() { makeempty(); public void makeempty() { head = tail = new ListNode(); public boolean isempty() { return (head == tail); public Object getfirst() // operazione O(1) { if (isempty()) throw new EmptyLinkedListException(); return head.getnext().getelement(); public Object getlast() // operazione O(1) { if (isempty()) throw new EmptyLinkedListException(); return tail.getelement(); Intervallo addfirst nuovo nodo addfirst public void addfirst(object e) { // inserisco il nell header attuale head.setelement(e); // creo un nuovo nodo con due riferimenti ListNode n = new ListNode(); // collego il nuovo nodo all header attuale n.setnext(head); // il nuovo nodo diventa l header della catena head = n; // tail non viene modificato Non esiste il problema di catena piena L operazione è O(1) 17 addfirst Verifichiamo che tutto sia corretto anche inserendo in una catena vuota Fare sempre attenzione ai casi limite nuovo nodo 18 Marcello Dalpasso 3

4 addfirst public void addfirst(object e) { head.setelement(e); ListNode n = new ListNode(); n.setnext(head); head = n; Il codice di questo metodo si può esprimere anche in modo più conciso public void addfirst(object e) { head.setelement(e); // funziona perché prima head viene USTO // (a destra) e solo successivamente viene // MODIFITO (a sinistra) head = new ListNode(, head); È più professionale, anche se meno leggibile 19 removefirst nodo da eliminare Il nodo viene eliminato dal garbage collector 20 removefirst public Object removefirst() { // delega a getfirst il // controllo di lista vuota Object e = getfirst(); // aggiorno l header head = head.getnext(); head.setelement(); return e; L operazione è O(1) removefirst Verifichiamo che tutto sia corretto anche eliminando da una catena vuota Fare sempre attenzione ai casi limite addlast nuovo nodo 23 addlast public void addlast(object e) { tail.setnext(new ListNode(e, )); tail = tail.getnext(); Non esiste il problema di catena piena nche questa operazione è O(1) 24 Marcello Dalpasso 4

5 addlast Verifichiamo che tutto sia corretto anche inserendo in una catena vuota Fare sempre attenzione ai casi limite 25 removelast spostamento complesso nodo da eliminare 26 removelast public Object removelast() { Object e = getlast(); // bisogna cercare il penultimo nodo // partendo dall inizio ed andando avanti // finché non si arriva alla fine della catena ListNode temp = head; while (temp.getnext()!= tail) temp = temp.getnext(); // a questo punto temp si riferisce al // penultimo nodo tail = temp; tail.setnext(); return e; Purtroppo questa operazione è O(n) 27 removelast Verifichiamo che tutto sia corretto anche eliminando da una catena vuota Fare sempre attenzione ai casi limite nodo da eliminare 28 Header della catena La presenza del nodo header nella catena rende più semplici i metodi della catena stessa non bisogna gestire i casi limite in modo diverso dalle situazioni ordinarie Senza usare il nodo header, le prestazioni asintotiche rimangono comunque le stesse Usando il nodo header si spreca un nodo per valori elevati del numero di dati nella catena questo spreco, in percentuale, è trascurabile Marcello Dalpasso 5

6 Esercizio: acktracking Il problema delle otto regine Un problema classico di programmazione piazzare otto regine su una scacchiera in modo che nessuna di esse ne possa catturare un altra è noto che il problema ha soluzione ome si procederebbe a mano? Se dovessimo risolvere il problema a mano procederemmo così si piazza una regina in una posizione libera si piazza un altra regina in una posizione libera e non controllata da altre regine già piazzate si continua così finché si arriva alla soluzione se non si riesce a piazzare una regina, significa che la scelta fatta in precedenza era sbagliata, per cui si torna indietro rimuovendo la regina appena piazzata e mettendola in una posizione diversa se non ci sono più posizioni possibili, bisogna rimuovere la regina precedente, e via così 33 acktracking Questa strategia, detta backtracking, è molto comoda in tutte quelle situazioni in cui l algoritmo di soluzione di un problema deve esplorare diversi possibili percorsi senza sapere a priori se un certo percorso porterà alla soluzione Giunti ad un bivio tra due possibili percorsi, si sceglie uno dei percorsi dopo aver seguito un percorso senza successo, si ritorna al bivio e si segue un percorso diverso (finché ci sono percorsi possibili) 34 acktracking Occorre predisporre le strutture dati necessarie per poter tornare indietro lungo un percorso fino ad un bivio occorre anche tenere traccia di quali percorsi, a partire da un certo bivio, devono ancora essere provati Il backtracking è anche ricorsivo se nessuno dei percorsi che partono da un bivio porta ad una soluzione, occorre tornare indietro al bivio precedente 35 La scacchiera Per rappresentare la scacchiera usiamo un array bidimensionale quadrato Ogni cella dell array contiene un numero intero che vale 0 se la cella è libera e non controllata da altre regine quindi vi si può piazzare una nuova regina -1 se la cella contiene una regina 1 se la cella non contiene una regina ma è controllata da una regina, e quindi non è disponibile 36 Marcello Dalpasso 6

7 Una posizione sulla scacchiera Per rappresentare una posizione sulla scacchiera sarebbe naturale usare una coppia di numeri interi x e y come indici di riga e di colonna nell array Vedremo però che è più comodo usare un solo numero intero position, effettuando le seguenti conversioni position = x * board.length + y; x = position / board.length; y = position % board.length; 37 Il problema delle otto regine Impostiamo la soluzione del problema per una scacchiera di dimensioni generiche, a scelta dell utente Si sistemano N regine in una scacchiera N x N public class QueensSolver { public static void main(string[] args) { int boardsize = 8; if (args.length == 1) boardsize = Integer.parseInt(args[0]); int[][] board = new int[boardsize][boardsize]; putqueens(board, boardsize); print(board); Il problema delle otto regine private static void copy(int[][] fromoard, // metodi int[][] tooard) // ausiliari { for (int i = 0; i < fromoard.length; i++) for (int j = 0; j < fromoard.length; j++) tooard[i][j] = fromoard[i][j]; private static void print(int[][] board) { for (int i = 0; i < board.length; i++) { for (int j = 0; j < board.length; j++) if (board[i][j] == -1) System.out.print("0"); else System.out.print("."); System.out.println(); private static boolean isvailable(int[][] board, int pos) { return (board[pos/board.length][pos%board.length] == 0); 39 lgoritmo ontrassegna tutte le posizioni come disponibili Inizializza la posizione a zero Finché ci sono regine da piazzare se la posizione è disponibile memorizza la situazione attuale in una pila piazza una regina in tale posizione altrimenti incrementa la posizione se la posizione non è valida se la pila è vuota il problema non ha soluzione altrimenti estrai dalla pila la situazione più recentemente memorizzata (cioè torna indietro al bivio precedente) e passa alla posizione successiva 40 lgoritmo osa significa memorizza la situazione attuale? bisogna memorizzare la configurazione attuale della scacchiera la configurazione della scacchiera contiene la posizione di tutte le regine già piazzate e l indicazione del controllo da parte di altre regine o della disponibilità delle singole posizioni bisogna memorizzare la posizione che si sta esaminando ripristinando una configurazione con il backtracking bisognerà poi proseguire dalla posizione successiva, altrimenti si entra in un ciclo infinito, provando sempre lo stesso percorso! 41 lgoritmo Dato che dobbiamo sempre ritornare alla configurazione memorizzata più di recente, è naturale usare una pila private static void savestate(stack s, int[][] board, int pos) { int[][] currentoard = new int[board.length][board.length]; copy(board, currentoard); s.push(new Integer(pos)); s.push(currentoard); private static int restorestate(stack s, int[][] board) { copy((int[][]) s.topndpop(), board); Integer position = (Integer) s.topndpop(); return position.intvalue(); // notare l ordine inverso nell estrazione dalla pila 42 Marcello Dalpasso 7

8 Soluzione private static void putqueens(int[][] board, int numofqueens) { Stack s = new rraystack(); int currentposition = 0; while (numofqueens > 0) { if (isvailable(board, currentposition)) { savestate(s, board, currentposition); place(board, currentposition); numofqueens--; else currentposition++; while (currentposition == board.length * board.length) { if (s.isempty()) return; numofqueens++; currentposition = 1 + restorestate(s, board); 43 Soluzione private static void place(int[][] board, int pos) { int x = pos / board.length, y = pos % board.length; board[x][y] = -1; // piazza la regina for (int i = 0; i < board.length; i++) // controlla la riga if (i!= y) board[x][i] = 1; for (int i = 0; i < board.length; i++) // controlla la colonna if (i!= x) board[i][y] = 1; for (int i = x-1, j = y-1; // controlla diagonale alto sx i >= 0 && j >= 0; i--, j--) board[i][j] = 1; for (int i = x+1, j = y+1; // controlla diagonale basso dx i < board.length && j < board.length; i++, j++) board[i][j] = 1; for (int i = x-1, j = y+1; // controlla diagonale alto dx i >= 0 && j < board.length; i--, j++) board[i][j] = 1; for (int i = x+1, j = y-1; // controlla diagonale basso sx i < board.length && j >= 0; i++, j--) board[i][j] = 1; 44 Intervallo Soluzione ricorsiva Senza usare una pila esplicitamente, si può identificare una soluzione ricorsiva per il problema Si noterà che la pila viene usata ugualmente, soltanto che la gestione dello stato è affidata alla JVM mediante il runtime stack Soluzione ricorsiva Il problema delle otto regine ontrassegna tutte le posizioni come disponibili Dopo aver piazzato una regina in una posizione, Piazza N regine: occorre contrassegnare come non disponibili tutte esamina in sequenza ciascuna posizione le posizioni che si trovano sotto il controllo di tale se la posizione è disponibile regina piazza una regina nella posizione Rimuovendo una regina da una posizione, occorre se N = 1 contrassegnare come nuovamente disponibili tutte successo le posizioni che si trovavano sotto il controllo di altrimenti tale regina se piazza N-1 regine ha successo tranne quelle posizioni che si trovano sotto il» successo controllo di altre regine già piazzate togli la regina dalla posizione fallimento Marcello Dalpasso 8

9 Il problema delle otto regine La convenzione precedente per i valori delle celle della scacchiera non è più adatta per ogni posizione, occorre tenere traccia di quante regine la controllano (si osservi che non è necessario sapere quali regine la controllano) Possiamo usare un array bidimensionale di numeri interi il valore indica quante regine controllano una posizione (che è disponibile se tale valore è zero) piazzando una regina si aumenta di uno il valore di tutte le celle da essa controllate rimuovendo una regina si diminuisce di uno il valore di tutte le celle da essa controllate 49 Il problema delle otto regine private static boolean putqueens(int[][] board, int numofqueens) { for (int i = 0; i < board.length * board.length; i++) if (isvailable(board, i)) { placequeen(board, i); if (numofqueens == 1) return true; if (putqueens(board, numofqueens-1)) return true; removequeen(board, i); return false; 50 Il problema delle otto regine Il problema delle otto regine private static void placequeen(int[][] board, int pos) { board[pos/board.length][pos%board.length] = -1; mark(board, pos, 1); private static void removequeen(int[][] board, int pos) { board[pos/board.length][pos%board.length] = 0; mark(board, pos, -1); private static void print(int[][] board) { for (int i = 0; i < board.length; i++) { for (int j = 0; j < board.length; j++) if (board[i][j] == -1) System.out.print("0"); else System.out.print("."); System.out.println(); 51 private static void mark(int[][] board, int pos, int inc) { int x = pos/board.length, y = pos%board.length; for (int i = 0; i < board.length; i++) // colonna if (i!= x) board[i][y] += inc; for (int i = 0; i < board.length; i++) // riga if (i!= y) board[x][i] += inc; for (int i = x-1, j = y-1; // diagonale verso alto sx i >= 0 && j >= 0; i--, j--) board[i][j] += inc; for (int i = x+1, j = y+1; // diagonale verso basso dx i < board.length && j < board.length; i++, j++) board[i][j] += inc; for (int i = x-1, j = y+1; // diagonale verso alto dx i >= 0 && j < board.length; i--, j++) board[i][j] += inc; for (int i = x+1, j = y-1; // diagonale verso basso sx i < board.length && j >= 0; i++, j--) board[i][j] += inc; 52 Prestazioni della catena Marcello Dalpasso 9

10 Prestazioni della catena Tutte le operazioni sulla catena sono O(1) tranne removelast che è O(n) si potrebbe pensare di tenere un riferimento anche al penultimo nodo, ma per aggiornare tale riferimento sarebbe comunque necessario un tempo O(n) Se si usa una catena con il solo riferimento head, anche addlast diventa O(n) per questo è utile usare il riferimento tail, che migliora le prestazioni di addlast senza peggiorare le altre e non richiede molto spazio di memoria 55 Prestazioni della catena Non esiste il problema di catena piena non bisogna mai ridimensionare la catena la JVM lancia l eccezione OutOfMemoryError se viene esaurita la memoria disponibile Non c è spazio di memoria sprecato (come negli array riempiti solo in parte ) un nodo occupa però più spazio di una cella di array, almeno il doppio (contiene due riferimenti anziché uno) 56 lassi interne 57 lassi interne Osserviamo che la classe ListNode, usata dalla catena, non viene usata al di fuori della catena stessa la catena non restituisce mai riferimenti a ListNode la catena non riceve mai riferimenti a ListNode Per il principio dell incapsulamento (information hiding) sarebbe preferibile che questa classe e i suoi dettagli non fossero visibili all esterno della catena in questo modo una modifica della struttura interna della catena e/o di ListNode non avrebbe ripercussioni sul codice scritto da chi usa la catena 58 lassi interne Il linguaggio Java consente di definire classi all interno di un altra classe tali classi si chiamano classi interne (inner classes) L argomento è molto vasto noi interessa solo il fatto che se una classe interna viene definita private essa è accessibile (in tutti i sensi) soltanto all interno della classe in cui è definita dall esterno non è nemmeno possibile creare oggetti di tale classe interna private class ListNode 59 Utilizzo di catene 60 Marcello Dalpasso 10

11 Pila realizzata con una catena Una pila può essere realizzata usando una catena invece di un array Si noti che entrambe le estremità di una catena hanno, prese singolarmente, il comportamento di una pila si può quindi realizzare una pila usando una delle due estremità della catena è più efficiente usare l inizio della catena, perché le operazioni su tale estremità sono O(1) 61 public class LinkedListStack implements Stack { private LinkedList list = new LinkedList(); public void push(object obj) { list.addfirst(obj); public void pop() { list.removefirst(); public Object top() { return list.getfirst(); public Object topndpop() { return list.removefirst(); public void makeempty() { list.makeempty(); public boolean isempty() { return list.isempty(); 62 oda realizzata con una catena nche una coda può essere realizzata usando una catena invece di un array È sufficiente inserire gli elementi ad un estremità della catena e rimuoverli dall altra estremità per ottenere il comportamento di una coda Perché tutte le operazioni siano O(1) bisogna inserire alla fine e rimuovere all inizio 63 public class LinkedListQueue implements Queue { private LinkedList list = new LinkedList(); public void enqueue(object obj) { list.addlast(obj); public Object dequeue() { return list.removefirst(); public Object getfront() { return list.getfirst(); public void makeempty() { list.makeempty(); public boolean isempty() { return list.isempty(); 64 lgoritmi per catene 65 atena: conteggio elementi Per contare gli elementi presenti in una catena è necessario attraversare tutta la catena public int getsize() { ListNode temp = head.getnext(); int size = 0; while (temp!= ) { size++; temp = temp.getnext(); // osservare che size è zero // se la catena è vuota return size; 66 Marcello Dalpasso 11

12 atena: ricerca Per verificare la presenza di un elemento all interno di una catena è necessario attraversare tutta la catena, esaminando tutti i suoi nodi public boolean find(object x) { ListNode temp = head.getnext(); while (temp!= ) { if (temp.getelement().equals(x)) return true; temp = temp.getnext(); return false; 67 Iteratore in una catena Osserviamo che per eseguire algoritmi sulla catena è necessario definire metodi all interno della classe LinkedList, che è l unica ad avere accesso ai nodi della catena Questo limita molto l utilizzo della catena come struttura dati definita una volta per tutte Vogliamo che la catena metta a disposizione uno strumento per accedere ordinatamente a tutti i suoi elementi 68 Iteratore in una catena L idea più semplice è quella di fornire un metodo gethead public ListNode gethead() { return head; Questo viola completamente l incapsulamento, perché è possibile modificare direttamente lo stato interno della catena, anche in modo da non farla più funzionare correttamente ad esempio, creando una catena circolare Fortunatamente non funziona, perché ListNode è una classe interna 69 Intervallo 70 Iteratore in una catena La soluzione del problema è quella di fornire all utilizzatore della catena uno strumento (un oggetto ) con il quale interagire con la catena per scandire i suoi nodi Tale oggetto si chiama iteratore e ne definiamo prima di tutto il comportamento astratto mediante un interfaccia Un iteratore rappresenta in astratto il concetto di posizione all interno di una catena la posizione è rappresentata concretamente da un nodo 71 Iteratore in una catena public interface ListItr { // porta l iteratore nella prima posizione; // e la posizione in cui l iteratore si trova // quando viene costruito void first(); // sposta l iteratore di una posizione (può // portarlo ad una posizione non valida) void advance(); // verifica se l iteratore si trova // in una posizione valida boolean isinlist(); // restituisce l oggetto (il ) che si // trova nella posizione attuale; restituisce // se l iteratore non si trova in una // posizione valida Object retrieve(); 72 Marcello Dalpasso 12

13 Iteratore in una catena questo punto, è sufficiente che la catena fornisca un metodo per creare un iteratore public ListItr getiterator() { return...; // vediamo dopo come fare e si può scandire la catena senza accedere ai nodi Iteratore in una catena ome realizzare il metodo getiterator nella catena? osserviamo che restituisce un riferimento ad interfaccia, per cui dovrà creare un oggetto di una classe che realizzi tale interfaccia Definiamo la classe LinkedListItr che realizza ListItr Gli oggetti di tale classe vengono costruiti soltanto all interno di LinkedList e vengono restituiti all esterno soltanto tramite riferimenti a ListItr quindi possiamo usare una classe interna LinkedList list = new LinkedList();... ListItr iter = list.getiterator(); while(iter.isinlist()) { System.out.println(iter.retrieve()); iter.advance(); iter.first(); // ora si può scandire di nuovo Iteratore in una catena Per un corretto funzionamento dell iteratore occorre concedere a tale oggetto il pieno accesso alla catena in particolare, alle sue variabili di esemplare head e tail non vogliamo però che l accesso sia consentito anche ad altre classi Questo è consentito dalla definizione di classe interna una classe interna può accedere agli elementi private della classe in cui è definita essendo tali elementi definiti private, l accesso è impedito alle altre classi 75 public ListItr getiterator() { return new LinkedListItr(this); private class LinkedListItr implements ListItr { private LinkedList list; private ListNode current; // posizione public LinkedListItr(LinkedList lst) { list = lst; first(); public void first() { current = list.head.getnext(); public void advance() // non fallisce mai { if (isinlist()) current = current.getnext(); public boolean isinlist() { return current!= ; public Object retrieve() { return isinlist()? current.getelement() : ; 76 atena: ricerca Possiamo quindi riscrivere il metodo di ricerca in una catena, ma al di fuori della catena stessa, in una classe qualsiasi public boolean find(linkedlist list, Object x) { ListItr iter = list.getiterator(); while (iter.isinlist()) { if (x.equals(iter.retrieve())) return true; iter.advance(); return false; 77 atena: inserimento e rimozione bbiamo visto l inserimento e la rimozione di un elemento all inizio e alla fine della catena Vogliamo estendere le modalità di funzionamento della catena per poter inserire e rimuovere elementi in qualsiasi punto della catena stessa abbiamo di nuovo il problema di rappresentare il concetto di posizione, la posizione in cui inserire il nuovo nodo nella catena o da cui rimuovere il nodo Usiamo di nuovo l iteratore dobbiamo però estenderne le funzionalità 78 Marcello Dalpasso 13

14 Iteratore in una catena public interface ListItr { void first(); void advance(); boolean isinlist(); Object retrieve(); // inserisce l oggetto x in un nuovo nodo // che si aggiunge alla catena nella posizione // successiva alla posizione attuale, senza // modificare la posizione dell iteratore void insert(object x); // elimina il nodo che si trova nella posizione // successiva alla posizione attuale, senza // modificare la posizione dell iteratore void remove(); 79 atena: inserimento e rimozione Gestione degli errori se l iteratore si trova in una posizione non valida quando viene invocato insert o remove, viene lanciata l eccezione InvalidPositionListException anche se si invoca remove quando l iteratore si trova nell ultima posizione aso particolare se il metodo insert inserisce un nuovo nodo nella posizione successiva alla posizione attuale, come si può inserire un nuovo nodo all inizio della catena? la posizione iniziale non è la successiva di nessuna posizione 80 atena: inserimento e rimozione ggiungiamo all iteratore il metodo zeroth che pone l iteratore in una posizione inesistente, la cui posizione successiva è la posizione iniziale si tratta della posizione zeresima Dal punto di vista realizzativo, ciò non pone problemi, perché la catena ha effettivamente un nodo precedente al primo nodo il nodo header rappresenta la posizione zeresima Iteratore in una catena public interface ListItr { void first(); void advance(); boolean isinlist(); Object retrieve(); void insert(object x); void zeroth(); void remove(); private class LinkedListItr implements ListItr { private LinkedList list; private ListNode current; public LinkedListItr(LinkedList lst) { list = lst; first(); public void first() { current = list.head.getnext(); public void zeroth() { current = list.head; private boolean isinzeroth() { return current == list.head; public boolean isinlist() { return current!= &&!isinzeroth(); public void advance() // non fallisce mai { if (isinlist() isinzeroth()) current = current.getnext(); public Object retrieve() { return isinlist()? current.getelement() : ; private class LinkedListItr implements ListItr public void insert(object x) { if (current == list.tail) list.addlast(x); else if (isinzeroth()) list.addfirst(x); else if (!isinlist()) throw new InvalidPositionListException(); else current.setnext(new ListNode(x, current.getnext())); 84 Marcello Dalpasso 14

15 private class LinkedListItr implements ListItr public void remove() { if (isinzeroth()) list.removefirst(); else if (!isinlist() current == list.tail) throw new InvalidPositionListException(); else if (current.getnext() == list.tail) { // bisogna rimuovere l ultimo // ma list.removelast() è lento! current.setnext(); list.tail = current; else current.setnext( current.getnext().getnext()); Lista 87 Lista Dopo aver introdotto l iteratore completo per una catena, possiamo osservare che l interfaccia ListItr, oltre a consentire la manipolazione di una catena, definisce anche il comportamento astratto di un contenitore in cui i dati sono disposti in sequenza (cioè per ogni è definito un precedente ed un successivo) nuovi dati possono essere inseriti in ogni punto della sequenza dati possono essere rimossi da qualsiasi punto della sequenza 88 Lista Un contenitore avente un tale comportamento può essere molto utile, per cui si definisce un tipo di dati astratto, detto lista, con la seguente interfaccia public interface List extends ontainer { ListItr getiterator(); dove ListItr è l interfaccia definita in precedenza 89 Lista questo punto possiamo ridefinire la catena come public class LinkedList implements List ma si noti che non è necessario realizzare una lista mediante una catena, perché nella definizione della lista non vengono menzionati i nodi è infatti possibile definire una lista che usa un array come struttura di memorizzazione dei dati 90 Marcello Dalpasso 15

16 Dati in sequenza bbiamo quindi visto diversi tipi di contenitori per dati in sequenza, rappresentati dagli DT pila coda lista (che usa un iteratore) Per realizzare tali DT, abbiamo usato diverse strutture dati array catena 91 Più iteratori sulla stessa lista Se vengono creati più iteratori che agiscono sulla stessa lista cosa perfettamente lecita, invocando più volte il metodo getiterator ciascuno di essi mantiene il proprio stato, cioè memorizza la propria posizione nella lista iascun iteratore può muoversi nella lista indipendentemente dagli altri occorre però usare qualche cautela quando si usano gli iteratori per modificare la lista 92 Più iteratori sulla stessa lista List list = new LinkedList() ListItr iter1 = list.getiterator(); iter1.insert(new Integer(1)); ListItr iter2 = list.getiterator(); // iter2 punta al primo elemento in lista, 1 iter1.zeroth(); iter1.insert(new Integer(2)); // il primo elemento della lista è diventato 2 System.out.println(iter2.retrieve()); // 1 atena doppia (doubly linked list) L argomento è molto complesso, ma viene qui soltanto accennato per invitare alla cautela nell uso di più iteratori non ci sono problemi se si usano in sola lettura atena doppia La catena doppia (lista doppiamente concatenata, doubly linked list) non è un nuovo DT, ma è una struttura dati per la realizzazione di DT Una catena doppia è un insieme ordinato di nodi ogni nodo è un oggetto che contiene un riferimento ad un elemento (il ) un riferimento al nodo successivo della lista () un riferimento al nodo precedente della lista (prev) 95 atena doppia prev prev prev Dato che la struttura è ora simmetrica, si usano due nodi che non contengono dati, uno a ciascun estremo della catena 96 Marcello Dalpasso 16

17 atena doppia Tutto quanto detto per la catena (semplice) può essere agevolmente esteso alla catena doppia Il metodo removelast diventa O(1) come gli altri metodi L iteratore per la catena doppia avrà anche un metodo per retrocedere di una posizione, oltre a quello per avanzare Intervallo lbero binario: definizione lbero binario 99 Un albero è un insieme (eventualmente vuoto) di nodi connessi mediante rami o archi Se l albero non è vuoto, uno dei suoi nodi viene detto radice dell albero iascun nodo è connesso tramite un ramo ad un altro nodo che ne è il genitore e di cui rappresenta un figlio unica eccezione: la radice non ha genitore iascun nodo può avere al massimo due figli (da cui il nome binario) figlio sinistro e figlio destro D E 100 F lberi binari: esempi lbero binario: percorsi vuoto 101 iascun nodo può contenere informazioni di vario tipo rappresentate dalla sua D etichetta (label), fungendo da contenitore l albero binario è quindi una struttura dati Una sequenza di nodi dell albero tale che ciascun nodo (tranne l ultimo) sia il genitore del nodo successivo della sequenza si dice cammino o percorso nell albero La lunghezza di un percorso è il numero dei suoi rami un percorso con k nodi ha lunghezza k-1 si considera anche il percorso degenere di lunghezza zero, con un solo nodo E F 102 Marcello Dalpasso 17

18 lbero binario: livello Per ciascun nodo esiste uno ed un solo percorso che lo collega alla radice la lunghezza di tale percorso è la profondità o livello del nodo (la radice ha livello/profondità zero, F è al livello 3) la profondità di un nodo è uguale alla profondità del genitore, aumentata di uno i nodi che si trovano su tale percorso sono gli antenati del nodo, ed il nodo è un loro discendente (,, E sono gli antenati di F) D E F lbero binario: tipi di nodi Un nodo senza figli è un nodo terminale o foglia Un nodo con almeno un figlio è un nodo interno Due nodi con lo stesso genitore si dicono fratelli (sibling) D E F lbero binario: altezza L altezza di un nodo è la lunghezza del più lungo percorso che va dal nodo stesso D E ad una foglia tutte le foglie di un albero hanno altezza zero F il nodo ha altezza 2 dalla definizione discende che l altezza di un nodo interno è uguale all altezza maggiore tra quella dei suoi figli, aumentata di uno L altezza di un albero non vuoto è l altezza della sua radice (ed è anche il livello massimo dei suoi nodi) l albero qui rappresentato ha altezza 3 l altezza di un albero vuoto non è definita 105 Sotto-albero binario Dato un nodo N appartenente ad un albero binario, l insieme dei nodi dell albero che contiene N e tutti i suoi discendenti si dice sotto-albero binario, ed N ne è la radice È facile verificare che un sotto-albero binario, considerato a sé stante, è un albero binario Dato un nodo N, il sotto-albero che ha come radice il suo figlio sinistro (destro) si dice sotto-albero sinistro (destro) di N se il nodo N non ha un figlio sinistro (destro), si dice che ha un sotto-albero sinistro (destro) vuoto 106 D N E F Definizione ricorsiva È possibile dare una diversa definizione di albero binario, una definizione ricorsiva D E 1L albero vuoto è un albero binario F 2Se X e Y sono alberi binari (eventualmente vuoti) senza nodi in comune e il nodo Z non appartiene né ad X né a Y, allora inserendo la radice di X come figlio sinistro di Z e la radice di Y come figlio destro di Z si ottiene un albero binario con radice Z 107 lbero binario completo Un nodo avente due figli si dice pieno Un albero binario di altezza h si dice completo se tutti i nodi di livello minore di h sono pieni Livello 0 Livello 1 Livello 2 D E F G 108 Marcello Dalpasso 18

19 lbero binario completo In un albero binario completo troviamo un nodo al livello 0 due nodi al livello 1 quattro (2 2 ) nodi al livello 2 2 h nodi al livello h Livello 0 Livello 1 lbero binario completo In un albero binario completo di altezza h ci sono N = h h = 2 h+1-1 In un albero binario completo, ogni sotto-albero è Livello 2 D E F G un albero binario completo nodi L altezza di un albero binario completo con N nodi è quindi h = log 2 (N+1) - 1 lbero binario bilanciato Un albero binario di altezza h si dice bilanciato se tutti i nodi di livello minore di h-1 sono pieni rispetto ad un albero completo, possono mancare soltanto alcune foglie Un albero completo è anche bilanciato In un albero bilanciato, per ogni nodo vale la proprietà le altezze dei suoi due sottoalberi D F differiscono tra loro al massimo di una unità Marcello Dalpasso 19