51 Esercizi di Java - TIM e Telecom in un unico portale | TIM · delle strutture dati può basarsi...

51 Esercizi di Java V0.90

Marcello Esposito

Copyright c⃝2006-2015 Marcello Esposito. Permission is granted to copy,distribute and/or modify this document under the terms of the GNU FreeDocumentation License, Version 1.3 or any later version published by theFree Software Foundation; with no Invariant Sections, no Front-Cover Texts,and no Back-Cover Texts. A copy of the license is included in the sectionentitled "GNU Free Documentation License".

Indice

Prefazione 5

I Esercizi 10

EL Esercizi su liste 11

EL.1 Lista Semplicemente Collegata . . . . . . . . . . . . . . . . 11EL.2 Somma Elementi . . . . . . . . . . . . . . . . . . . . . . . . 12EL.3 Coda Pari . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12EL.4 Min e Max . . . . . . . . . . . . . . . . . . . . . . . . . . . 12EL.5 Lista Statica . . . . . . . . . . . . . . . . . . . . . . . . . . 13EL.6 È Ordinata . . . . . . . . . . . . . . . . . . . . . . . . . . . 13EL.7 Elimina Tutti . . . . . . . . . . . . . . . . . . . . . . . . . . 14EL.8 Elimina Ultimi . . . . . . . . . . . . . . . . . . . . . . . . . 14EL.9 Somma Coda . . . . . . . . . . . . . . . . . . . . . . . . . . 14EL.10 Sposta Testa in Coda . . . . . . . . . . . . . . . . . . . . . 15EL.11 Elimina Pari e Dispari . . . . . . . . . . . . . . . . . . . . . 15EL.12 Lista Doppiamente Collegata . . . . . . . . . . . . . . . . . 15EL.13 Ribalta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

EA Esercizi su alberi binari 18

EA.1 Albero Binario . . . . . . . . . . . . . . . . . . . . . . . . . 18EA.2 Numero Elementi . . . . . . . . . . . . . . . . . . . . . . . 19EA.3 Occorrenze . . . . . . . . . . . . . . . . . . . . . . . . . . . 19EA.4 Occorrenza Massima . . . . . . . . . . . . . . . . . . . . . . 20EA.5 Profondità Limitata . . . . . . . . . . . . . . . . . . . . . . 20EA.6 Somma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21EA.7 Sostituisci . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21EA.8 Conta Min e Max . . . . . . . . . . . . . . . . . . . . . . . 21EA.9 Profondità Maggiore di Due . . . . . . . . . . . . . . . . . . 22EA.10 Profondita Maggiore Di . . . . . . . . . . . . . . . . . . . . 22

1

INDICE 2

EA.11 Profondità Massima . . . . . . . . . . . . . . . . . . . . . . 22EA.12 Somma Livello . . . . . . . . . . . . . . . . . . . . . . . . . 23EA.13 Eliminazione Foglia . . . . . . . . . . . . . . . . . . . . . . 23EA.14 Eliminazione Foglie . . . . . . . . . . . . . . . . . . . . . . 23EA.15 Cerca Foglia . . . . . . . . . . . . . . . . . . . . . . . . . . 24EA.16 Operatore di Confronto . . . . . . . . . . . . . . . . . . . . 24EA.17 Conta Nodi non Foglia . . . . . . . . . . . . . . . . . . . . . 25EA.18 Conta Nodi . . . . . . . . . . . . . . . . . . . . . . . . . . . 25EA.19 Conta Nodi Sottoalbero . . . . . . . . . . . . . . . . . . . . 25EA.20 SommaMinMax . . . . . . . . . . . . . . . . . . . . . . . . 26

EP Esercizi su pile 27

EP.1 Push Greater . . . . . . . . . . . . . . . . . . . . . . . . . . 27EP.2 Push If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

EC Esercizi su code 30

EC.1 Coda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30EC.2 Coda con Perdite . . . . . . . . . . . . . . . . . . . . . . . . 31EC.3 Coda a Priorità . . . . . . . . . . . . . . . . . . . . . . . . . 32EC.4 PopMinMax . . . . . . . . . . . . . . . . . . . . . . . . . . 33

EX Altri esercizi 35

EX.1 Accumulatore . . . . . . . . . . . . . . . . . . . . . . . . . . 35EX.2 Cifratore . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35EX.3 Lista Della Spesa . . . . . . . . . . . . . . . . . . . . . . . . 36EX.4 Predittore di Temperatura . . . . . . . . . . . . . . . . . . 37EX.5 Contenitore . . . . . . . . . . . . . . . . . . . . . . . . . . . 38EX.6 Lista Prenotazioni . . . . . . . . . . . . . . . . . . . . . . . 39EX.7 Classi�ca . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40EX.8 Agenzia Matrimoniale . . . . . . . . . . . . . . . . . . . . . 41EX.9 Parco Pattini . . . . . . . . . . . . . . . . . . . . . . . . . . 43EX.10 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44EX.11 Timer Avanzato . . . . . . . . . . . . . . . . . . . . . . . . 45EX.12 Votazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

II Soluzioni 47

SL Soluzioni degli esercizi su liste 48

SL.1 Lista Semplicemente Collegata . . . . . . . . . . . . . . . . 48SL.2 Somma Elementi . . . . . . . . . . . . . . . . . . . . . . . . 52

INDICE 3

SL.3 Coda Pari . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53SL.4 Min e Max . . . . . . . . . . . . . . . . . . . . . . . . . . . 54SL.5 Lista Statica . . . . . . . . . . . . . . . . . . . . . . . . . . 54SL.6 È Ordinata . . . . . . . . . . . . . . . . . . . . . . . . . . . 55SL.7 Elimina Tutti . . . . . . . . . . . . . . . . . . . . . . . . . . 56SL.8 Elimina Ultimi . . . . . . . . . . . . . . . . . . . . . . . . . 57SL.9 Somma Coda . . . . . . . . . . . . . . . . . . . . . . . . . . 58SL.10 Sposta Testa in Coda . . . . . . . . . . . . . . . . . . . . . 59SL.11 Elimina Pari e Dispari . . . . . . . . . . . . . . . . . . . . . 60SL.12 Lista Doppiamente Collegata . . . . . . . . . . . . . . . . . 61SL.13 Ribalta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

SA Soluzioni degli esercizi su alberi binari 67

SA.1 Albero Binario . . . . . . . . . . . . . . . . . . . . . . . . . 67SA.2 Numero Elementi . . . . . . . . . . . . . . . . . . . . . . . 72SA.3 Occorrenze . . . . . . . . . . . . . . . . . . . . . . . . . . . 73SA.4 Occorrenza Massima . . . . . . . . . . . . . . . . . . . . . . 73SA.5 Profondità Limitata . . . . . . . . . . . . . . . . . . . . . . 75SA.6 Somma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77SA.7 Sostituisci . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77SA.8 Conta Min e Max . . . . . . . . . . . . . . . . . . . . . . . 77SA.9 Profondità Maggiore di Due . . . . . . . . . . . . . . . . . . 78SA.10 Profondita Maggiore Di . . . . . . . . . . . . . . . . . . . . 79SA.11 Profondità Massima . . . . . . . . . . . . . . . . . . . . . . 79SA.12 Somma Livello . . . . . . . . . . . . . . . . . . . . . . . . . 80SA.13 Eliminazione Foglia . . . . . . . . . . . . . . . . . . . . . . 81SA.14 Eliminazione Foglie . . . . . . . . . . . . . . . . . . . . . . 82SA.15 Cerca Foglia . . . . . . . . . . . . . . . . . . . . . . . . . . 82SA.16 Operatore di Confronto . . . . . . . . . . . . . . . . . . . . 85SA.17 Conta Nodi non Foglia . . . . . . . . . . . . . . . . . . . . . 86SA.18 Conta Nodi . . . . . . . . . . . . . . . . . . . . . . . . . . . 86SA.19 Conta Nodi Sottoalbero . . . . . . . . . . . . . . . . . . . . 87SA.20 SommaMinMax . . . . . . . . . . . . . . . . . . . . . . . . 89

SP Soluzioni degli esercizi su pile 91

SP.1 Push Greater . . . . . . . . . . . . . . . . . . . . . . . . . . 91SP.2 Push If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

SC Soluzioni degli esercizi su code 96

SC.1 Coda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96SC.2 Coda con Perdite . . . . . . . . . . . . . . . . . . . . . . . . 99

INDICE 4

SC.3 Coda a Priorità . . . . . . . . . . . . . . . . . . . . . . . . . 103SC.4 PopMinMax . . . . . . . . . . . . . . . . . . . . . . . . . . 109

SX Soluzioni degli altri esercizi 111

SX.1 Accumulatore . . . . . . . . . . . . . . . . . . . . . . . . . . 111SX.2 Cifratore . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112SX.3 Lista Della Spesa . . . . . . . . . . . . . . . . . . . . . . . . 113SX.4 Predittore di Temperatura . . . . . . . . . . . . . . . . . . 118SX.5 Contenitore . . . . . . . . . . . . . . . . . . . . . . . . . . . 120SX.6 Lista Prenotazioni . . . . . . . . . . . . . . . . . . . . . . . 123SX.7 Classi�ca . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126SX.8 Agenzia Matrimoniale . . . . . . . . . . . . . . . . . . . . . 130SX.9 Parco Pattini . . . . . . . . . . . . . . . . . . . . . . . . . . 136SX.10 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140SX.11 Timer Avanzato . . . . . . . . . . . . . . . . . . . . . . . . 142SX.12 Votazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

A GNU Free Documentation License 148

Prefazione

Gli esercizi presentati in questo eserciziario sono stati originariamente asse-gnati ad un corso universitario di Programmazione I al secondo e terzo annodi Ingegneria delle Telecomunicazioni. Il corso richiedeva di realizzarne lesoluzioni in linguaggio C++. Successivamente sono tradotti in linguaggioJava dal testo 50 esercizi di C++ con soluzioni [1].

Il corso aveva lo scopo di introdurre alla programmazione orientata aglioggetti. Una rilevante parte del programma a�rontava lo studio dei tipidi dati astratti, con particolare enfasi sulle strutture dati di tipo conteni-tore, stressandone i concetti di incapsulamento ed interfaccia. Gli esercizidedicati all'approfondimento di questi concetti sono stati raccolti in questoeserciziario, insieme con le relative soluzioni.

A chi è rivolto questo testo

Gli studenti che approcciano allo studio del linguaggio Java, in occasionedi corsi di studi superiori, troveranno utile studiare e risolvere gli esercizicontenuti in questo testo. Se da un lato questi favoriscono l'acquisizione dellericorrenti tecniche legate alla realizzazione ed all'uso di contenitori, dall'altrorappresentano un pretesto per mettere in pratica approcci algoritmici allarisoluzione di problemi più generici. Il libro si focalizza sulla progettazionedegli algoritmi più che sulla sintassi e sull'uso esteso dello speci�co linguaggio.

Non essendo questo un libro di teoria, lo studio di uno dei numero-si testi dedicati alle nozioni della programmazione, alle regole ed alla sin-tassi del linguaggio Java, risulta propedeutico. Un di�uso testo orientatoall'apprendimento del linguaggio è [2].

La struttura degli esercizi

Questo eserciziario contiene di�erenti tipologie di esercizi: alcuni richiedonola realizzazione di una struttura dati di tipo contenitore, mediante uso del

5

Prefazione 6

costrutto class del linguaggio, fornendo allo studente la speci�ca in formadi interfaccia dei classici metodi di cui tali strutture sono dotate (aggiunta diun elemento, conteggio degli elementi, svuotamento, visita, etc.). Altri eser-cizi, basandosi sulle suddette implementazioni, richiedono la realizzazione difunzionalità �nalizzate ad e�ettuare particolari elaborazioni sugli elementicontenuti (per esempio inserimenti o eliminazioni condizionate, somme, spo-stamenti, conteggi, etc.). In�ne, alcuni esercizi richiedono la realizzazionedi strutture dedicate a risolvere speci�ci problemi, e quindi prive dei classicirequisiti di generalità.

Per ogni metodo da implementare, una traccia fornisce le seguenti infor-mazioni:

• il nome del metodo;

• l'insieme dei parametri di ingresso;

• l'insieme dei parametri di uscita;

• la descrizione della funzionalità che il metodo deve realizzare.

Per esempio, la speci�ca di un ipotetico metodo di eliminazione di ele-menti da una lista, potrebbe apparire come segue.

Nome Param. Ingr. Param. Usc.

elimina() int int

Elimina dalla struttura tutte le occorrenze dell'elemento speci�cato dal

parametro di ingresso. Restituisce il numero delle eliminazioni e�ettuate.

Nel caso in cui l'insieme dei parametri di ingresso e/o di uscita fossevuoto, si utilizzerà il simbolo �ϕ�. Talvolta può accadere che nella descrizionedel funzionamento del metodo non si prenda in considerazione la totalitàdei casi che possono veri�carsi (pre-condizioni), limitandosi a descrivere ilcomportamento del metodo nei casi d'uso più comuni. In questo caso, ilprogrammatore può scegliere arbitrariamente un comportamento per tutti icasi non esplicitamente considerati.

Per quanto riguarda le strategie di gestione della memoria, la realizzazionedelle strutture dati può basarsi su un approccio di tipo statico (uso di vettoriallocati sullo stack) oppure dinamico (realizzazione di strutture concatenatecon puntatori ed allocate nell'heap mediante costrutto new). Questa scelta,in alcuni casi, è lasciata alla sensibilità dello studente.

Per ognuno degli esercizi, oltre alla traccia, si fornisce la soluzione con-sistente nell'implementazione dei metodi conformi all'interfaccia speci�cata

Prefazione 7

dalla traccia. Nel caso in cui la traccia richieda di realizzare una struttura da-ti completa (e non solo i metodi basati su di essa, nella soluzione viene anchefornito un modulo di test (di solito rappresentato dalla funzione main() dellaclasse Main) utile esclusivamente al collaudo delle funzionalità della classe.

Al �ne di preservare una maggiore generalità delle strutture dati realizza-te, un esplicito requisito comune a tutti gli esercizi consiste nel vietare l'usodei meccanismi di I/O nell'implementazione dei metodi della classe. La re-sponsabilità di prelevare i dati da tastiera e mostrare i risultati sulla consoleviene pertanto delegata al modulo di test, mentre la classe resta indipen-dente dalla tecnologia utilizzata per l'interfacciamento gra�co con l'utente.Pertanto, anziché stampare direttamente, i metodi di visita delle strutturecontenitore (per es. stampa degli elementi di una lista) costruiscono e resti-tuiscono una stringa contenente l'insieme degli elementi. Allo scopo utilizza-no la classe StringBuilder della libreria standard java.lang, che consenteproprio la composizione incrementale ed e�ciente di grosse stringhe di testomediante uso del metodo append(). Non sarà necessario quindi modi�carela classe nel caso in cui, in futuro, si decidesse di utilizzare una diversa in-terfaccia gra�ca (es. SWT, HTML, ecc.) per acquisire i dati e mostrare irisultati delle elaborazioni.

Compilare i sorgenti

Tutti i sorgenti presentati sono stati compilati con l'ambiente di sviluppointegrato Eclipse per Java, nella sua versione Luna Service Release 2 (4.4.2).L'estrema portabilità del linguaggio Java non dovrebbe rendere complicatala compilazione su altri ambienti di sviluppo.

Uno sguardo al futuro

Quelli che alla �ne di questo eserciziario penseranno: �Sì, e allora?�, probabil-mente sono pronti per a�rontare uno studio più approfondito della program-mazione, che non si esaurisce con il possesso delle nozioni sulla progettazionedi generici algoritmi e un'infarinatura sulle basi del linguaggio. Tra un indi-viduo che conosca un linguaggio di programmazione ed un programmatoreesperto c'è un di�erenza analoga a quella che esiste tra un individuo che sap-pia scrivere ed uno scrittore. Un buon programmatore non è quello che saa�rontare la complessità, ma quello che sa dominarla. Certamente la cono-scenza della sintassi del linguaggio è un primo passo indispensabile, ma chivuole approfondire questa a�ascinante materia non può fare a meno di acqui-

Prefazione 8

sire le nozioni della progettazione, le buone prassi per la stesura del codice egli strumenti forniti dalle librerie standard oggi disponibili. È solo attraversoquesta strada che diviene possibile scrivere applicazioni non banali, preser-vandone le caratteristiche di comprensibilità, estensibilità, manutenibilità,correttezza e, in una sola parola, di qualità. Programmare utilizzando l'in-capsulamento, il polimor�smo, i meccanismi delle eccezioni, delle asserzioni,dei generics, le numerose librerie più o meno standard, signi�ca disporre distrumenti semanticamente molto potenti, oltre che ben consolidati; signi�cadelegare al compilatore lo svolgimento di una serie di operazioni e di controlliche, in alternativa, peserebbero sulle spalle del programmatore, oppure nonverrebbero messi in essere a�atto.

Nell'apprendere le nozioni della progettazione e le buone prassi per lastesura del codice, ascoltare cosa hanno da dirci `i giganti' al proposito, puòservire molto. A questo scopo non si può fare a meno di citare dei testidisponibili in letteratura, universalmente considerati dei classici.

Design Patterns [3] è probabilmente il più bel testo mai scritto nell'ambitodella progettazione software, considerando anche le profonde ripercussioniche esso ha poi avuto sul concetto di buona progettazione software orientataagli oggetti, tanto da essere ancora oggi il libro di gran lunga più citatonel suo genere. In questo testo gli autori introducono il concetto di patternprogettuale software (design pattern); ad un livello di astrazione superiore aquello di qualsiasi linguaggio di programmazione, presentano poi 55 soluzionia problemi comuni nell'ambito della progettazione, con esempi in linguaggioC++. Ne esistono varie versioni declinate nel linguaggio Java. Imperdibile.

A livello professionale, è molto utile approfondire altri patterns consoli-dati. Un importante aspetto riguarda l'interfacciamento delle applicazionicon le basi di dati relazionali. Queste ultime, progettate prima della va-sta di�usione della programmazione orientata agli oggetti, male si adattanoad interagire con le moderne applicazioni. Per questo si sono recentementesviluppati prodotti classi�cati come object/relational mappers, il cui uso con-sapevole migliora notevolmente le caratteristiche di correttezza, modularità,portabilità, e�cienza di un'applicazione transazionale. Chi invece preferisseun approccio più radicale, estremamente promettente ed in fase di rapidadi�usione, può approfondire l'uso dei database documentali, tra i quali at-tualmente spicca MongoDB per numero di installazioni e tasso di crescita.Un altro interessante pattern trasversale è quello della dependency-injection,che naturalmente instrada ad uno sviluppo delle classi pulito, essenziale, mo-dulare, nel rispetto dei principali parametri di qualità del software. Chi fosseinteressato può approfondire la tematica cercando informazioni sui cinqueprincipi della programmazione SOLID.

Prefazione 9

Dove trovare questo eserciziario

Questo eserciziario è distribuito sotto licenza GNU Free Documentation Li-cense (vedi Appendice A) all'indirizzo http://esercizicpp.sourceforge.

net. Dal sito è possibile prelevare l'ultima versione disponibile, accedere aiforum dedicati ai lettori ed iscriversi alla mailing-list informativa.

Contattare l'autore

Commenti, suggerimenti e segnalazioni sono graditi. L'autore può esserecontattato al seguente indirizzo e-mail: [email protected]

Parte I

Esercizi

10

Capitolo EL

Esercizi su liste

EL.1 Lista Semplicemente Collegata

Soluzione a pag. 48

Si realizzi la struttura dati Lista secondo l'implementazione della lista sem-plicemente collegata (ogni elemento punta al successivo). Il tipo degli ele-menti contenuti sia uguale al tipo int del linguaggio. La lista sia dotata deimetodi riportati di seguito.

Nome Param. Ingr. Param. Usc.Lista() ϕ ϕCostruttore senza parametri.

Lista() Lista ϕCostruttore di copia.

inserisci() int ϕInserimento in testa alla lista.

numeroElementi() ϕ int

Restituisce il numero degli elementi contenuti nella lista.

svuota() ϕ ϕSvuota la lista.

elimina() int ϕElimina un elemento dalla lista, se presente.

toString() ϕ String

Restituisce in forma testuale la rappresentazione della strutturacostituita da tutti gli elementi contenuti nella lista.

11

EL. Esercizi su liste 12

ricerca() int boolean

Predicato indicante la presenta di un elemento.

Si realizzi una classe Main dotata del metodo public static void main()

che permetta di e�ettuare il collaudo della struttura dati realizzata.

EL.2 Somma Elementi

Soluzione a pag. 52

Dotare la classe Lista (vedi EL.1) del metodo somma() secondo la seguentespeci�ca.

Nome Param. Ingr. Param. Usc.somma() ϕ int

Restituisce la somma degli elementi presenti nella lista.

EL.3 Coda Pari

Soluzione a pag. 53

Dotare la classe Lista (vedi EL.1) del metodo codaPari(), secondo laseguente interfaccia.

Nome Param. Ingr. Param. Usc.codaPari() ϕ boolean

Restituisce true se l'elemento in coda è pari, false altrimenti.

EL.4 Min e Max

Soluzione a pag. 54

Dotare la classe Lista (vedi EL.1) del metodo minMax() secondo la seguentespeci�ca.

Nome Param. Ingr. Param. Usc.minMax() ϕ int,int

Restituisce gli elementi minimo e massimo all'interno della lista. Incaso di lista vuota l'uscita di questo metodo è non speci�cata.


EL.5 Lista Statica

Soluzione a pag. 54

Si realizzi la struttura dati Lista secondo un approccio all'allocazione dellamemoria di tipo statico. Il tipo degli elementi contenuti sia uguale al tipoint del linguaggio. La lista sia dotata dei metodi riportati di seguito.

Nome Param. Ingr. Param. Usc.Lista() ϕ ϕCostruttore.

inserisciInCoda() int ϕInserisce un elemento in coda alla lista.


count() ϕ int

Restituisce il numero degli elementi contenuti nella lista.


Restituisce una stringa contenente tutti gli elementi della lista.

Nessun metodo della classe Lista può utilizzare le funzionalità di stampa(System.out).

EL.6 È Ordinata

Soluzione a pag. 55

Dotare la classe Lista (vedi EL.5) del metodo eOrdinata(), secondo laseguente interfaccia.

Nome Param. Ingr. Param. Usc.eOrdinata() ϕ boolean

Restituisce true se la lista è ordinata secondo la relazione diordinamento crescente per gli interi, false altrimenti.


EL.7 Elimina Tutti

Soluzione a pag. 56

Dotare la classe Lista (vedi EL.5) del metodo eliminaTutti(), secondo laseguente interfaccia.

Nome Param. Ingr. Param. Usc.eliminaTutti() int int

Elimina tutte le occorrenze dell'elemento speci�cato presenti nellalista. Restituisce il numero di occorrenze eliminate.

EL.8 Elimina Ultimi

Soluzione a pag. 57

Dotare la classe Lista (vedi EL.1) dei metodi le cui interfacce sono riportatedi seguito.

Nome Param. Ingr. Param. Usc.eliminaUltimi() int int

Elimina dalla lista gli ultimi n elementi, con n pari al valore delparametro di ingresso. Il valore restituito è pari al numero di elementie�ettivamente eliminati dalla lista.

lasciaPrimi() int int

Elimina dalla lista tutti gli elementi tranne i primi n, con n pari alvalore del parametro di ingresso. Il valore restituito è pari al numerodi elementi e�ettivamente eliminati dalla lista.

EL.9 Somma Coda

Soluzione a pag. 58

Dotare la classe Lista (vedi EL.1) del metodo sommaCoda(), secondo laseguente interfaccia.

Nome Param. Ingr. Param. Usc.sommaCoda() ϕ ϕSomma a tutti gli elementi della lista il valore dell'elemento di coda.


EL.10 Sposta Testa in Coda

Soluzione a pag. 59

Dotare la classe Lista (vedi EL.1) del metodo spostaTestaInCoda(), se-condo la seguente interfaccia.

Nome Param. Ingr. Param. Usc.spostaTestaInCoda() ϕ boolean

Sposta in coda alla lista l'elemento di testa. Il metodo restituiscetrue se lo spostamento è e�ettuato, false altrimenti.

EL.11 Elimina Pari e Dispari

Soluzione a pag. 60

Dotare la classe Lista (vedi EL.1) dei metodi eliminaElPostoPari() edeliminaElPostoDispari(), secondo la seguente interfaccia.

Nome Param. Ingr. Param. Usc.eliminaElPostoPari() ϕ int

Elimina dalla lista tutti gli elementi di posto pari (0, 2, 4, ...).Restituisce il numero di elementi eliminati.

eliminaElPostoDispari() ϕ int

Elimina dalla lista tutti gli elementi di posto dispari (1, 3, 5, ...).Restituisce il numero di elementi eliminati.

EL.12 Lista Doppiamente Collegata

Soluzione a pag. 61

Si realizzi in linguaggio C++ il tipo di dato astratto Lista mediante uso delcostrutto class del linguaggio. L'implementazione deve essere realizzata me-diante puntatori ed allocazione dinamica della memoria secondo l'approcciodi lista doppiamente collegata. Ogni elemento, cioè, punta contemporanea-mente al precedente ed al successivo (vedi Figura EL.1). Gli elementi dellalista siano uguali al tipo int del linguaggio.

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe Lista.


el el el

first last

Figura EL.1: Struttura della lista doppiamente collegata

Nome Param. Ingr. Param. Usc.Lista() ϕ ϕCostruttore.

inserisci() int ϕInserisce un elemento in coda alla lista.


count() ϕ int

Conta gli elementi contenuti nella lista.

stampaDiretta() ϕ String

Restituisce una stringa contenente tutti gli elementi della lista,dall'elemento di testa all'elemento di coda.

stampaInversa() ϕ String

Restituisce una stringa contenente tutti gli elementi della lista,dall'elemento di coda all'elemento di testa.

stampaAlternata() ϕ String

Restituisce una stringa con il contenuto della lista nel seguente ordi-ne: primo elemento, ultimo elemento, secondo elemento, penultimoelemento, terzo elemento, terzultimo elemento...

Nessun metodo della classe Lista può utilizzare le funzionalità di stampa(System.out).

Si realizzi una funzione main() che permetta di e�ettuare il collaudo dellastruttura dati realizzata.


EL.13 Ribalta

Soluzione a pag. 64

Dotare la classe Lista (vedi EL.1) del metodo ribalta() secondo la seguentespeci�ca.

Nome Param. Ingr. Param. Usc.ribalta() ϕ ϕRibalta la posizione di tutti gli elementi della lista. Alla chiamata ditale metodo il primo elemento diventa l'ultimo, il secondo diventa ilpenultimo. . . l'ultimo diventa il primo.

Capitolo EA

Esercizi su alberi binari

EA.1 Albero Binario

Soluzione a pag. 67

Realizzare la classe AlberoBinario. Il tipo TElem dei suoi elementi sia iltipo int e gli elementi risultino ordinati secondo la relazione di ordinamentocrescente per gli interi. L'implementazione di tutti i metodi sia basata suappositi metodi ricorsivi. L'interfaccia della classe sia la seguente.

Nome Param. Ingr. Param. Usc.AlberoBinario() ϕ ϕCostruttore della struttura.

AlberoBinario() AlberoBinario ϕCostruttore di copia.

aggiungiElem() int ϕMetodo di aggiunta di un elemento all'albero.

inAlb() int boolean

Ricerca un elemento nell'albero. Restituisce true nel caso in cuil'elemento speci�cato sia presente nell'albero, false altrimenti.

elimina() int ϕElimina l'elemento speci�cato dall'albero.

svuota() ϕ ϕSvuota la struttura.

18

EA. Esercizi su alberi binari 19

preOrdine() ϕ String

E�ettua una visita in pre-ordine dell'albero, restituendo in unastringa tutti gli elementi.

postOrdine() ϕ String

E�ettua una visita in post-ordine dell'albero, restituendo in unastringa tutti gli elementi.

inOrdine() ϕ String

E�ettua una visita in ordine dell'albero, restituendo in una stringatutti gli elementi.

Si realizzi una classe Main dotata di un metodo main() che permetta die�ettuare il collaudo della struttura dati realizzata.

Nessuno dei metodi della classe può operare con i canali di input/output(per es. System.out). L'interfacciamento con l'utente per la lettura e lavisualizzazione dei dati sono concessi esclusivamente all'interno della classeMain.

EA.2 Numero Elementi

Soluzione a pag. 72

Dotare la classe AlberoBinario (vedi EA.1) del metodo numElem() secondola seguente speci�ca.

Nome Param. Ingr. Param. Usc.numElem() ϕ int

Restituisce il numero degli elementi presenti nell'albero.

EA.3 Occorrenze

Soluzione a pag. 73

Dotare la classe AlberoBinario (vedi EA.1) del metodo occorrenze(),secondo la seguente interfaccia.

Nome Param. Ingr. Param. Usc.occorrenze() int int

Restituisce le occorrenze dell'elemento speci�cato nell'albero.


EA.4 Occorrenza Massima

Soluzione a pag. 73

Modi�care la classe AlberoBinario (vedi EA.1) per prevedere un'occorren-za massima degli elementi in esso inseriti. Più precisamente, il costruttoredeve accettare come parametro di ingresso un numero intero positivo (per es.occMax); l'inserimento di un nuovo elemento nell'albero deve andare a buon�ne solo se tale elemento è presente con occorrenza minore di occMax.

Di seguito è riportata la speci�ca dei due metodi pubblici da implementareper la classe AlberoBinario.

Nome Param. Ingr. Param. Usc.AlberoBinario() int ϕCostruttore con parametro di ingresso di tipo intero non negativo. Ilparametro di ingresso rappresenta l'occorrenza massima con cui glielementi potranno essere presenti nell'albero.

aggiungiElem() int boolean

Inserisce l'elemento speci�cato nell'albero solo se esso è presen-te con occorrenza minore dell'occorrenza massima speci�cata nelcostruttore.Il metodo restituisce true o false a seconda che l'inserimento siaavvenuto o meno.

EA.5 Profondità Limitata

Soluzione a pag. 75

Modi�care la classe AlberoBinario (vedi EA.1) perché non superi una pro-fondità massima durante il suo utilizzo. La profondità massima raggiungibileè indicata al costruttore dell'albero come parametro di ingresso.

Di seguito è riportata la speci�ca dei due nuovi metodi pubblici da im-plementare per la classe AlberoBinario.

Nome Param. Ingr. Param. Usc.AlberoBinario() int ϕCostruttore con parametro intero non negativo. Il parametro di in-gresso indica la massima profondità che l'albero può assumere duranteil suo ciclo di vita.


inserisci() int boolean

Inserisce in maniera ordinata l'elemento speci�cato nell'albero solo sel'inserimento non comporta il superamento della massima profonditàprevista per l'albero. Il metodo restituisce true se l'elemento è statoinserito nell'albero, false altrimenti.

EA.6 Somma

Soluzione a pag. 77

Dotare la classe AlberoBinario (vedi EA.1) del metodo somma() secondo laseguente speci�ca.

Nome Param. Ingr. Param. Usc.somma() int ϕSomma ad ogni elemento dell'albero il valore intero speci�cato comeparametro di ingresso.

EA.7 Sostituisci

Soluzione a pag. 77

Dotare la classe AlberoBinario (vedi EA.1) del metodo sostituisci()

secondo la seguente speci�ca.

Nome Param. Ingr. Param. Usc.sostituisci() int,int int

Detti i e j i parametri di ingresso al metodo, sostituisce tutte leoccorrenze dell'elemento i con l'elemento j. Restituisce il numero disostituzioni e�ettuate.

N.B.: questo metodo in generale non preserva la proprietà di ordinamentodell'albero. Si assuma comunque che questo metodo agisca sempre su unalbero ordinato.

EA.8 Conta Min e Max

Soluzione a pag. 77

Dotare la classe AlberoBinario (vedi EA.1) del metodo contaMinMax(),secondo la seguente speci�ca.


Nome Param. Ingr. Param. Usc.contaMinMax() int,int int

Restituisce il numero degli elementi presenti nell'albero il cui valoreè compreso tra gli interi min e max passati in ingresso al metodo,estremi inclusi.

EA.9 Profondità Maggiore di Due

Soluzione a pag. 78

Dotare la classe AlberoBinario (vedi EA.1) del metodo profMaggioreDi-

Due() secondo la seguente speci�ca.

Nome Param. Ingr. Param. Usc.profMaggioreDiDue() ϕ boolean

Predicato che indica se la profondità dell'albero è strettamente mag-giore di 2. Restituisce true nel caso in cui la condizione sia veri�cata,false altrimenti.

EA.10 Profondita Maggiore Di

Soluzione a pag. 79

Dotare la classe AlberoBinario (vedi EA.1) del metodo profMaggioreDi()


Nome Param. Ingr. Param. Usc.profMaggioreDi() int boolean

Predicato che indica se la profondità dell'albero è strettamente mag-giore del valore intero rappresentato dal parametro di ingresso. Re-stituisce true nel caso in cui la condizione sia veri�cata, false

altrimenti.

EA.11 Profondità Massima

Soluzione a pag. 79

Dotare la classe AlberoBinario (vedi EA.1) del metodo profondita(),secondo la seguente interfaccia.


Nome Param. Ingr. Param. Usc.profondita() int int,boolean

Restituisce la profondità dell'elemento speci�cato dal parametro diingresso. In caso di occorrenze multiple, restituisce la profonditàmassima. Restituisce inoltre un valore booleano che informa se taleelemento è o meno una foglia dell'albero. Nel caso in cui l'elementonon fosse presente nell'albero, il metodo restituisce il valore −1.

EA.12 Somma Livello

Soluzione a pag. 80

Dotare la classe AlberoBinario (vedi EA.1) del metodo sommaLivello()


Nome Param. Ingr. Param. Usc.sommaLivello() int ϕSomma ad ogni elemento dell'albero un valore intero pari al livellodel corrispondente nodo. Per es.: al nodo radice verrà aggiunto 1, aisuoi �gli diretti 2,. . . ecc.

N.B.: questo metodo in generale non preserva la proprietà di ordinamentodell'albero.

EA.13 Eliminazione Foglia

Soluzione a pag. 81

Dotare la classe AlberoBinario (vedi EA.1) del metodo eliminaFoglia()


Nome Param. Ingr. Param. Usc.eliminaFoglia() int boolean

Elimina dall'albero l'elemento speci�cato se e solo se esso è presenteed è una foglia. Il metodo restituisce true in caso di eliminazionee�ettuata, false altrimenti.

EA.14 Eliminazione Foglie

Soluzione a pag. 82

Dotare la classe AlberoBinario (vedi EA.1) del metodo eliminaFoglie()



Nome Param. Ingr. Param. Usc.eliminaFoglie() ϕ int

Elimina dall'albero tutte le foglie. Restituisce il numero di elementieliminati.

EA.15 Cerca Foglia

Soluzione a pag. 82

Dotare la classe AlberoBinario (vedi EA.1) dei due metodi le cui interfaccesono riportate di seguito.

Nome Param. Ingr. Param. Usc.cercaFoglia() int boolean,

boolean

Predicato che indica se l'elemento speci�cato dal parametro di ingres-so è presente nell'albero. Nel caso in cui sia presente, il metodo resti-tuisce anche un ulteriore valore booleano che indica se esiste almenouna foglia contenente il valore speci�cato.

cercaNodo() int boolean,

boolean

Predicato che indica se l'elemento speci�cato dal parametro di ingres-so è presente nell'albero. Nel caso in cui sia presente, il metodo resti-tuisce anche un ulteriore valore booleano che indica se esiste almenoun nodo contenente il valore speci�cato.

EA.16 Operatore di Confronto

Soluzione a pag. 85

Implementare il metodo equal() della classe AlberoBinario (vedi EA.1).Tale operatore viene invocato come mostrato nell'esempio di seguito:

boolean sonoUgual i = a . equa l s ( obj ) ;

dove a è l'istanza della classe AlberoBinario sulla quale avviene l'invoca-zione. Si noti che obj è un'istanza della classe base Object (da cui eredi-tano tutte le classi Java), coerentemente con l'implementazione del metodoequals() già presente nella classe base, di cui questa rappresenta di fatto unoverride.

Di seguito si riporta la speci�ca del metodo da realizzare.


Nome Param. Ingr. Param. Usc.equals() AlberoBinario,

Object

bool

È l'operatore di confronto tra un albero ed un generico ogget-to. Fornisce true se l'oggetto in ingresso è un'istanza della classeAlberoBinario uguale (anche strutturalmente) all'albero che ricevela chiamata, false altrimenti.

EA.17 Conta Nodi non Foglia

Soluzione a pag. 86

Dotare la classe AlberoBinario (vedi EA.1) del metodo contaNodiNon-

Foglia() secondo la seguente speci�ca.

Nome Param. Ingr. Param. Usc.contaNodiNonFoglia() ϕ int

Restituisce il numero di nodi non foglia presenti nell'albero.

EA.18 Conta Nodi

Soluzione a pag. 86

Dotare la classe AlberoBinario (vedi EA.1) del metodo contaNodi() secon-do la seguente speci�ca.

Nome Param. Ingr. Param. Usc.contaNodi() ϕ int, int, int

Restituisce il numero di nodi dell'albero aventi 0, 1 e 2 �gli, rispetti-vamente.

EA.19 Conta Nodi Sottoalbero

Soluzione a pag. 87

Dotare la classe AlberoBinario (vedi EA.1) dei metodi aventi l'interfacciaspeci�cata di seguito.


Nome Param. Ingr. Param. Usc.contaNodiSottoalb_Min() int int

Conta i nodi del sottoalbero avente come radice l'elemento il cui va-lore è pari al valore del parametro di ingresso. Nel caso di occorrenzemultiple, la radice viene individuata nell'elemento posizionato al livel-lo dell'albero minore (più in alto) rispetto a tutti gli altri. In caso diassenza dell'elemento, il metodo restituisce null. Si consideri anchela radice del sottoalbero nel conteggio degli elementi.

contaNodiSottoalb_Max() int int

Conta i nodi del sottoalbero avente come radice l'elemento il cui va-lore è pari al valore del parametro di ingresso. Nel caso di occorrenzemultiple, la radice viene individuata nell'elemento posizionato al li-vello dell'albero maggiore (più in basso) rispetto a tutti gli altri. Incaso di assenza dell'elemento, il metodo restituisce null. Si considerianche la radice del sottoalbero nel conteggio degli elementi.

EA.20 SommaMinMax

Soluzione a pag. 89

Dotare la classe AlberoBinario (vedi EA.1) del metodo sommaMinMax()


Nome Param. Ingr. Param. Usc.sommaMinMax() ϕ int

Restituisce la somma dell'elemento minimo e dell'elemento massimocontenuti nell'albero.

Capitolo EP

Esercizi su pile

EP.1 Push Greater

Soluzione a pag. 91

Si realizzi in linguaggio Java il tipo di dato astratto Pila mediante uso delcostrutto class del linguaggio e ricorrendo ad un'implementazione dinamica.Il tipo degli elementi della pila sia il tipo int.

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe Pila.

Nome Param. Ingr. Param. Usc.Pila() ϕ ϕCostruttore senza parametri.

push() int ϕAggiunge sulla pila l'elemento speci�cato.

pushGreater() int boolean

Aggiunge sulla pila l'elemento speci�cato esclusivamente se esso èmaggiore dell'elemento di testa corrente. Nel caso in cui la pila siavuota l'aggiunta è sempre eseguita. Restituisce true oppure false aseconda che l'aggiunta sia stata eseguita oppure no.

top() ϕ int

Restituisce l'elemento di testa corrente della pila (ma non lo estrae).In caso di pila vuota il comportamento di questo metodo è nonspeci�cato.

27

EP. Esercizi su pile 28

pop() ϕ int

Estrae e restituisce l'elemento di testa corrente della pila. In caso dipila vuota il comportamento di questo metodo è non speci�cato.

svuota() ϕ ϕSvuota la pila.

count() ϕ int

Restituisce il numero di elementi presenti nella pila.

empty() ϕ boolean

Predicato vero se la pila è vuota, falso altrimenti.



EP.2 Push If

Soluzione a pag. 94

Si modi�chi la classe Pila dell'esercizio �EP.1 per renderla conforme aimetodi speci�cati di seguito:

Nome Param. Ingr. Param. Usc.Pila() int ϕCostruttore con parametro. Il parametro di ingresso indica il numerodi inserimenti massimi consecutivi possibili (vedi anche speci�che delmetodo push()).

push() int boolean

Aggiunge sulla pila l'elemento speci�cato se non è stato superato ilnumero massimo di inserimenti consecutivi (cioè non intervallati daalcun prelievo con il metodo pop() o da uno svuotamento completodella lista con il metodo svuota()). Nel caso in cui tale numero, spe-ci�cato dal parametro di ingresso del costruttore, sia stato superato,l'inserimento non avviene ed il metodo restituisce false. Altrimentirestituisce true.

EP. Esercizi su pile 29

pop() ϕ int

Estrae e restituisce l'elemento di testa corrente della pila. Azzera ilconteggio degli inserimenti. In caso di pila vuota il comportamentodi questo metodo è non speci�cato.

svuota() ϕ ϕSvuota la pila ed azzera il conteggio degli inserimenti.

Capitolo EC

Esercizi su code

EC.1 Coda

Soluzione a pag. 96

Si realizzi in linguaggio Java il tipo di dato astratto Coda mediante uso delcostrutto class del linguaggio e ricorrendo ad un'implementazione dinamica.Il tipo degli elementi della coda sia il tipo int.

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe Coda.

Nome Param. Ingr. Param. Usc.Coda() ϕ ϕCostruttore senza parametri.

push() int ϕAccoda l'elemento speci�cato.

top() ϕ int

Restituisce l'elemento di testa corrente della coda (ma non lo estrae).In caso di coda vuota il comportamento di questo metodo è nonspeci�cato.

pop() ϕ int

Estrae e restituisce l'elemento di testa corrente presente in coda.In caso di coda vuota il comportamento di questo metodo è nonspeci�cato.

somma() ϕ int

Restituisce la somma di tutti gli elementi presenti in coda.

30

EC. Esercizi su code 31

svuota() ϕ ϕSvuota la coda.

count() ϕ int

Restituisce il numero di elementi presenti nella coda.

empty() ϕ boolean

Predicato vero se la coda è vuota, falso altrimenti.



EC.2 Coda con Perdite

Soluzione a pag. 99

Si realizzi in linguaggio Java il tipo di dato astratto Coda mediante uso delcostrutto class del linguaggio. Il tipo degli elementi della coda sia il tipoint.


Nome Param. Ingr. Param. Usc.Coda() int ϕCostruttore con parametro intero. Il parametro indica il numero mas-simo di posti in coda, oltre il quale non deve essere possibile inserireulteriori elementi.

push() int boolean

Accoda l'elemento speci�cato. Restituisce true in caso di elementoaccodato, false altrimenti.

top() ϕ int

Restituisce l'elemento di testa corrente della coda (ma non lo estrae).In caso di coda vuota il comportamento di questo metodo è nonspeci�cato.


pop() ϕ int

Estrae e restituisce l'elemento di testa corrente presente in coda.In caso di coda vuota il comportamento di questo metodo è nonspeci�cato.

pop() int int

Estrae tanti elementi quanti speci�cati dal parametro di ingresso erestituisce solo il primo di questi, cioè l'elemento presente in testaprecedentemente alla chiamata al metodo. Rappresenta una versioneoverloaded del metodo precedente. Nel caso in cui la coda risultivuota all'atto della chiamata al metodo, il comportamento risultanteè non speci�cato.


count() ϕ int

Restituisce il numero di elementi presenti nella coda.

empty() ϕ boolean




EC.3 Coda a Priorità

Soluzione a pag. 103

Si realizzi in linguaggio Java il tipo di dato astratto PriorityQueuemedianteuso del costrutto class del linguaggio. Il tipo degli elementi della coda sia iltipo int. La struttura permette di accodare elementi che possono avere duedi�erenti livelli di priorità: high (alta) e low (bassa). Un elemento a bassapriorità viene sempre accodato alla struttura. Un elemento a priorità alta hainvece la precedenza sugli elementi a priorità bassa, ma non sugli elementi apriorità alta eventualmente già presenti nella struttura.



Nome Param. Ingr. Param. Usc.PriorityQueue() ϕ ϕCostruttore.

pushLow() int ϕAccoda un elemento a bassa priorità.

pushHigh() int ϕAccoda un elemento ad alta priorità.

pop() ϕ int

Estrae e restituisce il primo elemento ad altà priorità o, in sua as-senza, il primo elemento a bassa priorità. In caso di coda vuota ilcomportamento di questo metodo è non speci�cato.


empty() ϕ boolean




EC.4 PopMinMax


Dotare la classe Coda (vedi EC.1) dei metodi popMax() e popMin() secondola seguente speci�ca.

Nome Param. Ingr. Param. Usc.popMax() int int

Detto n il valore del parametro di ingresso di tipo intero, il metodoestrae i primi n valori di testa della struttura e restituisce il massimotra questi. In caso di coda vuota il comportamento di questo metodoè non speci�cato.


popMin() int int

Detto n il valore del parametro di ingresso di tipo intero, il metodoestrae i primi n valori di testa della struttura e restituisce il minimotra questi. In caso di coda vuota il comportamento di questo metodoè non speci�cato.

Capitolo EX

Altri esercizi

EX.1 Accumulatore


Si realizzi la classe Accumulatore conforme all'interfaccia seguente.

Nome Param. Ingr. Param. Usc.Accumulatore() ϕ ϕCostruttore della classe.

add() float ϕAggiunge all'accumulaotre il valore speci�cato dal parametro diingresso.

reset() ϕ ϕAzzera l'accumulatore.

getValue() ϕ float

Restituisce il valore corrente dell'accumulatore.

EX.2 Cifratore


Implementare la classe Cifratore con la capacità di cifrare stringhe di ca-ratteri attraverso uno slittamento del codice ASCII dei caratteri componentila stringa (c.d. codice di Cesare). L'interfaccia della classe sia la seguente.

35

EX. Altri esercizi 36

Nome Param. Ingr. Param. Usc.Cifratore() int ϕCostruttore della classe. Imposta la costante intera di slittamentoche il cifratore utilizza per crittografare le stringhe.

cifra() String String

Metodo di cifratura. Accetta la stringa da cifrare e ne restituisce laversione cifrata. La cifratura consiste in uno slittamento (shift) deicodici ASCII di ogni singolo carattere della stringa.

decifra() String String

Metodo di decifratura. Accetta la stringa cifrata attraverso il metodoCifra() e ne restituisce nuovamente la versione decifrata.

EX.3 Lista Della Spesa


Si realizzi in linguaggio Java il tipo di dato astratto ListaDellaSpesa me-diante uso del costrutto class del linguaggio e ricorrendo ad un'implementa-zione dinamica. Gli elementi della lista siano del tipo Articolo, che contienegli attributi nome e quantità, di tipo String e float, rispettivamente.

Di seguito si riporta la speci�ca dei metodi da implementare.

Nome Param. Ingr. Param. Usc.ListaDellaSpesa() ϕ ϕCostruttore.

aggiungi() String, float float

Aggiunge alla lista la quantità speci�cata in corrispondenza dell'ar-ticolo indicato. Il metodo restituisce la quantità con cui l'articolospeci�cato è presente nella lista in seguito all'aggiunta.

elimina() String boolean

Elimina dalla lista l'elemento avente il nome speci�cato (se presente).Il metodo restituisce true se è stato cancellato un elemento, falsealtrimenti.

getQuantita() String float

Restituisce la quantità dell'elemento presente nella lista ed avente ilnome speci�cato. Se l'elemento non è presente restituisce zero.


svuota() ϕ ϕSvuota la lista della spesa.


Converte in una stringa il contenuto dell'intera lista nel formatoNome1: Quantità1, Nome2: Quantità2, ....Suggerimento: si utilizzi la classe standard StringBuilder per la costruzione

incrementale della stringa da restituire.



EX.4 Predittore di Temperatura


Realizzare la classe TempPredictor che svolga la funzione di predittore ditemperatura. Tale oggetto deve essere capace di fornire una stima dellatemperatura in un certo istante futuro di tempo. La stima è operata apartire da dati presenti e passati forniti dall'utente sui valori di temperaturamisurati attraverso ipotetici sensori.

Si supponga che i tempi siano espressi con numeri interi in un ipoteticoriferimento temporale. Si supponga inoltre che la stima sia ottenuta medianteestrapolazione lineare delle ultime due temperature fornite dall'utente dellaclasse. Per esempio, se l'utente comunica all'oggetto che la temperaturaall'istante 0 è pari a 14◦ e che all'istante 5 è pari a 16◦, una richiesta dellastima della temperatura all'istante 10 produrrebbe come risultato 18◦.

Si consideri la seguente interfaccia della classe.

Nome Param. Ingr. Param. Usc.TempPredictor() int, float ϕCostruttore della classe. Accetta in ingresso una prima lettura rea-le della temperatura (il parametro float), insieme all'istante in cuiquesta è stata campionata da un ipotetico sensore (il parametro int).

setTemp() int, float ϕFornisce al predittore un ulteriore valore di temperatura campionatoed il relativo istante di campionamento.


estimateTemp() int float

Richiede al predittore di e�ettuare una stima della temperatura inun particolare istante di tempo speci�cato.

Il costruttore accetta in ingresso un primo valore della temperatura adun certo istante di tempo. In assenza di altri dati la stima sarà pari pro-prio a questo valore. Qualsiasi chiamata ad estimateTemp(), cioè, forniràcome risultato il valore di temperatura speci�cato all'atto della chiamatadel costruttore1. Successivamente l'utente comunicherà all'oggetto nuovi va-lori della temperatura attraverso ripetute chiamate al metodo setTemp(),speci�candone anche i relativi istanti di tempo.

EX.5 Contenitore


Si realizzi in linguaggio Java il tipo di dato astratto Contenitore medianteuso del costrutto class del linguaggio. Un Contenitore può contenere istanzedel tipo Oggetto, modellato con un nome (di classe String) ed un peso (ditipo float).

Inoltre, ogni contenitore può ospitare oggetti �no al raggiungimento diun peso complessivo massimo, oltre il quale nessun altro oggetto può essereospitato.

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe Contenitore.

Nome Param. Ingr. Param. Usc.Contenitore() float ϕCostruttore con parametro di tipo float. Il parametro indica ilpeso massimo raggiungibile dalla totalità degli oggetti presenti nelcontenitore.

inserisci() String, float boolean

Inserisce nel contenitore un oggetto avente il nome e il peso speci�-cato. Il metodo restituisce true se l'inserimento va a buon �ne, cioèse il peso dell'elemento da inserire non eccede la capacità residua delcontenitore, false altrimenti.

svuota() ϕ ϕSvuota il contenitori di tutti gli oggetti presenti in esso.

1Ciò permette al predittore di operare non appena divenga disponibile un primocampionamento della temperatura.


pesoComplessivo() ϕ float

Restituisce il peso complessivo raggiunto dal contenitore.

pesoResiduo() ϕ float

Restituisce il peso residuo per il raggiungimento della capacitàmassima del contenitore.

numElem() ϕ int

Restituisce il numero di oggetti presenti nel contenitore.


Stampa le coppie (nome, peso) di tutti gli oggetti presenti nelcontenitore.



EX.6 Lista Prenotazioni


Si realizzi in linguaggio Java il tipo di dato astratto ListaPrenotazioni

mediante uso del costrutto class del linguaggio. La lista deve memorizzarele prenotazioni di studenti ad un singolo generico evento. Gli elementi dellalista siano del tipo Prenotazione modellata con una matricola (di tipo int)ed un nome (di classe String).

I metodi da implementare per la classe ListaPrenotazioni siano con-formi alla seguente interfaccia.

Nome Param. Ingr. Param. Usc.ListaPrenotazioni() int ϕCostruttore con parametro intero. Il parametro indica il numero mas-simo di posti disponibili per l'evento, oltre i quali non deve esserepossibile inserire ulteriori prenotazioni.

prenota() int, String boolean

Se nella lista non è già presente alcuna altra prenotazione con lostesso numero di matricola e se ci sono posti disponibili, inserisceuna nuova prenotazione in coda alla lista. Il metodo restituisce l'esitodell'operazione.


eliminaPrenotazione() int boolean

Elimina dalla lista la prenotazione relativa al campo matricola spe-ci�cato (se presente). Il metodo restituisce true se è stato eliminatoun elemento, false altrimenti.

getPostiDisponibili() ϕ int

Restituisce il numero di posti ancora disponibili.

esistePrenotazione() int boolean

Restituisce true se esiste la prenotazione relativa al numero dimatricola speci�cato, false altrimenti.



Restituisce la rappresentazione testuale della struttura dati nelformato seguente: Matricola1: Nome1, Matricola2: Nome2,

Matricola3: Nome3, ...



EX.7 Classi�ca


Si realizzi in linguaggio Java il tipo di dato astratto Classificamediante usodel costrutto class del linguaggio. L'implementazione deve essere realizzatamediante puntatori ed allocazione dinamica della memoria. Gli elementi dellalista siano della classe Squadra, modellata con un nome (di classe String)ed un punteggio (di tipo int).

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe Classifica.

Nome Param. Ingr. Param. Usc.Classifica() ϕ ϕCostruttore.


aggiungi() Nome, int int

Se la squadra non è già presente, la aggiunge alla struttura e le as-segna il punteggio speci�cato. Nel caso di squadra già presente, ag-giunge il punteggio speci�cato a quello già totalizzato. Restituisce ilnumero di punti correntemente totalizzati dalla squadra.



Restituisce la rappresentazione testuale della struttura dati, conte-nente nome e punteggio di tutte le squadre in ordine decrescente dipunteggio.

count() ϕ int

Conta gli elementi contenuti nella struttura.



Suggerimento: l'aggiornamento di un punteggio nella struttura può essere conve-

nientemente realizzato attraverso la composizione di un'eliminazione ed un inserimento

ordinato.

EX.8 Agenzia Matrimoniale


Si realizzi in linguaggio Java il tipo di dato astratto AgenziaMatrimoniale

mediante uso del costrutto class del linguaggio. L'implementazione deveessere realizzata mediante puntatori ed allocazione dinamica della memoria.Gli elementi della lista siano di tipo Persona modellata con il nome (di classeString), il sesso (di tipo boolean) e il coniuge (di classe Persona).

Di seguito è riportata la speci�ca dei metodi pubblici da implementareper la classe AgenziaMatrimoniale.

Nome Param. Ingr. Param. Usc.AgenziaMatrimoniale() ϕ ϕCostruttore.


aggiungiPersona() String,

boolean

boolean

Aggiunge alla struttura la persona avente nome speci�cato attraversoi parametri di ingresso, e indica se è maschio (parametro di ingressobooleano pari a true) o femmina (parametro di ingresso booleanopari a false). Restituisce true in caso di inserimento avvenuto,false altrimenti (se esiste già una persona con lo stesso nome).

sposa() String, String boolean

Marca come sposate le due persone presenti nella struttura ed aven-ti nomi speci�cati dai parametri di ingresso. Restituisce l'esitodell'operazione. L'operazione fallisce nei casi seguenti:

• uno o entrambi i nomi non sono presenti nella lista;

• le persone speci�cate sono dello stesso sesso;

• una o entrambe le persone risultano già sposate.

coniugato() String boolean,

boolean

Restituisce due valori booleani. Il primo indica se il nome speci�catoè presente o meno nella lista. Se tale valore è vero, il secondo valorerestituito è pari a vero se la persona dal nome speci�cato è coniugata,falso altrimenti.

numeroSposi() ϕ int

Restituisce il numero delle persone coniugate nella struttura.

numeroCoppie() ϕ int

Restituisce il numero di coppie di sposi presenti nella struttura.



Restituisce la rappresentazione testuale della struttura.


Nessuno dei metodi della classe può operare con i canali di input/output(per es. System.out). L'interfacciamento con l'utente per la lettura e la


visualizzazione dei dati sono concessi esclusivamente all'interno della classeMain.

EX.9 Parco Pattini


La ditta Sax gestisce una pista di pattinaggio e dispone di un parco pattini.I pattini, tutti dello stesso modello, vengono �ttati ai clienti a tempo, inbase alla taglia della calzatura richiesta, che si suppone di tipo intero. Siimplementi in linguaggio Java la classe ParcoPattini utile ad una primainformatizzazione del processo di gestione della pista.

Si implementi la struttura conformemente all'interfaccia speci�cata diseguito.

Nome Param. Ingr. Param. Usc.ParcoPattini() ϕ ϕCostruttore senza parametri. Inizializza una struttura che contieneun parco pattini vuoto.

aggiungiPattini() int ϕAggiunge al parco un paio di pattini della misura speci�cata.

svuota() ϕ ϕSvuota il parco pattini.

numeroTotPattini() ϕ int

Restituisce il numero di paia di pattini che costituiscono l'interoparco.

fitta() int boolean

Marca come ��ttati� un paio di pattini della taglia speci�cata dalparametro di ingresso. Il metodo restituisce true se esiste almeno unpaio di pattini della taglia speci�cata, false altrimenti.

disponibilita() int int

Restituisce il numero di paia di pattini disponibili per la tagliaspeci�cata.

numeroPattini() int int

Restituisce il numero di paia di pattini appartenenti al parco, di datataglia (indipendentemente dal loro stato).


restituzione() int boolean

Marca nuovamente come �disponibile� un paio di pattini della tagliaspeci�cata. Il metodo restituisce true se e�ettivamente esiste unpaio di pattini della taglia speci�cata marcati come ��ttati�, falsealtrimenti.


Restituisce in formato testuale l'intero stato della struttura.



EX.10 Timer


Si realizzi la classe Timer che svolga le funzioni di cronometro. Tale og-getto deve poter gestire i messaggi START, STOP, RESET e GETTIMEcomportandosi come speci�cato dall'interfaccia seguente.

Nome Param. Ingr. Param. Usc.start() ϕ ϕAvvia il conteggio del tempo.

stop() ϕ ϕArresta il conteggio del tempo.

reset() ϕ ϕArresta ed azzera il timer.

getTime() ϕ int

Restituisce il conteggio corrente del tempo in secondi.

Nella �gura è riportato un esempio gra�co del funzionamento dell'oggetto.Si realizzi una classe Main dotata di un metodo main() che permetta di

e�ettuare il collaudo della struttura dati realizzata.Nessuno dei metodi della classe può operare con i canali di input/output

(per es. System.out). L'interfacciamento con l'utente per la lettura e lavisualizzazione dei dati sono concessi esclusivamente all'interno della classeMain.


0

GETTIME

4

0

START

10

GETTIME

15

5

GETTIME

20

10

STOP

25

GETTIME

30

15

INATTIVO

IL T

IME

R V

IEN

E C

RE

ATO

ATTIVO INATTIVO

RESET

35

GETTIME

40

0 Valori conteggio

Figura EX.1: Un esempio d'uso del timer nel tempo

Suggerimenti

• Le classi standard java.time.LocalDateTime e java.time.Durationimplementano il trattamento delle date e delle durate temporali. Con-sultando la documentazione di queste classi è possibile conoscere i ser-vizi messi da queste a disposizione. Per esempio, la chiamata al metodoLocalDateTime.now() restituisce un'istanza della classe java.time.-LocalDateTime contenente l'ora corrente del sistema.

• Il funzionamento del timer nei casi non espressamente previsti dallespeci�che sia arbitrario.

EX.11 Timer Avanzato


Con riferimento alla classe Timer dell'esercizio EX.10, si considerino le se-guenti ulteriori speci�che:

• quando il timer riceve il messaggio START, il conteggio non deveripartire sempre da 0, ma dal valore correntemente memorizzato;

• la ricezione di un messaggio START a timer attivo deve essere inin-�uente;

• la ricezione di un messaggio STOP a timer fermo deve essere inin�uente.

Modi�care, se necessario, l'implementazione del timer per rendere la clas-se conforme a queste ulteriori speci�che.


EX.12 Votazioni


Si supponga di voler gestire un exit-poll elettorale. Ad ogni intervistatoall'uscita dal seggio si chiede il partito per cui ha votato. In ogni momentobisogna poi essere in grado di dire quanti voti ha ottenuto ciascun partitoe qual è la distribuzione dei voti tra i partiti. Mediante l'uso del costruttoclass del linguaggio Java, si realizzi una struttura dati adatta all'uopo. Sisupponga, per semplicità, che ogni partito è identi�cato con un codice intero,e si ignorino i voti bianchi e nulli. Di seguito è riportata la speci�ca dei metodipubblici da implementare per la classe Votazioni.

Nome Param. Ingr. Param. Usc.Votazioni() ϕ ϕCostruttore.

aggiungiVoto() int int

Aggiunge un voto al partito avente il codice speci�cato dal parame-tro di ingresso. Restituisce il numero di voti accumulati �no a quelmomento dal partito.


getVotiPartito() int int

Restituisce il numero di voti ottenuto dal partito avente il codicespeci�cato dal parametro di ingresso.

getNumeroVoti() ϕ int

Restituisce il numero totale di voti.


Restituisce in formato testuale una rappresentazione dello stato dellastruttura dati.



Parte II

Soluzioni

47

Capitolo SL

Soluzioni degli esercizi su liste

SL.1 Lista Semplicemente Collegata

Traccia a pag. 11

Di seguito si riporta il �le Lista.java contenente la de�nizione della clas-se Lista. Come richiesto dalla traccia, la lista è semplicemente collegata ele sue celle sono rappresentate dalla classe Record, de�nita all'interno dellaclasse Lista. Grazie al modi�catore di accesso private, la classe Record

resta invisibile agli utenti della classe contenitore. Dall'interfaccia della clas-se Lista non traspare la sua natura di lista semplicemente collegata. Idettagli implementativi restano pertanto nascosti, nel rispetto del principiodell'information hiding.

In questa implementazione il costruttore dovrebbe avere il compito diinizializzare le variabili-membro della classe, che in questo caso sono first

e numEl. L'inizializzazione dovrebbe consistere nelle seguenti due istruzioni:

f i r s t = null ;numEl = 0 ;

In assenza di queste due linee, però, le speci�che del linguaggio Javaindicano che first viene inizializzato a null (default per gli oggetti) e numEla 0 (default per gli interi). Tale inizializzazione è pertanto super�ua e ilcostruttore può rimanere vuoto.

File Lista.java

public class L i s ta {private class Record {

int e l ;Record succ ;

}

48

SL. Soluzioni degli esercizi su liste 49

private Record f i r s t ;private int numEl ;

public L i s ta ( ) {/∗ Cos t ru t tore vuoto . Si vedano i commenti a l l a s o l u z i one . ∗/

}

public L i s ta ( L i s t a l 2 ) {// Questo c o s t r u t t o r e deve creare l a l i s t a ad// immagine e somig l ianza de l model lo l 2 .

i f ( l 2 . f i r s t == null ) // se i l model lo è una l i s t a vuota ,// ho g ià f i n i t o . . .

return ; // . . . ed esco ant ic ipa tamente .

i n s e r i s c i ( l 2 . f i r s t . e l ) ; // i n s e r i s c o in t h i s i l primo e l .// d i l 2

Record p = this . f i r s t ; // creo un puntatore a l mio primo// elemento

Record p2 = l2 . f i r s t . succ ; // creo un puntatore a l// secondo elemento d i l 2// ( che po t rebbe e s s e r e anche// nu l l )

while ( p2 != null ) { // mentre l ' e lemento puntato in l 2// non è nu l l

p . succ = new Record ( ) ; // creo un nuovo record e l o// imposto come succe s s i vo// d e l l ' e lemento puntato da p

p . succ . e l = p2 . e l ; // g l i assegno i l va l o r ep = p . succ ; // spos to p in avant i per f a r l o puntare

// a l l ' e lemento appena crea top2 = p2 . succ ; // spos to p2 in avant i per puntare

// a l l ' e lemento d i l 2 succe s s i vo}this . numEl = l2 . numEl ; // imposto i l mio numEl a l numEl

// d i l 2}

public void i n s e r i s c i ( int e l ) {Record p = new Record ( ) ; // Creo una nuova area d i

// memoria n e l l ' heap , d e s t i na t a// a contenere un nuovo record

p . e l = e l ; // imposto i l v a l o r e d e l l ' e lementop . succ = f i r s t ; // punto a l l ' e lemento succe s s i vo ( che è

// i l primo )f i r s t = p ; // i l "nuovo primo" è l ' e lemento appena

// crea to .numEl++; // Incremento i l numero d e g l i e l ement i .

}

public int numeroElementi ( ) {return numEl ;

}

public void svuota ( ) {// Lo svuotamento con s i s t e n e l l ' impostare i l puntatore// f i r s t a nu l l ed azzerare i l numero d e g l i e l ement i .f i r s t = null ;numEl = 0 ;

}


public void e l im ina ( int e l ) {// Questa ver s ione d i Elimina () e l imina l ' e ven tua l e// prima occorrenza d e l l ' e lemento e l .

// Se l a l i s t a è vuota , esco senza fa r nu l l ai f ( f i r s t == null )

return ;

// Si t r a t t a diversamente i l caso in cui l ' e lemento da// e l iminare s i a i l primo da q u e l l o in cui è un// elemento succe s s i vo a l primo .

i f ( f i r s t . e l == e l ) { // L ' elemento da e l iminare è i l// primo?

f i r s t = f i r s t . succ ; // l o e l imino !this . numEl−−; // e decremento i l numero d e g l i

// e lement i .} else { // a l t r imen t i , scorro l a l i s t a in cerca

// d e l l ' e lementoRecord p = f i r s t ;while (p . succ != null )

// mentre e s i s t e un elemento// succ . a q u e l l o puntato . . .i f (p . succ . e l == e l ) { // . . . se l ' e lemento

// succe s s i vo è q u e l l o da// canc e l l a r e . . .

p . succ = p . succ . succ ; // . . . l o rimuovo d a l l a// catena . . .

this . numEl−−; // . . . decremento i l numero// d e g l i e l ement i . . .

break ; // . . . e interrompo i l c i c l o wh i l e .} else

p = p . succ ; // . . . a l t r imen t i punto con p// a l l ' e lemento succe s s i vo .

}}

public St r ing toS t r i ng ( ) {//La c l a s s e java . lang . S t r ingBu i l d e r c i consente d i c o s t r u i r e// agevolmente l a s t r i n ga contenente t u t t i g l i e l ement i .St r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;

Record p = f i r s t ; // punto con p a l primo recordwhile (p != null ) { // mentre p punta ad un elemento . . .

sb . append (p . e l + " " ) ; // . . . l o stampo . . .p = p . succ ; // ed avanzo con p a l suc ce s s i vo elemento .

} // Prima o poi p d i ven t e rà nu l l .

return sb . t oS t r i ng ( ) ;}

public boolean r i c e r c a ( int e l ) {Record p = f i r s t ; // punto con p a l primo recordwhile (p != null )

// mentre p punta ad un elemento . . .i f (p . e l == e l ) // . . . se l ' elem . è q u e l l o cerca to . . .

return true ; // r e t r i t u i s c i s u b i t o t rue ed e s c i// ant ic ipa tamente

else

p = p . succ ; // a l t r imen t i avanzo con p a l// succe s s i vo elemento .


return fa l se ; // Se sono a r r i v a t o qui , p punta a nu l l// ( f i n e d e l l a catena ) e l ' e lemento non è// s t a t o t rova to . Re s t i t u i s c o f a l s e .

}}

Il modulo Main.java, di seguito riportato, consente di e�ettuare il testingdi tutte le funzionalità disponibili nella classe Lista. L'interfacciamento conl'utente è testuale e basato su console.

File Main.java

import java . u t i l . Scanner ; // importaz ione de l package per l ' uso// d e l l ' o g ge t t o scanner

public class Main {// l ' o g ge t t o scanner a iu ta a l e g g e r e da t i i n s e r i t i s u l l o// standard−input ( t a s t i e r a )private stat ic Scanner scanner = new Scanner ( System . in ) ;

public stat ic void main ( St r ing [ ] a rgs ) {L i s t a l = new Li s ta ( ) ;int i ;

do {stampaMenu ( ) ;i = scanner . next Int ( ) ;switch ( i ) {case 1 :

i n s e r i s c i ( l ) ;break ;

case 2 :r i c e r c a ( l ) ;break ;

case 3 :e l im ina ( l ) ;break ;

case 4 :svuota ( l ) ;break ;

case 5 :stampa ( l ) ;break ;

case 6 :numeroElementi ( l ) ;break ;

case 7 :c op i aL i s t a ( l ) ;break ;

case 8 :break ;

default :System . out . p r i n t l n ( " Sc e l t a non va l i da . " ) ;

}} while ( i != 8 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . I n s e r i s c i " ) ;


System . out . p r i n t l n ( " 2 . Ricerca " ) ;System . out . p r i n t l n ( " 3 . Elimina" ) ;System . out . p r i n t l n ( " 4 . Svuota" ) ;System . out . p r i n t l n ( " 5 . Stampa" ) ;System . out . p r i n t l n ( " 6 . NumeroElementi" ) ;System . out . p r i n t l n ( " 7 . CopiaLista " ) ;System . out . p r i n t l n ( " 8 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

private stat ic void i n s e r i s c i ( L i s t a l ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;l . i n s e r i s c i ( e l ) ;

}

private stat ic void r i c e r c a ( L i s t a l ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;i f ( l . r i c e r c a ( e l ) )

System . out . p r i n t l n ( "Trovato . " ) ;else

System . out . p r i n t l n ( "Non trovato . " ) ;}

private stat ic void e l im ina ( L i s t a l ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;l . e l im ina ( e l ) ;

}

private stat ic void svuota ( L i s t a l ) {System . out . p r i n t l n ( "Svuotamento l i s t a " ) ;l . svuota ( ) ;

}

private stat ic void stampa ( L i s t a l ) {System . out . p r i n t ( "Stampa : " ) ;System . out . p r i n t l n ( l . t oS t r i ng ( ) ) ;

}

private stat ic void numeroElementi ( L i s t a l ) {System . out . p r i n t l n ( "Numero e l ement i : " +

l . numeroElementi ( ) ) ;}

private stat ic void cop i aL i s t a ( L i s t a l ) {L i s t a l c op i a = new Li s ta ( l ) ;System . out . p r i n t l n ( " L i s t a cop ia ta . La nuova l i s t a " +

" cont i ene : " ) ;l c op i a . t oS t r i ng ( ) ;

}}

SL.2 Somma Elementi

Traccia a pag. 12


Il metodo e�ettua una visita completa della lista. Ad ogni iterazionesomma ad un accumulatore il valore della cella correntemente visitata.

public int somma( ) {int somma = 0 ; // accumulatoreRecord p = f i r s t ; // i n i z i a l i z z o i l puntatore a l primo

// elemento .while (p != null ) { // Mentre p punta ad una c e l l a . . .

somma += p . e l ; // . . . accumulo i l va l o r e puntato . . .p = p . succ ; // . . . ed avanzo a l l ' e lemento succe s s i vo

}

return somma ; // r e s t i t u i s c o i l va l o r e d e l l ' accumulatore}

SL.3 Coda Pari

Traccia a pag. 12

Per valutare se l'elemento di coda è pari è possibile adottare un approccioiterativo che, a partire dall'elemento di testa, ricerchi l'ultimo elemento e nerestituisca il valore.

private Record getPuntCoda ( ) {i f ( f i r s t == null ) // se l a coda è vuota . . .

return null ; // . . . r e s t i t u i s c e nu l l

Record p = f i r s t ;while (p . succ != null )

// a l t r imen t i cerca l a codap = p . succ ;

return p ; // e l a r e s t i t u i s c e}

public boolean codaPari ( ) {Record p = getPuntCoda ( ) ;// Re s t i t u i s c o t rue se p è d i v e r so da nu l l AND// se l ' e lemento puntato è par i .// Sin te t i camente . . .return (p != null ) && (p . e l % 2 == 0 ) ;

}

L'esercizio può essere anche risolto secondo un approccio ricorsivo, cosìcome riportato di seguito.

private boolean _codaPariRic ( Record p) {i f (p == null )

return fa l se ;

i f (p . succ != null )return _codaPariRic (p . succ ) ;

else

return p . e l % 2 == 0 ;}

public boolean codaPariRic ( ) {return _codaPariRic ( f i r s t ) ;


}

SL.4 Min e Max

Traccia a pag. 12

La ricerca del minimo e del massimo può essere condotta secondo un ap-proccio iterativo. Nel listato che segue, si assume inizialmente che il minimoed il massimo siano entrambi rappresentati dall'elemento di testa (linee 12e 13). Successivamente si scandiscono in sequenza gli elementi della lista.Ogni volta che viene individuato un elemento minore del minimo corrente(linea 17), il minimo corrente viene aggiornato (linea 18). Analogo discorsovale per il massimo (linee 19 e 20).

Come appare chiaro dalle speci�che, il metodo minMax contiene due para-metri di uscita, di tipo intero. In Java un metodo può restituire al massimoun valore, all'occorrenza anche strutturato. È pertanto necessario de�nireuna nuova classe, che chiamiamo MinMax, deputata a veicolare i due valoriinteri al di fuori del metodo minMax.

1 public class MinMax {2 public int min ;3 public int max ;4 }5

6 public MinMax minMax( ) {7 i f ( f i r s t == null ) // se l a l i s t a non cont iene e lement i8 // non ha senso c a l c o l a r e min e max9 return null ; // e s i r e s t i t u i s c e nu l l .

10

11 MinMax mm = new MinMax ( ) ;12 mm.min = f i r s t . e l ;13 mm.max = f i r s t . e l ;14 Record p = f i r s t . succ ;15

16 while (p != null ) {17 i f (p . e l < mm.min )18 mm.min = p . e l ;19 i f (p . e l > mm.max)20 mm.max = p . e l ;21 p = p . succ ;22 }23

24 return mm;25 }

SL.5 Lista Statica

Traccia a pag. 13


La soluzione prevede l'uso di un vettore per ospitare gli elementi dellalista. La dimensione del vettore è speci�cata dalla costante privata MAXEL de-�nita nella classe Lista e vincola il numero massimo di elementi che possonoessere inseriti.public class L i s t aS t a t i c a {

// d e f i n i z i o n e d e l l a cos tan te MAXEL che determina l a// lunghezza de l v e t t o r e che cont iene g l i e l ement i// d e l l a l i s t a .private stat ic f ina l int MAXEL = 100 ;

private int numEl ; // ques to elemento v iene automaticamente// i n i z i a l i z z a t o a l suo va l o r e d i d e f a u l t// ( che è 0) a l l ' a t t o d e l l a co s t ru z i one// d e l l a l i s t a .

private int [ ] v = new int [MAXEL] ;

public void i n s e r i s c i I nCoda ( int e l ) {v [ numEl++] = e l ; // imposto l ' e lemento a l l ' i nd i c e numEl

// e , contestua lmente , incremento numEl// dopo averne usato i l v a l o r e ( post−// incremento ) .

}

public void svuota ( ) {numEl = 0 ;// come s i può notare , l o svuotamento r i c h i e d e so l o d i// impostare numEl a zero . Non è necessar io , ma è anz i// i n u t i l e , s o v r a s c r i v e r e i l v a l o r e d e g l i e l ement i .// Quest i non verranno mai l e t t i ne l s e gu i t o// de l c i c l o d i v i t a d e l l ' o g ge t t o .

}

public int count ( ) {return numEl ;

}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;for ( int i = 0 ; i < numEl ; i++)

sb . append (v [ i ] + " " ) ;return sb . t oS t r i ng ( ) ;

}}

SL.6 È OrdinataTraccia a pag. 13

public boolean eOrdinata ( ) {for ( int i = 0 ; i < numEl − 1 ; i++)

i f ( v [ i ] > v [ i + 1 ] )return fa l se ; // esce prematuramente se t rova

// un ' inve r s i one

return true ; // se non ha t rova to inve r s i on i , r e s t i t u i s c e// true .


8 3 0 0 1 0 5 4

8 3 1 5 4

nelem = 8

nelem = 5

1 2 3 4 5

Figura SL.1: Eliminazione degli elementi con valore 0 dal vettore

}

SL.7 Elimina Tutti

Traccia a pag. 14

Ipotizzando che l'elemento da eliminare sia 0, il metodo eliminaTutti()

modi�ca il vettore degli elementi come mostrato in Figura SL.1.Per ottenere l'e�etto desiderato è su�ciente scandire in sequenza gli ele-

menti del vettore originario (in alto nella �gura). Ad ogni passo, se l'ele-mento puntato è diverso dall'elemento da eliminare, lo si ricopia nel vettorein basso; in caso contrario non si e�ettua alcuna operazione e si passa adanalizzare l'elemento successivo. Alla �ne della scansione il vettore in bassorisulterà composto dai soli elementi del vettore originario diversi da quelloda eliminare.

È facile convincersi del fatto che, per realizzare l'operazione appena de-scritta, non sia necessario utilizzare due distinti vettori, ma tutto il procedi-mento può essere svolto su un unico vettore. La copia di un elemento divienein questo caso uno spostamento nell'ambito dello stesso vettore, senza che lasovrascrittura della locazione di destinazione rappresenti un problema. Alloscopo è su�ciente utilizzare due indici i e j:

• i va da 0 a nelem-1, scandendo in sequenza tutti gli elementi delvettore originario;

• j avanza ogni qual volta un elemento viene �ricopiato�, e pertantorappresenta il riempimento corrente del vettore �ripulito�.

Di seguito si riporta il codice del metodo eliminaTutti().

public int e l im inaTutt i ( int e l ) {int j = 0 ;int count = 0 ;


for ( int i = 0 ; i < numEl ; i++) {i f ( v [ i ] == e l ) {

count++;} else {

i f ( i != j )v [ j ] = v [ i ] ;

j++;}

}

numEl −= count ;return count ;

}

SL.8 Elimina Ultimi

Traccia a pag. 14

Il metodo lasciaPrimi() richiede di eliminare gli �elementi di coda� dellalista, preservandone i primi n. Bisogna dapprima considerare i seguenti casidegeneri:

• il numero di elementi da conservare è maggiore del numero di elementipresenti nella lista: nessun elemento va eliminato (righe 2�3);

• il numero degli elementi da conservare è pari a zero: tutti gli elementivanno eliminati (righe 6�11).

Negli altri casi, bisogna dapprima scorrere attraverso le prime n posizionidella lista (righe 17�18); i restanti elementi dovranno essere scollegati dallalista (riga 20). L'implementazione risultante è la seguente.

1 public int l a s c i aP r im i ( int n) {2 i f (n >= numEl) // se n >= numEl , nessun elemento va3 // e l iminato , ed esco prematuramente .4 return 0 ;5

6 i f (n == 0) { // se n = 0 , t u t t i g l i e l ement i vanno7 // e l im ina t i8 int ne l = numEl ;9 svuota ( ) ;

10 return ne l ;11 }12

13 Record p = f i r s t ;14

15 // portiamo p a puntare a l l ' u l t imo elemento da tenere16 // n e l l a l i s t a ; b i sogna fa re n−1 s a l t i .17 for ( int i = 1 ; i < n ; i++)18 p = p . succ ;19


20 p . succ = null ; // sco l l e gh iamo i l r e s t o d e l l a l i s t a21

22 int e l im i n a t i = numEl − n ; // ca l c o l o quant i e l ement i23 // ho e l imina to24 numEl = n ; // aggiorno numEl25

26 return e l im i n a t i ;27 }

Il metodo eliminaUltimi() deve eliminare gli ultimi n elementi. Essonon di�erisce nella sostanza dal precedente metodo, e può essere pertantoimplementato nei termini di quest'ultimo.

public int e l im inaUl t im i ( int n) {i f (n >= numEl) { // se n >= numEl l a l i s t a va

// svuo ta taint ne l = numEl ;svuota ( ) ;return ne l ;

} else { // a l t r imen t i implemento ques to metodo nei// termini d i l a sc iaPr imi ( ) .

return l a s c i aP r im i (numEl − n ) ;}

}

SL.9 Somma Coda

Traccia a pag. 14

L'approccio più e�ciente per risolvere questo problema consiste nel tenerememoria del valore della coda in un membro privato della lista. Tale valoredeve essere costantemente aggiornato, a cura di tutti i metodi che possonopotenzialmente alterarlo: inserimento, eliminazione, svuotamento, ecc. Sinoti che lo stesso metodo sommaCoda() �nisce per alterare il valore dellacoda. Di seguito si mostrano le implementazioni dei metodi inserisci() esommaCoda(), nelle ipotesi che la lista sia dotata di una variabile-membroprivata de�nita come segue:

public class Li s t a {. . .private int valoreCoda ;. . .

} ;

public void i n s e r i s c i ( int e l ) {Record p = new Record ( ) ; //Creo una nuova area d i

//memoria n e l l ' heap , d e s t i na t a//a contenere un nuovo record


p . e l = e l ; // imposto i l v a l o r e d e l l ' e lementop . succ = f i r s t ; //punto a l l ' e lemento succe s s i vo ( che è

// i l primo )f i r s t = p ; // i l "nuovo primo" è l ' e lemento appena

// crea to .numEl++; // Incremento i l numero d e g l i e l ement i .

//Se q u e l l o i n s e r i t o è i l primo elemento , b i sogna// agg iornare i l v a l o r e d e l l a coda .i f ( f i r s t . succ == null )

valoreCoda = f i r s t . e l ;}

public void sommaCoda ( ) {i f ( f i r s t != null ) {

//Se l a l i s t a non è vuota , l a v a r i a b i l e−membro// valoreCoda cont iene i l va l o r e d e l l a coda .//Lo sommo a t u t t i g l i e l ement i .

Record p = f i r s t ;while (p != null ) {

p . e l += valoreCoda ;p = p . succ ;

}

//Anche i l va l o r e d e l l a coda sarà s t a t o incrementato ;// aggiorno l a v a r i a b i l e−membrovaloreCoda ∗= 2 ;

}}

SL.10 Sposta Testa in Coda

Traccia a pag. 15

Per svolgere l'operazione si fa uso di un metodo di supporto getPuntCoda()

deputato a restituire il puntatore all'elemento di coda della lista, se esistemte.Si noti che nessun nuovo elemento viene creato (new), ma l'operazione èe�ettuata esclusivamente mediante ricollocazione di puntatori, preservandole caratteristiche di e�cienza della soluzione.

private Record getPuntCoda ( ) {i f ( f i r s t == null ) // se l a coda è vuota . . .

return null ; // . . . r e s t i t u i s c e nu l l

Record p = f i r s t ;while (p . succ != null )

// a l t r imen t i cerca l a codap = p . succ ;

return p ; // e l a r e s t i t u i s c e}

public boolean spostaTestaInCoda ( ) {Record p = getPuntCoda ( ) ; // r e s t i t u i s c e i l punt . a l l a

// coda se c ' è


i f (p != null ) {p . succ = f i r s t ; // i l s u c c e s s i vo d e l l a coda è f i r s tf i r s t = f i r s t . succ ; // f i r s t avanza d i un elementop . succ . succ = null ; // i l s u c c e s s i vo d e l l a ( vecch ia )

// coda punta a nu l l}

return (p != null ) ;}

SL.11 Elimina Pari e DispariTraccia a pag. 15

public int e l iminaElement iPostoDispar i ( ) {i f ( f i r s t == null ) // Se l a l i s t a è vuota

return 0 ; // non c ' è nu l l a da e l iminare

int n = 0 ; // accumulatore e lement i e l im ina t iRecord p = f i r s t ; // p punta a l primo elemento ( d i

// ind i c e 0 , qu ind i par i )

// Se p punta ad un elemento , e ques to ha un succe s s i v o . . .while ( ( p != null ) && (p . succ != null ) ) {

p . succ = p . succ . succ ; // . . . i l s u c c e s s i vo deve e s s e r e// e l imina to . Lo f a c c i o sco l−// l egando lo d a l l a catena .

n++; // incremento l ' accumulatore

p = p . succ ; // avanzo a l l ' e lemento succes s i vo ,// sempre d i ind i c e par i ( n e l l a l i s t a// o r i g i n a l e ) .

}

return n ;}

public int e l iminaElement iPostoPar i ( ) {i f ( f i r s t == null ) // Se l a l i s t a è vuota

return 0 ; // non c ' è nu l l a da e l iminare

int n = 0 ; // accumulatore e lement i e l im ina t i

// Cancel l iamo sub i t o i l primo elemento ( ind i c e 0 ) .f i r s t = f i r s t . succ ; // sco l l egh iamo i l primo e l . d a l l a

// catenan++; // incremento l ' accumulatore

// essendo s t a t a e l imina ta l a t e s ta , non re s t a che// e l iminare t u t t i g l i e l ement i d i posto d i s p a r i// d e l l ' a t t u a l e l i s t a .n += el iminaElement iPostoDispar i ( ) ;

return n ;}


SL.12 Lista Doppiamente Collegata

Traccia a pag. 15

File Lista.java

public class DoubleLinkedList {private class Record {

int e l ;Record prec ;Record succ ;

}

private Record f i r s t ;private Record l a s t ;int numEl ;

public DoubleLinkedList ( ) {// f i r s t = nu l l ;// l a s t = nu l l ;//numEl = 0;

// t u t t e ques t e i n i z i a l i z z a z i o n i sarebbero in r e a l t à// p l eonas t i che , poiché corrispondono ai v a l o r i// d i d e f a u l t che i l l i n guag g i o assegna a i t i p i// r i f e r imen to e in t e ro secondo l o standard Java// in f a s e d i l o ro i n i z i a l i z z a z i o n e .

}

public void i n s e r i s c i ( int e l ) {Record p = new Record ( ) ;p . e l = e l ;p . succ = null ; // p l e ona s t i c ap . prec = l a s t ;i f ( l a s t != null ) // se l a s t punta ad una coda , i l suo

l a s t . succ = p ; // succe s s i vo d i v i ene l ' e l e l e n t o// appena crea to

l a s t = p ; // i l puntatore l a s t va agg iornato a l nuovo e l .

i f ( f i r s t == null ) // se f i r s t punta a nu l l ( l i s t a vuota )f i r s t = p ; // va agg iornato a l nuovo elemento

numEl++;}

public void svuota ( ) {f i r s t = l a s t = null ;numEl = 0 ;

}

public St r ing stampaDiretta ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = f i r s t ;while (p != null ) {

sb . append (p . e l + " " ) ;p = p . succ ;


}return sb . t oS t r i ng ( ) ;

}

public St r ing stampaInversa ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = l a s t ;while (p != null ) {

sb . append (p . e l + " " ) ;p = p . prec ;


}

public St r ing stampaAlternata ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = f i r s t ;Record q = l a s t ;boolean done = fa l se ;

while ( ( p != null ) && ! done ) {sb . append (p . e l + " " ) ;i f ( q != p)

sb . append (q . e l + " " ) ;

// se p e q sono sov rappos t i oppure con s e cu t i v i// abbiamo terminatoi f ( ( p == q) | | (p . succ == q ) )

done = true ;

p = p . succ ;q = q . prec ;


}

int numeroElementi ( ) {return numEl ;

}

}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {DoubleLinkedList l = new DoubleLinkedList ( ) ;int i ;

do {stampaMenu ( ) ;i = scanner . next Int ( ) ;switch ( i ) {


case 1 :i n s e r i s c i ( l ) ;break ;


case 3 :stampaDiretta ( l ) ;break ;

case 4 :stampaInversa ( l ) ;break ;

case 5 :stampaAlternata ( l ) ;break ;


case 7 :break ;


}} while ( i != 7 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . I n s e r i s c i " ) ;System . out . p r i n t l n ( " 2 . Svuota" ) ;System . out . p r i n t l n ( " 3 . Stampa Di r e t ta " ) ;System . out . p r i n t l n ( " 4 . Stampa Inver sa " ) ;System . out . p r i n t l n ( " 5 . Stampa Alternata " ) ;System . out . p r i n t l n ( " 6 . Numero Elementi " ) ;System . out . p r i n t l n ( " 7 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

private stat ic void i n s e r i s c i ( DoubleLinkedList l ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;l . i n s e r i s c i ( e l ) ;

}

private stat ic void svuota ( DoubleLinkedList l ) {System . out . p r i n t l n ( "Svuotamento l i s t a " ) ;l . svuota ( ) ;

}

private stat ic void stampaDiretta ( DoubleLinkedList l ) {System . out . p r i n t ( "Stampa d i r e t t a : " ) ;System . out . p r i n t l n ( l . stampaDiretta ( ) ) ;

}

private stat ic void stampaInversa ( DoubleLinkedList l ) {System . out . p r i n t ( "Stampa inve r s a : " ) ;System . out . p r i n t l n ( l . stampaInversa ( ) ) ;System . out . p r i n t l n ( ) ;

}

private stat ic void stampaAlternata ( DoubleLinkedList l ) {System . out . p r i n t ( "Stampa : a l t e r na t a : " ) ;System . out . p r i n t l n ( l . stampaAlternata ( ) ) ;


}

private stat ic void numeroElementi ( DoubleLinkedList l ) {System . out . p r i n t l n ( "Numero e l ement i : " +

l . numeroElementi ( ) ) ;}

}

SL.13 Ribalta

Traccia a pag. 17

L'approccio più e�ciente per ribaltare la lista consiste nel modi�care la con-�gurazione di tutti i puntatori contenuti nella struttura, senza pertanto ef-fettuare spostamenti �sici di elementi. Di seguito si forniscono due soluzioni,la prima basata su un metodo iterativo, la seconda su uno ricorsivo.

Approccio iterativo

Si consideri la Figura SL.2(a), in cui è riportata la lista di partenza. Perottenerne il ribaltamento è su�ciente che il campo succ del primo elemento(che punta ad el2) passi a puntare a null, che il campo succ del secondoelemento (che punta ad el3) passi a puntare al primo, che il campo succ

del terzo elemento (che punta ad el4) passi a puntare al secondo. . . e cosìvia. In�ne, il puntatore first (che punta ad el1) dovrà puntare all'elementoeln. Questo procedimento può essere svolto servendosi di due puntatori cheiniziano a scorrere la lista nell'unica direzione concessa, puntando di volta involta a due elementi consecutivi e spostandosi in avanti di un elemento allavolta. Ad ogni passo dell'iterazione lo scambio può essere e�ettuato serven-dosi di un terzo puntatore temporaneo (vedi Figure SL.2(b) e SL.2(c)). Lostato �nale della lista al termine dell'iterazione è riportato in Figura SL.2(d).

//Versione i t e r a t i v a de l metodo r i b a l t a ()

//Metodo Pubb l i copublic void r i b a l t a ( ) {

// Se l a l i s t a cont iene 0 o 1 elementi , esco su b i t o .i f ( f i r s t == null | | f i r s t . succ == null )

return ;

Record p1 = f i r s t ; // memorizzo in p1 i l primo . . .Record p2 = f i r s t . succ ; // . . . e in p2 i l secondop1 . succ = null ; // p1 d iven ta l ' u l t imo e punta a nu l l

while ( p2 . succ != null ) {Record temp = p2 . succ ; // memorizzo in temp i l

// succe s s i vo d i p2p2 . succ = p1 ; // i l s u c c e s s i vo d i p2 è ora p1

p1 = p2 ; // p1 d iven ta p2p2 = temp ; // p2 d iven ta temp


first el1 el2 eln

(a) Lista originale

eli-1 eli+1eli

p1 p2

(b) Prima dell'i-esima iterazione

eli-1 eli+1eli

p1 p2 temp

(c) Dopo l'i-esima iterazione

first el1 el2 eln

(d) Lista ribaltata

Figura SL.2: Il processo logico di ribaltamento di una lista


}

// in ques to punto de l cod ice p1 e p2 puntano a g l i u l t im i// due e lement i d e l l a l i s t ap2 . succ = p1 ; // i l s u c c e s s i vo d i p2 è ora p1f i r s t = p2 ; // p2 ora è l a nuova t e s t a

}

Approccio ricorsivo

Il ribaltamento della lista può essere approcciato come un problema ricorsivo.Infatti, avendo una lista, la sua versione ribaltata si ottiene isolando il primoelemento, ribaltando la restante parte della lista, e posponendo a questal'elemento isolato. Il problema del ribaltamento di una lista si riconducedunque al ribaltamento di una seconda lista costituita da un elemento inmeno. Di questo passo ci si troverà a ribaltare una lista costituita da un unicoelemento, la cui versione ribaltata è uguale a sé stessa. Durante il processodi ribaltamento bisogna anche prestare attenzione a redirigere correttamentela testa della (sotto)lista di volta in volta considerata. A questo proposito, ilmetodo ricorsivo _ribalta() riceve in ingresso il puntatore alla testa dellalista da ribaltare e restituisce la testa della lista ribaltata.

//Versione r i c o r s i v a de l metodo r i b a l t a ()

//Metodo pr i va t oprivate Record _r iba l ta ( Record p) {

// Se l a l i s t a cont iene 0 o 1 elementi , non f a c c i o nu l l a .i f (p == null | | p . succ == null )

return p ;

// memorizzo in vecchiaTesta l a vecch ia t e s t aRecord vecch iaTesta = p ;// memorizzo in vecchioSecondo i l vecch io sec . elementoRecord vecchioSecondo = p . succ ;// r i b a l t o l a s o t t o l i s t a con in t e s t a i l vecch io sec . . .// . . . e memorizzo in nuovaTesta l a nuova t e s t a .Record nuovaTesta = _r iba l t aR i co r s i vo ( vecchioSecondo ) ;

// l a vecch ia t e s t a d i v i ene l ' u l t imo elemento ( e qu ind i// punta a nu l l )vecch iaTesta . succ = null ;// i l vecch io secondo elemento punta a l l a vecch ia t e s t avecchioSecondo . succ = vecch iaTesta ;

return nuovaTesta ; // r e s t i t u i s c o l a nuova t e s t a}

//Metodo pubb l i c opublic void r i b a l t a ( ) {

f i r s t = _r iba l t aR i co r s i vo ( f i r s t ) ;}

Capitolo SA

Soluzioni degli esercizi su alberi

binari

SA.1 Albero Binario

Traccia a pag. 18

File AlberoBinario.java

public class AlberoBinar io {private class Nodo {

int elem ;Nodo s i n ;Nodo des ;

}

private Nodo root = null ;

public AlberoBinar io ( ) {} // c o s t r u t t o r e d i d e f a u l t

public AlberoBinar io ( AlberoBinar io a ) {i f ( this != a )

root = _copiaAlbero ( root , a . root ) ;}

// Metodi p r i v a t i r i c o r s i v i d i supportoprivate Nodo _copiaAlbero (Nodo dest , Nodo source ) {

// Questo metodo r i c o r s i v o acce t t a in ing re s so un// puntatore ad un a l b e ro sorgen te ( source ) e r e s t i t u i s c e// in u s c i t a un puntatore ad un a l b e ro che v iene cos t ru i−// to r icop iando i l primo .i f ( source == null ) { // se l a sorgen te è l ' a l b e ro vuoto

return null ; // anch ' io sarò vuoto ed esco// prematuramente

}

67

SA. Soluzioni degli esercizi su alberi binari 68

dest = new Nodo ( ) ; // creo un nuovo nododest . elem = source . elem ; // assegno i l contenuto d e l l a

// sorgen te a l l a de s t i na z i one

// Ora bisogna r i c r e a r e i l s o t t o a l b e r o s i n i s t r o ed i l// s o t t o a l b e r o des t ro de l nodo puntato da des t r ico−// piando i r i s p e t t i v i s o t t o a l b e r i pun ta t i da source .// Ri f l e t t endo , l ' operaz ione de s i d e ra ta è de l t u t t o// analoga a q u e l l a g ià invocata a pa r t i r e d a l l a ra−// d ice . E ' qu ind i p o s s i b i l e s f r u t t a r e l a r i c o r s i one// ed invocare l o s t e s s o " s e r v i z i o " _copiaAlbero ()// considerando source−>des e source−>sin come rad i c i// d i due d i s t i n t i a l b e r i .// La r i c o r s i one s i interromperà quando , in corr ispon−// denza d i ogni f o g l i a , ne copiamo i s o t t o a l b e r i// entrando ne l ramo ( source == nu l l ) .

dest . s i n = _copiaAlbero ( des t . s in , source . s i n ) ;des t . des = _copiaAlbero ( des t . des , source . des ) ;

return dest ;}

private Nodo _aggiungiElem (Nodo n , int elem ) {i f (n == null ) {

n = new Nodo ( ) ; // s i crea un nuovo elementon . elem = elem ; // e l o s i i n i z i a l i z z a

} else {i f ( elem > n . elem )

n . des = _aggiungiElem (n . des , elem ) ;else

n . s i n = _aggiungiElem (n . s in , elem ) ;}

return n ;}

private boolean _inAlb (Nodo n , int elem ) {i f (n == null ) // se l ' a l b e ro è vuoto . . .

return fa l se ; // . . . e lemento assente , u s c i t a an t i c i p .

i f (n . elem == elem ) // l ' e lemento cerca to è n e l l a rad ice ?return true ; // r e s t i t u i s c o t rue

i f ( elem > n . elem ) // è maggiore de l contenuto d e l l a// rad ice ?

return _inAlb (n . des , elem ) ; // cerca ne l s o t t o a l b e r o// des t ro

else

return _inAlb (n . s in , elem ) ; // cerca ne l s o t t o a l b e r o// s i n i s t r o

}

private void _s o s t i t u i s c i (Nodo n) {// Questo metodo r i c e v e in ing re s so un r i f e r imen to ad un// nodo n , rad ice d i un a l b e ro . Vi cerca i l massimo de l// s o t t o a l b e r o s i n i s t r o , ne r i c op i a i l v a l o r e n e l l a ra−// d ice e l o rimuove d a l l ' a l b e ro .Nodo q = n . s i n ; // q punta a l s o t t o a l b e r o s i n i s t r o d i n

i f ( q . des == null ) { // se q non ha un s o t t o a l b e r o des t ro


n . elem = q . elem ; // r i c op i o i l v a l o r e d i q ne l va l o r e// d i n

n . s i n = q . s i n ; // imposto i l s i n i s t r o d i n a l s i n i s t r o// d i q

return ; // ed ho f i n i t o}

while ( q . des . des != null )// scendo a des t ra in cerca de l// massimo . Mi fermo quando// punto a l l ' e lemento " sopra"// i l massimoq = q . des ;

n . elem = q . des . elem ; // r i c op i o i l massimo in nq . des = q . des . s i n ; // imposto i l d e s t ro d i q a l s i n i s t r o

// de l massimo}

private Nodo _elimina (Nodo n , int elem ) {i f (n == null ) // Eliminare da un a l b e ro vuoto non produce alcuna

// operaz ionereturn n ; // u s c i t a an t i c i p a t a

i f (n . elem == elem ) {// cance l l a nodo correntei f (n . s i n == null ) // i l ramo s i n i s t r o de l nodo da e l iminare è

// vuoto?n = n . des ; // s o s t i t u z i o n e de l nodo co l suo s o t t o a l b e r o des t ro

else i f (n . des == null ) // i l ramo des t ro de l nodo da e l iminare è// vuoto?

n = n . s i n ; // s o s t i t u z i o n e de l nodo co l suo s o t t o a l b e r o s i n i s t r oelse

// i l nodo da e l iminare ha s i a i l s o t t o a l b e r o sx che q u e l l o dx?_s o s t i t u i s c i (n ) ; // chiamo i l " s e r v i z i o " _ s o s t i t u i s c i ( )

} else i f ( elem > n . elem )n . des = _elimina (n . des , elem ) ;

else

n . s i n = _elimina (n . s in , elem ) ;

return n ;}

private void _preOrdine (Nodo n , S t r i ngBu i l d e r sb ) {i f (n != null ) {

sb . append (n . elem + " " ) ;_preOrdine (n . s in , sb ) ;_preOrdine (n . des , sb ) ;

}}

private void _postOrdine (Nodo n , S t r i ngBu i l d e r sb ) {i f (n != null ) {

_postOrdine (n . s in , sb ) ;_postOrdine (n . des , sb ) ;sb . append (n . elem + " " ) ;

}}

private void _inOrdine (Nodo n , S t r i ngBu i l d e r sb ) {i f (n != null ) {

_inOrdine (n . s in , sb ) ;


sb . append (n . elem + " " ) ;_inOrdine (n . des , sb ) ;

}}

/∗ Qui in i z i ano i metodi p u b b l i c i ∗/

public void aggiungiElem ( int e l ) {root = _aggiungiElem ( root , e l ) ;

}

public boolean inAlb ( int e l ) {return _inAlb ( root , e l ) ;

}

public void e l im ina ( int e l ) {root = _elimina ( root , e l ) ;

}

public void svuota ( ) {root = null ;

}

public St r ing preOrdine ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;_preOrdine ( root , sb ) ;return sb . t oS t r i ng ( ) ;

}

public St r ing postOrdine ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;_postOrdine ( root , sb ) ;return sb . t oS t r i ng ( ) ;

}

public St r ing inOrdine ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;_inOrdine ( root , sb ) ;return sb . t oS t r i ng ( ) ;

}}

File main.java


public class MainAlberoBinario {// l ' o g ge t t o scanner a iu ta a l e g g e r e da t i i n s e r i t i s u l l o// standard−input ( t a s t i e r a )private stat ic Scanner scanner = new Scanner ( System . in ) ;

public stat ic void main ( St r ing [ ] a rgs ) {AlberoBinar io a lbe ro = new AlberoBinar io ( ) ;int i ;

do {stampaMenu ( ) ;i = scanner . next Int ( ) ;


switch ( i ) {case 1 :

i n s e r i s c i ( a lbe ro ) ;break ;

case 2 :r i c e r c a ( a lbe ro ) ;break ;

case 3 :e l im ina ( a lbe ro ) ;break ;

case 4 :svuota ( a lbe ro ) ;break ;

case 5 :preOrdine ( a lbe ro ) ;break ;

case 6 :inOrdine ( a lbe ro ) ;break ;

case 7 :postOrdine ( a lbe ro ) ;break ;

case 8 :cop ia ( a lbe ro ) ;break ;

case 9 :break ;

default :System . out . p r i n t l n ( " Sc e l t a non va l i da . " ) ;break ;

}} while ( i != 9 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( ) ;System . out . p r i n t l n ( " 1 . I n s e r i s c i " ) ;System . out . p r i n t l n ( " 2 . Ricerca " ) ;System . out . p r i n t l n ( " 3 . Elimina" ) ;System . out . p r i n t l n ( " 4 . Svuota" ) ;System . out . p r i n t l n ( " 5 . Pre−ord ine " ) ;System . out . p r i n t l n ( " 6 . InOrdine " ) ;System . out . p r i n t l n ( " 7 . Post−Ordine" ) ;System . out . p r i n t l n ( " 8 . Copia a lbe ro " ) ;System . out . p r i n t l n ( " 9 . Esc i " ) ;System . out . p r i n t l n ( ) ;System . out . p r i n t ( " Sc e l t a : " ) ;

}

private stat ic void i n s e r i s c i ( AlberoBinar io a ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;a . aggiungiElem ( e l ) ;

}

private stat ic void r i c e r c a ( AlberoBinar io a ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;i f ( a . inAlb ( e l ) )

System . out . p r i n t l n ( "Trovato . \ n" ) ;else

System . out . p r i n t l n ( "Non trovato . \ n" ) ;


}

private stat ic void e l im ina ( AlberoBinar io a ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;a . e l im ina ( e l ) ;

}

private stat ic void svuota ( AlberoBinar io a ) {System . out . p r i n t ( "Svuotamento a lbe ro . " ) ;a . svuota ( ) ;

}

private stat ic void preOrdine ( AlberoBinar io a ) {System . out . p r i n t ( "Stampa in pre−ord ine : " ) ;System . out . p r i n t ( a . preOrdine ( ) ) ;

}

private stat ic void inOrdine ( AlberoBinar io a ) {System . out . p r i n t ( "Stampa in ord ine : " ) ;System . out . p r i n t ( a . inOrdine ( ) ) ;

}

private stat ic void postOrdine ( AlberoBinar io a ) {System . out . p r i n t ( "Stampa in post−ord ine : " ) ;System . out . p r i n t ( a . postOrdine ( ) ) ;

}

private stat ic void cop ia ( AlberoBinar io a ) {AlberoBinar io b = new AlberoBinar io ( a ) ;System . out

. p r i n t ( "La v i s i t a in ord ine d e l l ' a lbe ro cop ia to e ' : " ) ;b . inOrdine ( ) ;

// a l termine d i ques ta funzione , l ' i s t an za d i AlberoBinario// b d iven ta non più r i f e r i t a da alcun r i f e r imen to . Verrà// rimossa da l garbage c o l l e c t o r .

}}

SA.2 Numero Elementi

Traccia a pag. 19

La tecnica più semplice per e�ettuare il conteggio del numero di elementicontenuti in un albero, consiste nel de�nire un membro privato di tipo interonon negativo atto a memorizzare tale valore. Il valore del membro vienealterato da tutti i metodi della struttura che modi�cano il numero di nodipresenti in essa (inserimento, eliminazione, svuotamento, ecc.).

Qui si mostrerà un approccio di�erente, in generale meno e�ciente, con-sistente in un metodo ricorsivo che calcola il numero di elementi medianteuna visita completa dell'albero.

//Metodo pr i va t oprivate int _numEl(Nodo n) {

i f (n == null ) // se l ' a l b e ro è vuoto . . .


return 0 ; // . . . r e s t i t u i s c i zero

// a l t r imen t i , r e s t i t u i s c o 1 ( i l nodo n) più i l r i s u l t a t o// d i numEl () invocato su i miei s o t t o a l b e r i sx e dxreturn 1 + _numEl(n . s i n ) + _numEl(n . des ) ;

}

//Metodo pubb l i c opublic int numEl ( ) {

// invoco de l metodo r i c o r s i v o s u l l a rad icereturn _numEl( root ) ;

}

SA.3 OccorrenzeTraccia a pag. 19

//Metodo pr i va t oprivate int _occorrenze (Nodo n , int elem ) {

i f (n == null )return 0 ;

int occ = 0 ; // accumulatore occorrenze

i f (n . elem == elem )occ++;

i f ( elem > n . elem ) // i l segno > deve e s s e r e coerente con// l a convenzione s t a b i l i t a ne l metodo// aggiungiElem ()

occ += _occorrenze (n . des , elem ) ;else

occ += _occorrenze (n . s in , elem ) ;

return occ ;}

//Metodo pubb l i c opublic int occo r r enze ( int elem ) {

return _occorrenze ( root , elem ) ;}

SA.4 Occorrenza Massima

Traccia a pag. 20

Per risolvere il problema bisogna apportare alcune modi�che alla classe Al-beroBinario dell'esercizio �EA.1. In particolare va modi�cato il costruttore,perché acquisisca il valore occMax. Inoltre, il metodo ricorsivo _aggiungi-

Elem() ora deve restituire non più solo il valore del nodo creato, ma ancheil valore boolean che indica l'esito dell'inserimento. È pertanto opportunoconfezionare una classe, che chiameremo DatiAggiunta con visibilità privata,


che convoglierà fuori dal metodo ricorsivo i due valori richiesti. Le modi�chedescritte sono mostrate nel listato seguente.public class AlberoBinarioOccMax {

. . .private int occMax ;. . .

public AlberoBinarioOccMax ( int occMax ) {this . occMax = occMax ;

}

// Questa c l a s s e è u t i l e a convog l i a r e da t i a l l ' e s t erno// d e l l a funz ione _aggiungiElem ( ) .private class DatiAggiunta {

// Cos t ru t to re con parametripublic DatiAggiunta (Nodo nodo , boolean agg iuntaE f f e t tua ta ) {

this . nodo = nodo ;this . a gg iun taE f f e t tua ta = agg iuntaE f f e t tua ta ;

}

public Nodo nodo ;public boolean agg iuntaE f f e t tua ta ;

}

. . .

//Metodo pr i va t o r i c o r s i v oprivate DatiAggiunta _aggiungiElem (Nodo n , int elem ,

int occCor rent i ) {. . .

}

//Metodo pubb l i c opublic boolean aggiungiElem ( int e l ) {

. . .}

}

Particolare attenzione merita il metodo _aggiungiElem(), che si occupadell'inserimento nell'albero dell'elemento speci�cato dal parametro di ingres-so, nel rispetto del vincolo delle occorrenze massime. Esso si basa sulla pro-prietà secondo la quale, durante l'inserimento di un elemento in un alberobinario ordinato, bisogna necessariamente attraversare tutti gli eventuali al-tri nodi contenenti lo stesso valore da inserire. È possibile dunque discendereattraverso l'albero in cerca della posizione in cui aggiungere l'elemento e, con-temporaneamente, tenere il conteggio dell'occorrenza delle eventuali repliche,interrompendo prematuramente l'inserimento in caso di raggiungimento delnumero massimo di occorrenze.

L'implementazione dei metodi aggiungiElem() (pubblico non ricorsivo)e _aggiungiElem (privato ricorsivo) è riportata di seguito.

private DatiAggiunta _aggiungiElem (Nodo n , int elem ,int occCor rent i ) {

i f (n == null ) { // Se l ' a l b e ro è vuoto i n s e r i r ò certamenten = new Nodo ( ) ; // s i crea un nuovo elemento


n . elem = elem ; // e l o s i i n i z i a l i z z a

// r e s t i t u i s c o un ' i s t an za d i DatiAggiunta che cont ie−// ne i l r i f e r imen to a l nodo appena crea to e i l va lo−// re t rue che ind i ca l ' avvenuta agg iunta .return new DatiAggiunta (n , true ) ; // u s c i t a an t i c i p a t a

}

// L ' a l b e ro non è vuoto e sono su l percorso d e l l ' a l b e ro// cercando i l punto d i inser imento . Se lungo l a s t rada// trovo un elemento uguale ad elem , incremento i l con−// t a t o r e d e l l e occorrenze g ià i nd i v i dua t e . . .i f ( elem == n . elem ) {

occCor rent i++;i f ( occCorrent i >= occMax ) // . . . e se ho superato i l

// va l o r e max , esco anti−return new DatiAggiunta (n , fa l se ) ; // cipatamente

}

// Se sono qui i l l im i t e non è s t a t o ragg iuntoDatiAggiunta da ;i f ( elem > n . elem ) {

da = _aggiungiElem (n . des , elem , occCor rent i ) ;n . des = da . nodo ;

} else {da = _aggiungiElem (n . s in , elem , occCorrent i ) ;n . s i n = da . nodo ;

}

return new DatiAggiunta (n , da . agg iun taE f f e t tua ta ) ;}

// Metodi p u b b l i c ipublic boolean aggiungiElem ( int e l ) {

i f ( occMax == 0) // se occMax è zeroreturn fa l se ; // esco senza agg iungere alcunché .

DatiAggiunta r e s u l t = _aggiungiElem ( root , e l , 0 ) ;root = r e s u l t . nodo ;return r e s u l t . agg iun taE f f e t tua ta ;

}

SA.5 Profondità Limitata

Traccia a pag. 20

La classe AlberoBinario da realizzare è mostrata di seguito, con enfasi sullemodi�che da applicare alla versione della classe presentata in �EA.1.

Anche in questo caso, come già accaduto per l'esercizio EA.4, è statautilizzata una classe privata DatiAggiunta con lo scopo di convogliare fuoridal metodo inserisci() il riferimento al nodo eventualmente creato e l'esitodell'inserimento.public class AlberoBinar io {

. . .


// Questa c l a s s e è u t i l e a convog l i a r e da t i a l l ' e s t erno// d e l l a funz ione _in s e r i s c i ( ) .private class DatiAggiunta {

// Cos t ru t to re con parametripublic DatiAggiunta (Nodo nodo , boolean agg iuntaE f f e t tua ta ) {

this . nodo = nodo ;this . a gg iun taE f f e t tua ta = agg iuntaE f f e t tua ta ;

}

public Nodo nodo ;public boolean agg iuntaE f f e t tua ta ;

}

private Nodo root = null ;private int maxDepth ;

public AlberoBinarioMaxProf ( int _maxDepth) {this . maxDepth = _maxDepth ;

}

. . .

private DatiAggiunta _ i n s e r i s c i (Nodo n , int elem ,int _maxDepth) {

i f (_maxDepth > 0) {i f (n == null ) {

n = new Nodo ( ) ;n . elem = elem ;

return new DatiAggiunta (n , true ) ;} else {

DatiAggiunta da ;i f ( elem > n . elem ) {

da = _ i n s e r i s c i (n . des , elem , _maxDepth − 1 ) ;n . des = da . nodo ;

} else {da = _ i n s e r i s c i (n . s in , elem , _maxDepth − 1 ) ;n . s i n = da . nodo ;

}

return new DatiAggiunta (n , da . agg iun taE f f e t tua ta ) ;}

}

// se sono qui , non ho i n s e r i t o perché _maxDepth è// s t a t o decrementato lungo l a d i s c e sa r i c o r s i v a f i no//a d i ven tare nu l l oreturn new DatiAggiunta (n , fa l se ) ;

}

. . .

public boolean i n s e r i s c i ( int e l ) {DatiAggiunta da = _ i n s e r i s c i ( root , e l , maxDepth ) ;root = da . nodo ;return da . agg iuntaE f f e t tua ta ;

}}


SA.6 Somma

Traccia a pag. 21

La somma di un elemento ad ogni nodo dell'albero è in pratica implementatacome una visita completa dell'albero.

private void _somma(Nodo n , int i ) {i f (n != null ) {

n . elem += i ;_somma(n . s in , i ) ;_somma(n . des , i ) ;

}}

public void somma( int i ) {i f ( i != 0)

_somma( root , i ) ;}

SA.7 SostituisciTraccia a pag. 21

private int _s o s t i t u i s c i (Nodo n , int i , int j ) {i f (n == null )

return 0 ;

// v a r i a b i l e accumulatore d e l l e s o s t i t u z i o n iint s o s t i t u z i o n i = 0 ;

// So s t i t u i s c o prima nei s o t t o a l b e r i . . .i f ( i > n . elem )

s o s t i t u z i o n i += _s o s t i t u i s c i (n . des , i , j ) ;else

s o s t i t u z i o n i += _s o s t i t u i s c i (n . s in , i , j ) ;

// . . . poi n e l l a rad icei f (n . elem == i ) {

n . elem = j ;s o s t i t u z i o n i++;

}

return s o s t i t u z i o n i ;}

public int s o s t i t u i s c i ( int i , int j ) {return _s o s t i t u i s c i ( root , i , j ) ;

}

SA.8 Conta Min e Max

Traccia a pag. 21

Il conteggio degli elementi compresi entro un certo intervallo può essere svolto


mediante una visita dell'albero. Data la proprietà di ordinamento dell'albero,non è peraltro necessario visitare completamente la struttura. Si consideriper esempio il caso in cui si debbano conteggiare gli elementi compresi nel-l'intervallo [10, 20]. In occasione della visita di un ipotetico elemento pari a5, è inutile procedere verso il sottoalbero sinistro di tale elemento, che nonha possibilità di fornire un contributo al conteggio in corso.

private int _contaMinMax(Nodo n , int min , int max) {i f (n == null )

return 0 ;

int count = 0 ;

// Se l ' e lemento puntato da elem è compreso t ra// min e max . . .i f ( ( n . elem >= min) && (n . elem <= max) )

count++; // . . . incremento count .

// Se l ' e lemento puntato da n è minore d i max . . .i f (n . elem < max) {

// . . . a l l o r a ne l s o t t o a l b e r o des t ro po t rebbero e s s e r c i a l t r i// e lement i .count = count + _contaMinMax(n . des , min , max ) ;

}

i f (n . elem >= min) // E v i c e v e r sa per i l s o t t o a l b e r o s i n i s t r o .count = count + _contaMinMax(n . s in , min , max ) ;

return count ;}

public int contaMinMax ( int min , int max) {return _contaMinMax( root , min , max ) ;

}

SA.9 Profondità Maggiore di Due

Traccia a pag. 22

Si noti che il metodo riportato di seguito non è ricorsivo, né richiama alcunaltro metodo.

public boolean profMaggioreDiDue ( ) {return

( root != null ) && // c ' è l a rad ice e . . .(

// . . . o e s i s t e i l nodo d i s i n i s t r a e . . .( ( root . s i n != null ) &&

// . . . ques to ha almeno un f i g l i o . . .(

( root . s i n . s i n != null ) | |( root . s i n . des != null )

) )

| | //oppure


// . . . e s i s t e i l nodo d i de s t ra e . . .( ( root . des != null ) &&

// . . . ques to ha almeno un f i g l i o .(

( root . des . s i n != null ) | |( root . des . des != null )

) )) ;

}

SA.10 Profondita Maggiore DiTraccia a pag. 22

private boolean _profMaggioreDi (Nodo n , int p) {i f (n == null )

return fa l se ;

i f (p == 0) // se i l conta tore è ( sceso f i no a) zero . . .return true ; // . . . abbiamo superato l a pro f . r i c h i e s t a . . .

else

// . . . a l t r imen t i b i sogna cont inuare l a d i s c e sa nei s o t t o a l b e r i// decrementando p .return _profMaggioreDi (n . s in , p − 1)

| | _profMaggioreDi (n . des , p − 1 ) ;}

// Metodo pubb l i c opublic boolean profMaggioreDi ( int p) {

return _profMaggioreDi ( root , p ) ;}

SA.11 Profondità Massima

Traccia a pag. 22

Il metodo profondita() deve restituire un'informazione strutturata:• la profondità massima dell'elemento eventualmente trovato;

• il tipo del nodo eventualmente trovato, foglia o non-foglia.Per restituire questa informazione viene utilizzata un'apposita classe de-

nominata InfoProf. Laddove l'elemento non venisse trovato, il metodorestituirebbe un riferimento null.

public class In f oPro f {int pro fond i ta ;boolean f o g l i a ;

}

private In f oPro f _profondita (Nodo n , int elem ) {i f (n == null ) // se l ' a l b e ro è vuoto


return null ; // esco su b i t o

// Siccome s i r i c h i e d e l ' e lemento a pro fond i t à massima// v e r i f i c o prima se nei miei so t to−a l b e r i l ' e lemento// è presen te .

// Decido se c e r ca r l o a des t ra o a s i n i s t r a e . . .In f oPro f ip ;i f ( elem > n . elem )

// . . . uso i l s e r v i z i o che io s t e s s o o f f r o : r i c o r s i one .ip = _profondita (n . des , elem ) ;

else

ip = _profondita (n . s in , elem ) ;

i f ( ip != null ) { // se a l "piano d i s o t t o " c ' era . . .ip . p ro f ond i ta++; // . . . aggiungo 1 a l l a pro fond i t à

// v i s t a da l "piano d i s o t t o "return ip ; // e r e s t i t u i s c o " sopra " .

}

// se sono qui vuo l d i r e che " s o t t o " non c ' è// e v e r i f i c o se l ' e lemento sono propr io io .i f (n . elem == elem ) { // se sono propr io io . . .

ip = new In f oPro f ( ) ;ip . p ro f ond i ta = 1 ; // . . . da l mio punto d i v i s t a l a

// pro fond i t à è 1 e . . .// . . . se non ho f i g l i l ' e lemento t rova to è anche// una f o g l i a . . .ip . f o g l i a = (n . s i n == null ) && (n . des == null ) ;

}

return ip ;}

public In f oPro f p ro f ond i ta ( int elem ) {return _profondita ( root , elem ) ;

}

SA.12 Somma LivelloTraccia a pag. 23

private void _sommaLivello (Nodo n , int i ) {i f (n != null ) {

n . elem += i ;_sommaLivello (n . s in , i + 1 ) ;_sommaLivello (n . des , i + 1 ) ;

}}

public void sommaLivello ( ) {_sommaLivello ( root , 1 ) ;

}


SA.13 Eliminazione FogliaTraccia a pag. 23

private boolean eUnaFoglia (Nodo n) {// metodo d i supporto che v e r i f i c a se i l nodo// puntato da n è o meno una f o g l i a .return (n . s i n == null ) && (n . des == null ) ;

}

private boolean _el iminaFogl ia (Nodo n , int e l ) {// Questo metodo acce t t a un puntatore a l l a rad ice d i un// a l b e ro ed e l imina un ' even tua l e f o g l i a da l va l o r e// s p e c i f i c a t o in e l . Non funz iona se l a rad ice è nu l l// oppure se l a f o g l i a è propr io l a rad ice . Chi l o invoca// deve esserne co s c i en t e .i f ( e l > n . elem ) { // l ' elem è potenz ia lmente a des t ra ?

i f (n . des != null ) {i f ( ( n . des . elem == e l ) && ( eUnaFoglia (n . des ) ) ) {

n . des = null ;return true ;

}

// d i ce r to n . des non è nu l l e non è una f o g l i a// da e l iminare . Posso invocare i l metodo// r i c o r s i v o _el iminaFogl ia ( ) senza prob lemi .return _el iminaFogl ia (n . des , e l ) ;

}} else {

i f (n . s i n != null ) {i f ( ( n . s i n . elem == e l ) && ( eUnaFoglia (n . s i n ) ) ) {

n . s i n = null ;return true ;

}

// d i ce r to n . s in non è nu l l e non è una f o g l i a// da e l iminare . Posso invocare i l metodo// r i c o r s i v o _el iminaFogl ia ( ) senza prob lemi .return _el iminaFogl ia (n . s in , e l ) ;

}}

return fa l se ;}

public boolean e l im inaFog l i a ( int e l ) {i f ( root == null ) // se l ' a l b e ro è vuoto , esco ant i c ipa−

return fa l se ; // tamente con f a l s e

// Se in root c ' è l ' e lemento da e l iminare e// root è l ' unico nodo . . .i f ( ( root . elem == e l ) && eUnaFoglia ( root ) ) {

root = null ; // l o cance l l oreturn true ; // ed esco con true

}

// Ora sono s i curo che l ' a l b e ro non è vuoto ,// né l a rad ice è da e l iminare . Posso invocare// i l metodo r i c o r s i v o _el iminaFogl ia () senza prob lemi .return _el iminaFogl ia ( root , e l ) ;

}


SA.14 Eliminazione FoglieTraccia a pag. 23

private int _el iminaFog l i e (Nodo n) {// Questo metodo acce t t a un puntatore a l l a rad ice d i un// a l b e ro ed e l imina t u t t e l e sue f o g l i e .// Non funz iona se l a rad ice è nu l l o è f o g l i a .// Chi l o invoca deve esserne co s c i en t e .int e l im i n a t i = 0 ;i f (n . s i n != null ) {

i f ( eUnaFoglia (n . s i n ) ) {n . s i n = null ;e l im i n a t i++;

} else

// n . s in non è nu l l o f o g l i a . Posso invocare l a// r i c o r s i onee l im i n a t i += _el iminaFog l i e (n . s i n ) ;

}

i f (n . des != null ) {i f ( eUnaFoglia (n . des ) ) {

n . des = null ;e l im i n a t i++;

} else

// n . des non è nu l l o f o g l i a . Posso invocare l a// r i c o r s i onee l im i n a t i += _el iminaFog l i e (n . des ) ;

}

return e l im i n a t i ;}

public int e l im inaFog l i e ( ) {i f ( root == null )

return 0 ;

i f ( eUnaFoglia ( root ) ) {root = null ;return 1 ;

}

// root non è nu l l o f o g l i a . Posso invocare l a// r i c o r s i onereturn _el iminaFog l i e ( root ) ;

}

SA.15 Cerca Foglia

Traccia a pag. 24

I metodi cercaFoglia() e cercaNodo() devono restituire un'informazionestrutturata, costituita da due valori logici. Come di consueto, saranno utiliz-zate allo scopo delle classi appositamente de�nite. In questo caso si è sceltodi realizzare questa classi come classi immutabili. Ciò signi�ca che il valore


di ogni loro istanza viene de�nito all'atto della creazione e non può esse-re variato per tutto il ciclo di vita. Per esempio, il costruttore della classeRisultatoRicercaFoglia è de�nito come segue:

1 public Ri su l t a t oR i c e r c aFog l i a (boolean trovato ,2 boolean f o g l i a ) {3 this . t rovato = trovato ;4 this . f o g l i a = f o g l i a ;5 }

Le righe 1 e 2 contengono i parametri di ingresso, utili ad assegnareil valore delle omonime variabili private contenute nella classe. L'omonimianon crea alcun problema poiché, nello scope in cui sono visibili sia le variabiliprivate che i parametri locali (righe 3 e 4), viene risolta utilizzando il pre�ssothis. Laddove è presente this ci si sta riferendo alla variabile membroprivata. Laddove this non è presente, si fa invece riferimento al parametrolocale.

Di seguito è riportata l'implementazione dei metodi pubblici e privati utilia rispondere alla traccia.

public class Ri su l t a t oR i c e r c aFog l i a {// c l a s s e immutabi leprivate boolean t rovato ;private boolean f o g l i a ;

public Ri su l t a t oR i c e r c aFog l i a (boolean trovato ,boolean f o g l i a ) {

this . t rovato = trovato ;this . f o g l i a = f o g l i a ;

}

public boolean getTrovato ( ) {return t rovato ;

}

public boolean ge tFog l i a ( ) {return f o g l i a ;

}}

R i su l t a t oR i c e r c aFog l i a _cercaFogl ia (Nodo n , int e l ) {i f (n == null ) // Se n punta a nu l l

// u s c i t a an t i c i p a t a con f a l s ereturn new Ri su l t a t oR i c e r c aFog l i a ( false , fa l se ) ;

R i su l t a t oR i c e r c aFog l i a r r f = null ;

// Cerco su b i t o più " in basso " .i f ( e l > n . elem )

r r f = _cercaFogl ia (n . des , e l ) ;else

r r f = _cercaFogl ia (n . s in , e l ) ;

i f ( r r f . t rovato ) // se in basso l ' ho t rova to . . .return r r f ; // r e s t i t u i s c o i l v e r d e t t o .


i f (n . elem == e l ) { // se sono propr io io . . .r r f . t rovato = true ; // . . . imposto t rova to a t rue . . .r r f . f o g l i a = eUnaFoglia (n ) ; // . . . e v e r i f i c o se è

// una f o g l i a .}

return r r f ;}

public class RisultatoRicercaNodo {// c l a s s e immutabi leprivate boolean t rovato ;private boolean nodo ;

public RisultatoRicercaNodo (boolean trovato , boolean nodo ) {this . t rovato = trovato ;this . nodo = nodo ;

}

public boolean getTrovato ( ) {return t rovato ;

}

public boolean getNodo ( ) {return nodo ;

}}

Risu l tatoRicercaNodo _cercaNodo (Nodo n , int e l ) {i f (n == null )

return new RisultatoRicercaNodo ( false , fa l se ) ;

i f (n . elem == e l ) { // Se l ' e lemento corrente è par i ad// e l . . .

RisultatoRicercaNodo rrn = new RisultatoRicercaNodo (false , fa l se ) ;

r rn . nodo = ( ! eUnaFoglia (n ) ) ; // . . . v e r i f i c o se è un// nodo . . .

rrn . t rovato = true ; // . . . assegno r i s u l t a t o p o s i t i v o .// E ' i n f a t t i i n u t i l e procedere verso i l basso .return rrn ;

} else // Se non l ' ho trovato , cerco più " in basso " .i f ( e l > n . elem )

return _cercaNodo (n . des , e l ) ;else

return _cercaNodo (n . s in , e l ) ;}

// Metodi p u b b l i c ipublic Ri su l t a t oR i c e r c aFog l i a c e r caFog l i a ( int e l ) {

return _cercaFogl ia ( root , e l ) ;}

public RisultatoRicercaNodo cercaNodo ( int e l ) {return _cercaNodo ( root , e l ) ;

}


SA.16 Operatore di Confronto

Traccia a pag. 24

Il metodo equals() deve innanzitutto veri�care che l'istanza di oggetto pas-sata in ingresso sia della classe AlberoBinario. A questo scopo si utilizzal'operatore del linguaggio instanceof, che restituisce un valore booleano. Sequesto operatore restituisce il valore false, il metodo termina prematura-mente con il valore false. Altrimenti si procede alla veri�ca sull'uguaglianzastrutturale tra i due alberi da confrontare.

Si noti come la variabile alb del metodo equals() rappresenti un ulterioreriferimento all'oggetto obj: benché i due riferimenti siano identici (puntinocioè alla medesima locazione di memoria), il loro tipo è di�erente e alb puòessere utilizzato come parametro attuale nella chiamata del metodo ricorsivo_equals().

private boolean _equals (Nodo n1 , Nodo n2 ) {i f ( n1 == n2 ) // Se i pun ta to r i a l l e r a d i c i coincidono ,

return true ; // g l i a l b e r i sono ugua l i .// E ques to g e s t i s c e anche l ' e v en t u a l i t à// che g l i a l b e r i s iano entrambi vuo t i .

// Se so l o una d e l l e due rad . è nu l l (XOR) . . .i f ( ( n1 == null ) ^ ( n2 == null ) )

return fa l se ; // . . . i due a l b e r i non sono ugua l i// ( perché l ' a l t r a certamente non è// nu l l )

// Appurato che nessuna d e l l e due r a d i c i punta a zero . . .i f ( n1 . elem != n2 . elem ) // . . . se i due elem . pun ta t i da n1

// e n2 sono d i v e r s i . . .return fa l se ; // . . . a l l o r a i due a l b e r i non sono ugua l i .

// Dunque , abbiamo due a l b e r i non vuo t i e contenent i e l ement i// d i ugua le va l o r e n e l l a rad ice .// Bisogna ora c on t r o l l a r e se i l o ro s o t t o a l b e r i s i n i s t r o e// des t ro sono ugua l i : r i c o r s i one .return _equals ( n1 . s in , n2 . s i n )

&& _equals ( n1 . des , n2 . des ) ;}

public boolean equa l s ( Object obj ) {// se l ' o g ge t t o r i c e vu t o non è un AlberoBinarioi f ( ! ( obj instanceof AlberoBinar io ) )

return fa l se ; // certamente non siamo ugua l i

// creiamo un a l t r o r i f e r imento , d i t i p o AlberoBinario// a l l ' o g g e t t o obj , che è d i f a t t o un AlberoBinario .// Questa è un ' operaz ione d i ca s t i n g d i t i p o .AlberoBinar io a lb = ( AlberoBinar io ) obj ;

// confrontiamo i due a l b e r i a p a r t i r e d a l l a rad icereturn ( _equals ( root , a lb . root ) ) ;

}


SA.17 Conta Nodi non FogliaTraccia a pag. 25

private boolean eUnaFoglia (Nodo n) {// metodo d i supporto che v e r i f i c a se i l nodo// puntato da n è o meno una f o g l i a .return (n . s i n == null ) && (n . des == null ) ;

}

private int _contaNodiNonFoglia (Nodo n) {i f (n == null ) // Se l ' a l b e ro è vuoto

return 0 ; // i l con tegg io è nu l l o

int count = 0 ; // accumulatore

// even tua l e con t r i bu to s o t t o a l b e r o s i n i s t r oi f (n . s i n != null )

count = count + _contaNodiNonFoglia (n . s i n ) ;

// even tua l e con t r i bu to s o t t o a l b e r o des t roi f (n . des != null )

count = count + _contaNodiNonFoglia (n . des ) ;

// even tua l e con t r i bu to de l presen te nodoi f ( ! eUnaFoglia (n ) )

count++;

return count ;}

public int contaNodiNonFoglia ( ) {return _contaNodiNonFoglia ( root ) ;

}

SA.18 Conta Nodi

Traccia a pag. 25

La restituzione dei tre valori richiesti da parte del metodo contaNodi() av-viene mediante l'istanza di una classe ConteggioNodi, appositamente de�-nita. La classe implementa anche un metodo di supporto utile ad e�ettuarela somma tra due istanze della classe medesima.

public class ConteggioNodi {public int zero ;public int uno ;public int due ;

// Questo metodo d i supporto somma membro a membro// due i s t an z e d i ConteggioNodi e ne r e s t i u t i s c e// i l r i s u l t a t o in una nuova i s t an za .private ConteggioNodi somma( ConteggioNodi cn ) {

ConteggioNodi r e s u l t = new ConteggioNodi ( ) ;r e s u l t . ze ro = this . z e ro + cn . ze ro ;r e s u l t . uno = this . uno + cn . uno ;


r e s u l t . due = this . due + cn . due ;

return r e s u l t ;}

}

private ConteggioNodi _contaNodi (Nodo n) {// Creo su b i t o l ' i s t an za che r e s t i t u i r òConteggioNodi cont = new ConteggioNodi ( ) ;

// Se n è nu l l , i l con tegg io è zero ovunquei f (n == null )

return cont ;

// Chiedo a l mio s o t t o a l b e r o s i n i s t r o i l suo contegg ioConteggioNodi cont_sin = _contaNodi (n . s i n ) ;// Chiedo a l mio s o t t o a l b e r o des t ro i l suo contegg ioConteggioNodi cont_des = _contaNodi (n . des ) ;

// Calco lo i l mio con t r i bu toi f ( ( n . s i n == null ) && (n . des == null ) )

cont . ze ro++;else i f ( ( n . s i n != null ) && (n . des != null ) )

cont . due++;else

cont . uno++;

// Sommo i l con t r i bu to d i cont_sin a l va l o r e corrente// d i cont . Faccio puntare cont a l r i s u l t a t o .cont = cont . somma( cont_sin ) ;// Sommo i l con t r i bu to d i cont_des a l va l o r e corrente// d i cont . Faccio puntare cont a l r i s u l t a t o .cont = cont . somma( cont_des ) ;

return cont ; // r e s t i t u i s c o i l con tegg io}

public ConteggioNodi contaNodi ( ) {return _contaNodi ( root ) ;

}

SA.19 Conta Nodi Sottoalbero

Traccia a pag. 25

Il problema posto può essere scomposto in due sottoproblemi:

• individuare la radice del sottoalbero di cui contare i nodi;

• contare i nodi del sottoalbero individuato.

Solo la prima delle due operazioni suddette dipende da quale dei due me-todi viene invocato, a di�erenza della seconda che resta inalterata. Questaconsiderazione suggerisce di aggiungere alla classe AlberoBinario i seguentimetodi:


private int _contaNodi (Nodo n) {. . .

}

private Nodo _cercaOccorrenzaMin (Nodo n , int e l ) {. . .

}

private Nodo _cercaOccorrenzaMax (Nodo n , int e l ) {. . .

}

public int contaNodiSottoalb_Min ( int e l ) {. . .

}

public int contaNodiSottoalb_Max ( int e l ) {. . .

}

Il metodo _contaNodi() restituisce il numero di nodi di un sottoalberodi cui sia fornita la radice. Il metodo _cercaOccorrenzaMin() restituisceil puntatore al nodo avente valore speci�cato e posizionato più in alto (li-vello minimo) all'interno di un albero di cui si fornisce la radice. Analogocomportamento ha il metodo _cercaOccorrenzaMax(). I due metodi pub-blici svolgono le operazioni richieste basandosi sui metodi privati mostrati._cercaOccorrenzaMin(), ad esempio, invoca il metodo ricorsivo _cerca-

OccorrenzaMin() perché individui la radice del sottoalbero; su tale radiceinvoca poi il metodo _contaNodi().

Di seguito si riportano le implementazioni dei cinque metodi dichiarati.private int _contaNodi (Nodo n) {

i f (n != null )return 1 + _contaNodi (n . s i n ) + _contaNodi (n . des ) ;

else

return 0 ;}

private Nodo _cercaOccorrenzaMin (Nodo n , int e l ) {// Cerca n e l l ' a l b e ro avente rad ice in n l ' e lemento i l// cui va l o r e è par i ad e l ed i l cu i l i v e l l o è minimo .// Ne r e s t i t u i s c e i l puntatore .i f (n != null ) {

i f (n . elem == e l ) // Se sono i l nodo con l ' e lemento// cerca to . . .

return n ; // . . . r e s t i t u i s c o i l puntatore a me s t e s s o . . .else i f (n . elem < e l ) // . . . a l t r imen t i cerco "più g iù "

return _cercaOccorrenzaMin (n . des , e l ) ;else

return _cercaOccorrenzaMin (n . s in , e l ) ;} else

return null ;}


private Nodo _cercaOccorrenzaMax (Nodo n , int e l ) {// Cerca n e l l ' a l b e ro avente rad ice in n l ' e lemento i l// cui va l o r e è par i ad e l ed i l cu i l i v e l l o è massimo .// Ne r e s t i t u i s c e i l puntatore .i f (n != null ) {

Nodo r e s u l t ;i f (n . elem < e l ) // Cerco prima "più g iù "

r e s u l t = _cercaOccorrenzaMax (n . des , e l ) ;else

r e s u l t = _cercaOccorrenzaMax (n . s in , e l ) ;

i f ( r e s u l t != null ) // Se l ' ho t rova to . . .return r e s u l t ; // . . . l o r e s t i t u i s c o . . .

else i f (n . elem == e l ) // . . . a l t r imen t i v e r i f i c o d i// non es s e r e l ' elem . cerca to .

return n ; // Se sono io , r e s t i t u i s c o i l// puntatore a me s t e s s o . . .

else

return null ; // . . . a l t r imen t i r e s t i t u i s c o nu l l .} else

return null ;}

public int contaNodiSottoalb_Min ( int e l ) {Nodo n = _cercaOccorrenzaMin ( root , e l ) ;i f (n != null ) // C' è almeno un elemento par i ad e l ?

return _contaNodi (n ) ;else

return 0 ;}

public int contaNodiSottoalb_Max ( int e l ) {Nodo n = _cercaOccorrenzaMax ( root , e l ) ;i f (n != null ) // C' è almeno un elemento par i ad e l ?

return _contaNodi (n ) ;else

return 0 ;}

SA.20 SommaMinMaxTraccia a pag. 26

public int sommaMinMax( ) {int r e s u l t = 0 ;i f ( root != null ) {

Nodo n ;

//Sommo i l minimon = root ;// discendo l ' a l b e ro verso s i n i s t r a f i nché posso : minimowhile (n . s i n != null )

n = n . s i n ;r e s u l t += n . elem ;

//Sommo i l massimon = root ;


// discendo l ' a l b e ro verso des t ra f i nché posso : massimowhile (n . des != null )

n = n . des ;r e s u l t += n . elem ;

}

return r e s u l t ;}

Capitolo SP

Soluzioni degli esercizi su pile

SP.1 Push Greater

Traccia a pag. 27

File Pila.java

public class Pi l a {private class Record {

int elem ;Record succ ;

}

private Record top ;private int numEl ;

public Pi l a ( ) {}

public void push ( int e l ) {Record p = new Record ( ) ;p . elem = e l ;p . succ = top ;top = p ;numEl++;

}

public boolean pushGreater ( int e l ) {i f ( empty ( ) | | ( e l > top ( ) ) ) {

push ( e l ) ;return true ;

} else

return fa l se ;}

public int top ( ) throws I l l e g a l S t a t eEx c ep t i o n {i f ( top != null )

91

SP. Soluzioni degli esercizi su pile 92

return top . elem ;

// Se siamo qui , l a p i l a è vuota e non ha senso invocare// i l metodo top . Non è sensato r e s t i t u i r e un va l o r e// in t e ro convenzionale , che po t rebbe e s s e r e scambiato// da l chiamante come i l va l o r e d i t e s t a . La cosa più// g i u s t a da fa r e è s o l l e v a r e un ' eccez ione .throw new I l l e g a l S t a t eEx c ep t i o n ( " Impo s s i b i l e l e g g e r e "

+ "una p i l a vuota" ) ;}

public int pop ( ) throws I l l e g a l S t a t eEx c ep t i o n {i f ( top != null ) {

int e l = top . elem ; // memorizza i l v a l o r e d i t e s t a// per r e s t i t u i r l o a l l a f i n e

top = top . succ ;numEl−−;return e l ;

}

// ved i commenti a l metodo top ()throw new I l l e g a l S t a t eEx c ep t i o n ( " Impo s s i b i l e l e g g e r e "

+ "una p i l a vuota" ) ;}

public void svuota ( ) {top = null ;numEl = 0 ;

}


}

public boolean empty ( ) {return (numEl == 0 ) ;

}}

File Main.java

import java . u t i l . Scanner ;


public stat ic void main ( St r ing [ ] a rgs ) {P i l a l = new Pi l a ( ) ;int i ;


push ( l ) ;break ;


case 2 :pushGreater ( l ) ;break ;

case 3 :top ( l ) ;break ;

case 4 :pop ( l ) ;break ;



case 7 :empty ( l ) ;break ;

case 8 :break ;


}} while ( i != 8 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . Push" ) ;System . out . p r i n t l n ( " 2 . PushGreater " ) ;System . out . p r i n t l n ( " 3 . Top" ) ;System . out . p r i n t l n ( " 4 . Pop" ) ;System . out . p r i n t l n ( " 5 . Svuota" ) ;System . out . p r i n t l n ( " 6 . NumeroElementi" ) ;System . out . p r i n t l n ( " 7 . E ' vuota" ) ;System . out . p r i n t l n ( " 8 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

stat ic void push ( P i l a p) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;p . push ( e l ) ;

}

stat ic void pushGreater ( P i l a p) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;boolean i n s e r i t o = p . pushGreater ( e l ) ;i f ( i n s e r i t o )

System . out . p r i n t l n ( " Inser imento avvenuto . " ) ;else

System . out . p r i n t l n ( " Inser imento non avvenuto . " ) ;}

stat ic void top ( P i l a p) {i f ( ! p . empty ( ) )

System . out . p r i n t l n (p . top ( ) ) ;else

System . out . p r i n t l n ( "La p i l a è vuota . " ) ;}

stat ic void pop ( P i l a p) {


i f ( ! p . empty ( ) )System . out . p r i n t l n (p . pop ( ) ) ;

else

System . out . p r i n t l n ( "La p i l a è vuota . " ) ;}

stat ic void svuota ( P i l a p) {p . svuota ( ) ;

}

stat ic void numeroElementi ( P i l a p) {System . out . p r i n t l n (p . count ( ) ) ;

}

stat ic void empty ( P i l a p) {System . out . p r i n t l n (p . empty ( ) ) ;

}}

SP.2 Push If

Traccia a pag. 28

Nella parte privata della classe sono dichiarati i seguenti membri:

public class Pi l a {. . .private Record top ;private int numEl ;private f ina l int maxPush ;private int currPush ;. . .

}

La variabile membro maxpush tiene memoria di qual è il numero di inseri-menti massimi consecutivi ammessi; il suo valore è inizializzato dal costrutto-re al valore del parametro di ingresso e mai più variato durante il ciclo di vitadelle istanze della classe. La sua marcatura con l'attributo final abilita pro-prio tali controlli da parte del compilatore. La variabile membro currpush

tiene memoria del numero di inserimenti consecutivi correntemente e�ettua-ti. Ogni chiamata al metodo push() deve veri�care che questo parametronon ecceda il valore massimo consentito. Il metodo privato _push() è imple-mentato come una classica push su coda, così come disponibile nell'esercizio�EP.1.

Di seguito si riporta l'implementazione dei metodi richiesti dalla traccia.public Pi l a ( int _maxPush) {

maxPush = _maxPush ;}

private void _push( int e l ) {Record p = new Record ( ) ;p . elem = e l ;p . succ = top ;


top = p ;numEl++;

}

public boolean push ( int e l ) {i f ( currPush < maxPush) {

_push( e l ) ;currPush++;return true ;

}return fa lse ;

}

private int _pop( ) throws I l l e g a l S t a t eEx c ep t i o n {i f ( top != null ) {

int e l = top . elem ; // memorizza i l v a l o r e d i t e s t a// per r e s t i t u i r l o a l l a f i n e

top = top . succ ;numEl−−;return e l ;

}

throw new I l l e g a l S t a t eEx c ep t i o n ( ) ;}

public int pop ( ) {currPush = 0 ;return _pop ( ) ;

}

private void _svuota ( ) {top = null ;numEl = 0 ;

}

public void svuota ( ) {currPush = 0 ;_svuota ( ) ;

}

Capitolo SC

Soluzioni degli esercizi su code

SC.1 Coda

Traccia a pag. 30

File Coda.java

public class Coda {private class Record {


}

private Record head ;private Record t a i l ;private int numEl ;

public Coda ( ) {}

public void push ( int e l ) {// Creo un nuovo elementoRecord temp = new Record ( ) ;temp . elem = e l ;temp . succ = null ;

// se c ' è un elemento d i coda ques to deve puntare a l// nuovo elementoi f ( t a i l != null )

t a i l . succ = temp ;

// in ogni caso l a coda punterà a l nuovo elementot a i l = temp ;

// se l a t e s t a non punta ad un elemento , deve puntare// a l nuovo elemento : l a coda , cioè , era vuota a l// momento d e l l ' inser imento

96

SC. Soluzioni degli esercizi su code 97

i f ( head == null )head = temp ;

numEl++;}

public int top ( ) throws I l l e g a l S t a t eEx c ep t i o n {i f ( head != null )

return head . elem ;

// Se siamo qui , l a coda è vuota e non ha senso invocare// i l metodo top . Non è sensato r e s t i t u i r e un va l o r e// in t e ro convenzionale , che po t rebbe e s s e r e scambiato// da l chiamante come i l va l o r e d i t e s t a . La cosa più// g i u s t a da fa r e è s o l l e v a r e un ' eccez ione .throw new I l l e g a l S t a t eEx c ep t i o n ( " Impo s s i b i l e l e g g e r e "

+ "coda vuota . " ) ;}

public int pop ( ) throws I l l e g a l S t a t eEx c ep t i o n {i f ( head != null ) {

int e l = head . elem ;

// head passa a puntare a l l ' e lemento succe s s i vohead = head . succ ;

// se head non punta a n ien te vuo le d i r e che l a coda// conteneva un so l o elem . Anche t a i l qu ind i deve// puntare a nu l li f ( head == null )

t a i l = null ;

numEl−−;return e l ;

}

// ved i commenti metodo top ()throw new I l l e g a l S t a t eEx c ep t i o n ( " Impo s s i b i l e l e g g e r e "


public int somma( ) {int sum = 0 ;for ( Record temp = head ; temp != null ; temp = temp . succ )

sum += temp . elem ;

return sum ;}

public void svuota ( ) {head = t a i l = null ;numEl = 0 ;

}


}

public boolean empty ( ) {return numEl == 0 ;

}}


File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {Coda l = new Coda ( ) ;int i ;


push ( l ) ;break ;

case 2 :top ( l ) ;break ;


case 4 :somma( l ) ;break ;




case 8 :break ;


}} while ( i != 8 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . Push" ) ;System . out . p r i n t l n ( " 2 . Top" ) ;System . out . p r i n t l n ( " 3 . Pop" ) ;System . out . p r i n t l n ( " 4 . Somma" ) ;System . out . p r i n t l n ( " 5 . Svuota" ) ;System . out . p r i n t l n ( " 6 . NumeroElementi" ) ;System . out . p r i n t l n ( " 7 . E ' vuota" ) ;System . out . p r i n t l n ( " 8 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

stat ic void push (Coda c ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;


c . push ( e l ) ;}

stat ic void top (Coda c ) {i f ( ! c . empty ( ) )

System . out . p r i n t l n ( c . top ( ) ) ;else

System . out . p r i n t l n ( "La coda è vuota . " ) ;}

stat ic void pop (Coda c ) {i f ( ! c . empty ( ) )

System . out . p r i n t l n ( c . pop ( ) ) ;else


stat ic void somma(Coda c ) {System . out . p r i n t l n ( c . somma ( ) ) ;

}

stat ic void svuota (Coda c ) {c . svuota ( ) ;

}

stat ic void numeroElementi (Coda c ) {System . out . p r i n t l n ( c . count ( ) ) ;

}

stat ic void empty (Coda c ) {System . out . p r i n t l n ( c . empty ( ) ) ;

}}

SC.2 Coda con Perdite

Traccia a pag. 31

File Coda.java

public class Coda {private class Record {


}

private Record head ;private Record t a i l ;private int po s t i ;private int numEl ;

public Coda( int _posti ) {po s t i = _posti ;

}


public boolean push ( int e l ) {// Se l a coda ha e sau r i t o i pos t i , l ' inser imento// non avvienei f (numEl == po s t i )

return fa l se ;

// Creo un nuovo elementoRecord temp = new Record ( ) ;temp . elem = e l ;temp . succ = null ;




// se l a t e s t a non punta ad un elemento , deve puntare// a l nuovo elemento : l a coda , cioè , era vuota a l// momento d e l l ' inser imentoi f ( head == null )

head = temp ;

numEl++;return true ;

}

public int top ( ) {i f ( head != null )

return head . elem ;




int e l = head . elem ;


// se head non punta a n ien te vuo le d i r e che l a coda// conteneva un so l o elem . Anche t a i l qu ind i deve// puntare a nu l li f ( head == null )

t a i l = null ;

numEl−−;return e l ;

}


+ "coda vuota . " ) ;


}

public int pop ( int n) throws I l l e g a l S t a t eEx c ep t i o n {i f ( head != null ) {

int e l = pop ( ) ;

// e s t r a z i one de i r e s t a n t i e l ement i : s i usa i l// metodo Pop () ( se l a coda non è vuota ) ;for ( int i = 2 ; ( i <= n) && ( head != null ) ; i++)

pop ( ) ;

return e l ;}



public int somma( ) {int sum = 0 ;for ( Record temp = head ; temp != null ; temp = temp . succ )

sum += temp . elem ;

return sum ;}

public void svuota ( ) {head = t a i l = null ;numEl = 0 ;

}


}

public boolean empty ( ) {return numEl == 0 ;

}}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {Coda l = new Coda ( 5 ) ;int i ;


push ( l ) ;


break ;case 2 :

top ( l ) ;break ;


case 4 :popMany( l ) ;break ;




case 8 :break ;


}} while ( i != 8 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . Push" ) ;System . out . p r i n t l n ( " 2 . Top" ) ;System . out . p r i n t l n ( " 3 . Pop" ) ;System . out . p r i n t l n ( " 4 . PopMany" ) ;System . out . p r i n t l n ( " 5 . Svuota" ) ;System . out . p r i n t l n ( " 6 . NumeroElementi" ) ;System . out . p r i n t l n ( " 7 . E ' vuota" ) ;System . out . p r i n t l n ( " 8 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

stat ic void push (Coda c ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;System . out . p r i n t l n ( c . push ( e l ) ) ;

}

stat ic void top (Coda c ) {i f ( ! c . empty ( ) )

System . out . p r i n t l n ( c . top ( ) ) ;else


stat ic void pop (Coda c ) {i f ( ! c . empty ( ) )



stat ic void popMany(Coda c ) {System . out . p r i n t ( " I n s e r i s c i numero d i e l ement i da e s t r a r r e : " ) ;int n = scanner . next Int ( ) ;


System . out . p r i n t l n ( c . pop (n ) ) ;}

stat ic void svuota (Coda c ) {c . svuota ( ) ;

}

stat ic void numeroElementi (Coda c ) {System . out . p r i n t l n ( c . count ( ) ) ;

}

stat ic void empty (Coda c ) {System . out . p r i n t l n ( c . empty ( ) ) ;

}}

SC.3 Coda a Priorità

Traccia a pag. 32

Si vuole una coda in cui gli elementi possano essere liberamente accodatie siano connotati da uno tra due possibili livelli di priorità. Il prelievo diun elemento dalla coda dovrà rispettare, in primis, il livello di priorità e,nell'ambito degli elementi aventi la stessa priorità, la disciplina �rst-in-�rst-out (FIFO) di una coda.

La traccia speci�ca esclusivamente il comportamento �esteriore� dellastruttura dati, senza de�nire alcun dettaglio di natura implementativa. Perottenere una struttura avente il comportamento speci�cato è possibile seguirediverse strade. Di seguito sono riportate alcune possibilità.

Approccio 1

La coda a priorità può essere immaginata formata da una sequenza di ele-menti costituita a sua volta da due sotto-sequenze (vedi Figura SC.1):

• una prima sotto-sequenza, che parte dalla testa, che comprende glielementi a priorità alta;

• una successiva sotto-sequenza, che si estende �no alla coda, che com-prende gli elementi a priorità bassa.

Una o entrambe queste sotto-sequenze possono in generale essere vuote.Dal momento che le operazioni di prelievo (pop()) e di inserimento a bassa

priorità (pushLow()) corrispondono in questo caso alle normali operazioniusate nel caso di una classica coda, l'unica operazione nuova da implementareconsiste nell'inserimento in coda di un elemento a priorità alta (pushHigh()).Tale operazione prevede l'aggiunta di un elemento �in coda� agli elementi apriorità alta. In quest'ottica risulta utile de�nire un puntatore h aggiuntivoposizionato sull'ultimo degli elementi a priorità alta. Tale nuovo puntatore


ct

H H H H L L L L L

h

Figura SC.1: Una sequenza di elementi formata da due sotto-sequenzeconsecutive

punterà alla coda degli elementi ad alta priorità, oppure varrà null in casodi assenza di tali elementi.

File PriorityQueue.java

public class Prior i tyQueue {private class Record {


}

Record head ;Record t a i l ; // puntatore a l l a codaRecord ta i l_h ; // puntatore a l l a coda d e l l a so t to sequenza ad

// a l t a p r i o r i t à

public Prior i tyQueue ( ) {}

private void push ( int e l ) {// Creo un nuovo elemento n e l l ' heapRecord temp = new Record ( ) ;temp . elem = e l ;temp . succ = null ;




// se l a t e s t a non punta ad un elemento , deve puntare// a l nuovo elemento : l a s t ru t t u ra , cioè , era vuota// a l momento d e l l ' inser imentoi f ( head == null )

head = temp ;}

public void pushLow( int e l ) {push ( e l ) ; // s i r iduce ad un c l a s s i c o inser imento in coda

}

public void pushHigh ( int e l ) {


i f ( ta i l_h == null ) {

// non c i sono e lement i ad a l t a p r i o r i t à : agg iunta in// t e s t ai f ( head == null ) // l a coda è vuota?

push ( e l ) ; // i n s e r i s c o con push ()else {

Record temp = new Record ( ) ;temp . elem = e l ;temp . succ = head ;head = temp ;

}

ta i l_h = head ; // l ' e lemento i n s e r i t o è in t e s t a :// ta i l_h deve puntarv i

} else {// i n s e r i s c oRecord temp = new Record ( ) ;temp . elem = e l ;temp . succ = tai l_h . succ ;ta i l_h . succ = temp ;

ta i l_h = temp ; // aggiorno i l puntatore ta i l_h

// aggiorno t a i l se l ' e lemento agg iunto è in u l t ima// pos i z i onei f ( ta i l_h . succ == null )

t a i l = ta i l_h ;}

}


Record temp = head ;int el_temp = temp . elem ;

i f ( head == tai l_h ) // ho p r e l e v a t o l ' unico elemento// a p r i o r i t à a l t a ?

ta i l_h = null ; // a l l o r a non ce ne sono più


// se non punta a n ien te vuo le d i r e che l a coda// conteneva un so l o elem . Anche t a i l qu ind i// deve puntare a nu l li f ( head == null ) {

t a i l = null ;ta i l_h = null ;

}

return el_temp ;}




H H H H

L L L L L

t c

t c

SOTTO-CODA ADALTA PRIORITÀ

SOTTO-CODA ABASSA PRIORITÀ

CODA A PRIORITÀ

Figura SC.2: Coda a priorità formata da due classiche code a�ancate

public void c l e a r ( ) {head = t a i l = ta i l_h = null ;

}

public boolean empty ( ) {return head == null ;

}}

Approccio 2

La coda a priorità può essere immaginata composta di due classiche codea�ancate (vedi Figura SC.2), ciascuna destinata a contenere gli elementi diuna singola classe. Il metodo pushLow() accoda nella coda a bassa priorità.Il metodo pushHigh(), viceversa, in quella ad alta priorità. Il metodo pop()restituisce l'elemento di testa nella coda ad alta priorità, se esiste; in casocontrario restituisce l'elemento di testa nella coda a bassa priorità.

Servendosi del meccanismo dell'aggregazione stretta tra classi, le due co-de a�ancate risultano istanze della classe Coda (vedi EC.1). De�nendo taliistanze come membri privati della classe PriorityQueue esse non risulteran-no visibili dall'esterno della struttura (information hiding), la quale conti-nuerà ad apparire ai suoi utenti come una singola coda dotata dei meccanismidi priorità richiesti.import Coda . Coda ;

public class Prior i tyQueue {Coda coda_l ;Coda coda_h ;

public Prior i tyQueue ( ) {coda_l = new Coda ( ) ;coda_h = new Coda ( ) ;

}


L L H H L H L L H

ct

el el el el el el el el el

Figura SC.3: Sequenza di elementi �etichettati�

public void pushLow( int e l ) {coda_l . push ( e l ) ;

}

public void pushHigh ( int e l ) {coda_h . push ( e l ) ;

}

public int pop ( ) {i f ( ! coda_h . empty ( ) )

return coda_h . pop ( ) ;else

return coda_l . pop ( ) ;}

public void c l e a r ( ) {coda_h . svuota ( ) ;coda_l . svuota ( ) ;

}

public boolean empty ( ) {return coda_h . empty ( ) && coda_l . empty ( ) ;

}}

Approccio 3

La coda a priorità può essere una normale coda in cui i record, dispostisecondo l'ordine di inserimento, vengono etichettati con la loro priorità1 (ve-di Figura SC.3). In questo caso sia il metodo pushHigh() che il metodopushLow(), previa opportuna etichettatura, e�ettuano un'aggiunta in coda.È il metodo pop() in questo caso a prendersi carico della restituzione del�giusto� elemento. Tale operazione viene e�ettuata scorrendo tutta la strut-tura alla ricerca del primo elemento ad alta priorità e restituendolo dopoaverlo eliminato dalla coda. In assenza di un elemento ad alta priorità vienerestituito l'eventuale elemento di testa.

1Questo è possibile previa de�nizione di un'opportuna classe che contenga un elementoint ed un valore boolean indicante la relativa priorità.


Tale implementazione, pur prestandosi a diverse ottimizzazioni, non ri-sulta particolarmente e�ciente, richiedendo un ciclo di ricerca per ogni ope-razione Pop() e�ettuata. La sua implementazione non è qui riportata.

Si riporta invece l'implementazione della classe Main che usa una qualsiasidelle due implementazioni presentate di sopra, proprio perché queste sonocompatibili a livello di interfaccia.import java . u t i l . Scanner ;


public stat ic void main ( St r ing [ ] a rgs ) {Prior i tyQueue l = new Prior i tyQueue ( ) ;int i ;


pushLow( l ) ;break ;

case 2 :pushHigh ( l ) ;break ;




case 6 :break ;


}} while ( i != 6 ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 . PushLow" ) ;System . out . p r i n t l n ( " 2 . PushHigh" ) ;System . out . p r i n t l n ( " 3 . Pop" ) ;System . out . p r i n t l n ( " 4 . Svuota" ) ;System . out . p r i n t l n ( " 5 . E ' vuota" ) ;System . out . p r i n t l n ( " 6 . Esc i " ) ;System . out . p r i n t ( " S c e g l i : " ) ;

}

stat ic void pushLow( Prior i tyQueue c ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;c . pushLow( e l ) ;

}


stat ic void pushHigh ( Prior i tyQueue c ) {System . out . p r i n t ( " I n s e r i s c i i n t e r o : " ) ;int e l = scanner . next Int ( ) ;c . pushHigh ( e l ) ;

}

stat ic void pop ( Prior i tyQueue c ) {i f ( ! c . empty ( ) )



stat ic void svuota ( Pr ior i tyQueue c ) {c . c l e a r ( ) ;

}

stat ic void empty ( Pr ior i tyQueue c ) {System . out . p r i n t l n ( c . empty ( ) ) ;

}}

SC.4 PopMinMaxTraccia a pag. 33

private class MinMax {int min ;int max ;

}

// I l metodo seguente e s t r a e n e lement i e ne r e s t i t u i s c e// i l min ed i l maxprivate MinMax _popMinMax( int n) {

MinMax mm = new MinMax ( ) ;mm.min = mm.max = pop ( ) ; // Assegno min e max a l l ' e lemento d i

// t e s t a

int i = 1 ;// confronto con g l i a l t r i n−1 e lement i s e guen t i : n−1// i t e r a z i o n i ( se l a coda non s i svuota prima )while ( ( i < n) && ! empty ( ) ) {

int e l = pop ( ) ;i f ( e l < mm.min )

mm.min = e l ;i f ( e l > mm.max)

mm.max = e l ;i++;

}

return mm;}

// I l metodo seguente chiama _popMinMax() e r e s t i t u i s c e i l// massimopublic int popMax( int n) {

MinMax mm = _popMinMax(n ) ;


return mm.max ;}

// I l metodo seguente chiama _popMinMax() e r e s t i t u i s c e i l// minimopublic int popMin ( int n) {

MinMax mm = _popMinMax(n ) ;return mm.min ;

}

Capitolo SX

Soluzioni degli altri esercizi

SX.1 Accumulatore

Traccia a pag. 35

File Accumulatore.java

public class Accumulatore {private f loat a ;

public Accumulatore ( ) {r e s e t ( ) ;

}

void add ( f loat va l ) {a += val ;

}

void r e s e t ( ) {a = 0 ;

}

f loat getValue ( ) {return a ;

}}

File Main.java



111

SX. Soluzioni degli altri esercizi 112

public stat ic void main ( St r ing [ ] a rgs ) {System . out . p r i n t l n ( " ' a ' add" ) ;System . out . p r i n t l n ( " ' r ' r e s e t " ) ;System . out . p r i n t l n ( " ' s ' show" ) ;System . out . p r i n t l n ( " ' e ' e x i t " ) ;

Accumulatore a = new Accumulatore ( ) ;S t r ing l i n e ;

do {l i n e = scanner . nextLine ( ) ;

switch ( l i n e ) {case "a" :

System . out . p r i n t ( " I n s e r i s c i va l o r e : " ) ;l i n e = scanner . nextLine ( ) ;f loat f = Float . par seF loat ( l i n e ) ;a . add ( f ) ;System . out . p r i n t l n ( "Valore aggiunto . " ) ;break ;

case " r " :a . r e s e t ( ) ;System . out . p r i n t l n ( "Reset accumulatore . " ) ;break ;

case " s " :System . out . p r i n t l n ( " I l va l o r e accumulato è : "

+ a . getValue ( ) ) ;break ;

case "e" :break ;

default :System . out . p r i n t l n ( " Sc e l t a non va l i da " ) ;break ;

}} while ( ! l i n e . equa l s ( "e" ) ) ; // i l metodo equa l s ( ) d e l l a

// c l a s s e S t r ing confronta//due s t r i n gh e

}}

SX.2 Cifratore

Traccia a pag. 35

File Cifratore.java

public class Ci f r a t o r e {public int ch iave ;

public Ci f r a t o r e ( int _chiave ) {ch iave = _chiave ;

}

private char c i f r aCa r a t t e r e (char c , boolean c i f r a ) {


i f ( c i f r a )return (char ) ( c + chiave ) ; // c i f r a t u r a : aggiunge

else

return (char ) ( c − ch iave ) ; // d e c i f r a t u r a : s o t t r a e}

public St r ing c i f r a ( S t r ing s t r ) {// La c l a s s e S t r ing è immutabi le . I suo i c a r a t t e r i non// possono es s e r e mod i f i c a t i . E ' per tanto neces sar io// creare una nuova s t r i n ga contenente l a sequenza de i// c a r a t t e r i c i f r a t i .// La c l a s s e S t r ingBu i l d e r de l package java . lang// è u t i l e a c o s t r u i r e s t r i n gh e in maniera incrementa le .

St r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;for ( int i = 0 ; i < s t r . l ength ( ) ; i++)

sb . append ( c i f r aCa r a t t e r e ( s t r . charAt ( i ) , true ) ) ;return sb . t oS t r i ng ( ) ;

}

public St r ing d e c i f r a ( S t r ing s t r ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;for ( int i = 0 ; i < s t r . l ength ( ) ; i++)

sb . append ( c i f r aCa r a t t e r e ( s t r . charAt ( i ) , fa l se ) ) ;return sb . t oS t r i ng ( ) ;

}}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {System . out . p r i n t ( " I n s e r i s c i l a paro la da c i f r a r e : " ) ;S t r ing paro la = scanner . nextLine ( ) ;

System . out . p r i n t ( " I n s e r i s c i l a ch iave d i c i f r a t u r a : " ) ;S t r ing chiave_s = scanner . nextLine ( ) ;int ch iave = In t eg e r . pa r s e In t ( chiave_s ) ;

C i f r a t o r e c = new Ci f r a t o r e ( ch iave ) ;

System . out . p r i n t l n ( "Parola : " + paro la ) ;S t r ing pa ro l a_c i f r a t a = c . c i f r a ( paro la ) ;System . out . p r i n t l n ( " C i f r a tu ra : " + pa ro l a_c i f r a t a ) ;S t r ing pa ro l a_dec i f r a ta = c . d e c i f r a ( pa ro l a_c i f r a t a ) ;System . out . p r i n t l n ( " Dec i f r a tu ra : " + paro l a_dec i f r a ta ) ;

}}

SX.3 Lista Della Spesa

Traccia a pag. 36


L'attributo nome della classe Articolo è immutabile: il suo valore è pertantoinizializzato contestualmente alla costruzione e mai più modi�cato per tuttoil ciclo di vita della relativa istanza. La clausola final serve proprio a forzaretali controlli da parte del compilatore.

File Articolo.java

public class Art i c o l o {private f ina l St r ing _nome ;private f loat _quantita ;

public Art i c o l o ( S t r ing nome , f loat quant i ta ) {_nome = nome ;_quantita = quant i ta ;

}

public St r ing getNome ( ) {return _nome ;

}

public f loat getQuantita ( ) {return _quantita ;

}

public f loat addQuantita ( f loat q ) {_quantita += q ;return _quantita ;

}}

File ListaDellaSpesa.java

public class Li s taDe l l aSpesa {private class Record {

public Art i c o l o a ;public Record succ ;

}

private Record f i r s t ;private Record l a s t ;

public Li s taDe l l aSpesa ( ) {// f i r s t = nu l l ;// l a s t = nu l l ;// i n i z i a l i z z a z i o n i s up e r f l u e secondo l o standard Java

}

private Record r i c e r c a ( S t r ing nome) {// Questo metodo pr i va t o cerca l ' a r t i c o l o avente i l nome// s p e c i f i c a t o e r e s t i t u i s c e :// − i l puntatore a l corr i spondente Record , se t rova to ;// − nu l l , se non t rova to .Record p = f i r s t ;while (p != null ) {


i f (p . a . getNome ( ) . equa l s (nome ) )return p ;

p = p . succ ;}

return null ;}

public boolean e l im ina ( S t r ing nome) {i f ( f i r s t == null )

return fa l se ;

i f ( f i r s t . a . getNome ( ) . equa l s (nome ) ) {i f ( l a s t == f i r s t ) // se l a s t e f i r s t sono sov rappos t i

// stiamo per canc e l l a r e l ' unico// elemento . Quindi l a s t deve

l a s t = null ; // puntare a nu l l .f i r s t = f i r s t . succ ; // In ogni caso , f i r s t avanza

// d i una pos i z i one in avant i .return true ;

}

// Se siamo qui , l ' e lemento da e l iminare , se c ' è ,// non è i l primo .Record p = f i r s t ;while (p . succ != null ) {

i f (p . succ . a . getNome ( ) . equa l s (nome ) ) {i f ( l a s t == p . succ ) // se l a s t punta a l l ' e lemento

// da e l iminare (p . succ ) l o// facciamo ar r e t r a r e d i una// pos i z i one . Punta qu ind i// a p .

l a s t = p ;p . succ = p . succ . succ ;return true ;

}

p = p . succ ;}

return fa l se ;}

public f loat agg iung i ( S t r ing nome , f loat quant i ta ) {Record p = r i c e r c a (nome ) ;i f (p != null )

return p . a . addQuantita ( quant i ta ) ;else {

Ar t i c o l o a = new Art i c o l o (nome , quant i ta ) ;p = new Record ( ) ;p . a = a ;p . succ = null ;i f ( f i r s t == null )

f i r s t = p ;else

l a s t . succ = p ;l a s t = p ;return quant i ta ;

}}

public f loat getQuantita ( S t r ing nome) {


Record p = r i c e r c a (nome ) ;i f (p != null )

return p . a . getQuantita ( ) ;else

return 0 ;}

public void svuota ( ) {f i r s t = l a s t = null ;

}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = f i r s t ;while (p != null ) {

sb . append (p . a . getNome ( ) + " : " ) ;sb . append (p . a . getQuantita ( ) ) ;p = p . succ ;i f (p != null )

sb . append ( " , " ) ;}


}

File Main.java



private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " '1 ' Aggiungi " ) ;System . out . p r i n t l n ( " '2 ' Elimina" ) ;System . out . p r i n t l n ( " '3 ' GetQuantita" ) ;System . out . p r i n t l n ( " '4 ' Svuota" ) ;System . out . p r i n t l n ( " '5 ' Stampa" ) ;System . out . p r i n t l n ( " '6 ' TestVeloce " ) ;System . out . p r i n t l n ( " '7 ' Esc i " ) ;System . out . p r i n t l n ( " Sc e l t a : " ) ;

}

public stat ic void main ( St r ing [ ] a rgs ) {L i s taDe l l aSpesa l d s = new Li s taDe l l aSpe sa ( ) ;S t r ing l i n e ;

do {stampaMenu ( ) ;l i n e = scanner . nextLine ( ) ;switch ( l i n e ) {case "1" :

agg iung i ( l d s ) ;break ;

case "2" :e l im ina ( l d s ) ;break ;


case "3" :getQuantita ( l d s ) ;break ;

case "4" :svuota ( l d s ) ;break ;

case "5" :stampa ( l d s ) ;break ;

case "6" :t e s tVe l o c e ( l d s ) ;break ;

case "7" :break ;


}} while ( ! l i n e . equa l s ( "7" ) ) ;

}

private stat ic void agg iung i ( L i s taDe l l aSpesa l d s ) {System . out . p r i n t l n ( "Nome a r t i c o l o : " ) ;S t r ing nome = scanner . nextLine ( ) ;System . out . p r i n t l n ( "Quantità a r t i c o l o : " ) ;S t r ing quantita_s = scanner . nextLine ( ) ;f loat quant i ta = Float . par seF loat ( quantita_s ) ;f loat nq = ld s . agg iung i (nome , quant i ta ) ;System . out . p r i n t l n ( "Ora l a quant i tà è : " + nq ) ;

}

private stat ic void e l im ina ( L i s taDe l l aSpesa l d s ) {System . out . p r i n t l n ( "Nome a r t i c o l o : " ) ;S t r ing nome = scanner . nextLine ( ) ;boolean e l im ina to = ld s . e l im ina (nome ) ;i f ( e l im ina to )

System . out . p r i n t l n ( " Ar t i c o l o e l im ina to . " ) ;else

System . out . p r i n t l n ( " Ar t i c o l o non e l im ina to . " ) ;}

private stat ic void getQuantita ( L i s taDe l l aSpesa l d s ) {System . out . p r i n t l n ( "Nome a r t i c o l o : " ) ;S t r ing nome = scanner . nextLine ( ) ;System . out . p r i n t l n ( "La quant i tà è : "

+ ld s . getQuantita (nome ) ) ;}

private stat ic void svuota ( L i s taDe l l aSpe sa l d s ) {l d s . svuota ( ) ;System . out . p r i n t l n ( " L i s t a svuotata . " ) ;

}

private stat ic void stampa ( L i s taDe l l aSpe sa l d s ) {System . out . p r i n t l n ( l d s . t oS t r i ng ( ) ) ;

}

private stat ic void t e s tVe l o c e ( L i s taDe l l aSpe sa l d s ) {l d s . svuota ( ) ;l d s . agg iung i ( "Pane" , 1 f ) ;l d s . agg iung i ( "Latte " , 1 . 5 f ) ;l d s . agg iung i ( "Zucchero" , 1 f ) ;


l d s . agg iung i ( " Pro s c iu t to " , 0 . 3 f ) ;System . out . p r i n t l n ( l d s . t oS t r i ng ( ) ) ;System . out . p r i n t l n ( "Latte : "

+ ld s . agg iung i ( "Latte " , 0 . 5 f ) ) ;l d s . e l im ina ( "Pane" ) ;l d s . e l im ina ( "Zucchero" ) ;l d s . e l im ina ( " Pro s c iu t to " ) ;System . out . p r i n t l n ( "Latte : "

+ ld s . agg iung i ( "Latte " , 0 . 5 f ) ) ;System . out . p r i n t l n ( l d s . t oS t r i ng ( ) ) ;l d s . svuota ( ) ;System . out . p r i n t l n ( l d s . t oS t r i ng ( ) ) ;

}}

SX.4 Predittore di Temperatura

Traccia a pag. 37

Il metodo estimateTemp() deve e�ettuare un'estrapolazione lineare dellatemperatura basandosi sui dati delle ultime due letture comunicate. Laformula da utilizzare è la seguente:

T̂ =T2 − T1

t2 − t1(t− t1) + T1;

dove T̂ è la stima della temperatura all'istante t; T1, T2, t1 e t2 sonole ultime due letture della temperatura ed i relativi due istanti di lettura,rispettivamente.

N.B.: Variando l'implementazione del metodo estimateTemp() si possono operare

stime più accurate della temperatura; si potrebbe per esempio pensare di operare estrapo-

lazioni di ordine superiore al primo. Per giunta ciò, non alterando l'interfaccia della classe,

non comprometterebbe in alcun modo l'integrazione con i moduli utenti del predittore già

realizzati.

File TempPredictor.java

public class TempPredictor {int time1 ;int time2 ;f loat temp1 ;f loat temp2 ;

public TempPredictor ( int time , f loat temp) {// I n i z i a l i z z a r e in ques to modo l e temp . ed i tempi// s i g n i f i c a imporre che l e u l t ime _due_ l e t t u r e d e l l a// temperatura hanno f o r n i t o un r i s u l t . par i a temp e// su ques t e u l t ime due l e t t u r e b isogna e s t r apo l a r e// in i z i a lmen t e l a stima .


time1 = time − 1 ;time2 = time ;temp1 = temp ;temp2 = temp ;

}

public void setTemp ( int time , f loat temp) {time1 = time2 ; // spos ta l ' u l t ima l e t t u r a n e l l a penult imatemp1 = temp2 ;time2 = time ; // aggiorna l ' u l t ima l e t t u r a con i da t i

// i n d i c a t i d a l l ' u t en tetemp2 = temp ;

}

public f loat estimateTemp ( int time ) {return ( temp2 − temp1 ) / ( time2 − time1 )

∗ ( time − time1 ) + temp1 ;}

}

File Main.java

public class Main {

public stat ic void main ( St r ing [ ] a rgs ) {System . out . p r i n t ( " Lettura : a l l ' i s t a n t e 0 : " ) ;System . out . p r i n t l n ( " l a temperatura va l e 14" ) ;

// Posso c o s t r u i r e i l p r e d i t t o r e con qu e s t i d a t i .TempPredictor tp = new TempPredictor (0 , 1 4 ) ;

System . out . p r i n t ( "Stima : l a temperatura a l l ' i s t a n t e " ) ;System . out . p r i n t l n ( "10 sarà " + tp . estimateTemp ( 1 0 ) ) ;;System . out . p r i n t ( "Stima : l a temperatura a l l ' i s t a n t e " ) ;System . out . p r i n t l n ( "20 sarà " + tp . estimateTemp ( 2 0 ) ) ;

System . out . p r i n t ( " Lettura : a l l ' i s t a n t e 5 : " ) ;System . out . p r i n t l n ( " l a temperatura va l e 16" ) ;

// Comunico l a l e t t u r a a l p r e d i t t o r etp . setTemp (5 , 1 6 ) ;

System . out . p r i n t ( "Stima : l a temperatura a l l ' i s t a n t e " ) ;System . out . p r i n t l n ( "10 sarà " + tp . estimateTemp ( 1 0 ) ) ;


System . out . p r i n t ( " Lettura : a l l ' i s t a n t e 10 : " ) ;System . out . p r i n t l n ( " l a temperatura va l e 16" ) ;

// Comunico l a l e t t u r a a l p r e d i t t o r etp . setTemp (10 , 1 6 ) ;




}}

SX.5 Contenitore

Traccia a pag. 38

La classe Oggetto è progettata come classe �immutabile�. I suoi membrivengono pertanto tutti inizializzati all'atto della costruzione e il loro valorenon può mai più essere modi�cato. La clausola final garantisce proprio cheil compilatore e�ettui questi controlli.

File Oggetto.java

public class Oggetto {private f ina l St r ing nome ;private f ina l int peso ;

public Oggetto ( S t r ing nome , int peso ) {this . nome = nome ;this . peso = peso ;

}

public St r ing getNome ( ) {return nome ;

}

public int getPeso ( ) {// s i t r a t t i i l peso come va l o r e in t e ro (p . es . grammi)return peso ;

}}

File Contenitore.java

public class Conten i tore {private class Ce l l a {

public Oggetto elem ;Ce l l a succ ;

} ;

Ce l l a f i r s t ;int capac i ta ;int somma_pesi ;int nelem ;

public Conten i tore ( int pesoMax ) {// f i r s t = nu l l ;capac i ta = pesoMax ;// somma_pesi = 0;// nelem = 0;// l e i n i z i a l i z z a z i o n i commentate// sono supe r f l u e secondo l o standard Java


}

public boolean i n s e r i s c i ( S t r ing nome , int peso ) {i f ( peso <= capac i ta − somma_pesi ) {

Ce l l a c = new Cel l a ( ) ;c . elem = new Oggetto (nome , peso ) ;c . succ = f i r s t ;f i r s t = c ;somma_pesi += peso ; // i l con t en i t o r e è ora più

// pesante d i p . . .nelem++; // . . . e c ' è un elemento in più .

return true ;}

return fa l se ;}

public void svuota ( ) {f i r s t = null ;somma_pesi = 0 ;nelem = 0 ;

}

public int pesoCompless ivo ( ) {return somma_pesi ;

}

public int pesoResiduo ( ) {return capac i t a − somma_pesi ;

}

public int numElem( ) {return nelem ;

}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Ce l l a p = f i r s t ;while (p != null ) {

sb . append (p . elem . getNome ( ) + " : " ) ;sb . append (p . elem . getPeso ( ) ) ;p = p . succ ;i f (p != null )

sb . append ( " , " ) ;}


}

File Main.java


public class Main {private stat ic Scanner scanner = new Scanner ( System . in ) ;

public stat ic void main ( St r ing [ ] a rgs ) {System . out . p r i n t ( " I n s e r i s c i peso MAX con t en i t o r e : " ) ;


St r ing l i n e = scanner . nextLine ( ) ;Conten i tore c = new Conten i tore ( In t eg e r . pa r s e In t ( l i n e ) ) ;

do {stampa_menu ( ) ;l i n e = scanner . nextLine ( ) ;switch ( l i n e ) {case "1" :

i n s e r i s c i ( c ) ;break ;

case "2" :svuota ( c ) ;break ;

case "3" :pesoCompless ivo ( c ) ;break ;

case "4" :pesoResiduo ( c ) ;break ;

case "5" :numeroElementi ( c ) ;break ;

case "6" :stampa ( c ) ;break ;

case "7" :break ;



}

private stat ic void stampa_menu ( ) {System . out . p r i n t l n ( " 1 : I n s e r i s c i . " ) ;System . out . p r i n t l n ( " 2 : Svuota . " ) ;System . out . p r i n t l n ( " 3 : Peso Complessivo . " ) ;System . out . p r i n t l n ( " 4 : Peso Residuo . " ) ;System . out . p r i n t l n ( " 5 : Numero Elementi . " ) ;System . out . p r i n t l n ( " 6 : Stampa . " ) ;System . out . p r i n t l n ( " 7 : Esc i . " ) ;

}

private stat ic void i n s e r i s c i ( Conten i tore c ) {System . out . p r i n t ( " I n s e r i s c i nome elemento : " ) ;S t r ing nome = scanner . nextLine ( ) ;System . out . p r i n t ( " I n s e r i s c i peso elemento : " ) ;S t r ing peso_s = scanner . nextLine ( ) ;int peso = In t eg e r . pa r s e In t ( peso_s ) ;i f ( c . i n s e r i s c i (nome , peso ) )

System . out . p r i n t l n ( "Elemento i n s e r i t o . " ) ;else

System . out . p r i n t l n ( "Elemento NON i n s e r i t o . " ) ;}

private stat ic void svuota ( Conten i tore c ) {c . svuota ( ) ;System . out . p r i n t l n ( "Conten i tore svuotato . " ) ;

}

private stat ic void pesoCompless ivo ( Conten i tore c ) {


System . out . p r i n t l n ( " I l peso compless ivo è : "+ c . pesoCompless ivo ( ) ) ;

}

private stat ic void pesoResiduo ( Conten i tore c ) {System . out . p r i n t l n ( " I l peso r e s i duo è : "

+ c . pesoResiduo ( ) ) ;}

private stat ic void numeroElementi ( Conten i tore c ) {System . out . p r i n t l n ( "N. Elem : " + c . numElem ( ) ) ;

}

private stat ic void stampa ( Conten i tore c ) {System . out . p r i n t l n ( " I l contenuto de l c on t en i t o r e e ' : " ) ;System . out . p r i n t l n ( c . t oS t r i ng ( ) ) ;

}}

SX.6 Lista Prenotazioni

Traccia a pag. 39

La classe Prenotazione è progettata come classe �immutabile�. I suoi mem-bri vengono pertanto tutti inizializzati all'atto della costruzione e il loro va-lore non può mai più essere modi�cato. La clausola final garantisce proprioche il compilatore e�ettui questi controlli.

File Prenotazione.java

public class Prenotaz ione {private f ina l int matr i co la ;private f ina l St r ing nome ;

public Prenotaz ione ( int matr ico la , S t r ing nome) {this . mat r i co la = matr i co la ;this . nome = nome ;

}

public int getMatr i co la ( ) {return matr i co la ;

}


}

public St r ing toS t r i ng ( ) {return matr i co la + " : " + nome ;

}}

File ListaPrenotazioni.java


public class L i s t aPr eno ta z i on i {private Prenotaz ione [ ] vp ;private int po s t i ;private int nelem ;

private int r i c e r c a ( int matr ) {for ( int i = 0 ; i < nelem ; i++)

i f ( vp [ i ] . g e tMatr i co la ( ) == matr ) // se l o t rovoreturn i ; // ne r e s t i t u i s c o l ' i nd i c e

return −1; // a l t r imen t i r e s t i t u i s c o −1}

public L i s t aPr eno ta z i on i ( int po s t i ) {this . p o s t i = po s t i ;this . vp = new Prenotaz ione [ p o s t i ] ;// t h i s . nelem = 0;// ques t ' u l t ima i n i z i a l i z z a z i o n e Ã� supe r f l ua// secondo l o standard Java

}

public boolean prenota ( int matr , S t r ing nome) {i f ( ( g e tPo s t iD i s p on i b i l i ( ) > 0)

&& ! e s i s t eP r eno t a z i on e (matr ) ) {vp [ nelem++] = new Prenotaz ione (matr , nome ) ;return true ;

}

return fa l se ;}

public boolean e l iminaPrenotaz ione ( int matr ) {int i = r i c e r c a (matr ) ;

i f ( i >= 0) {for ( int j = i ; j < nelem − 1 ; j++)

vp [ j ] = vp [ j + 1 ] ;

nelem−−;

return true ;}

return fa l se ;}

public int g e tPo s t iD i s p on i b i l i ( ) {return po s t i − nelem ;

}

public boolean e s i s t eP r eno t a z i on e ( int matr ) {return r i c e r c a (matr ) >= 0 ;

}

public void svuota ( ) {nelem = 0 ;

}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;for ( int i = 0 ; i < nelem ; i++) {


sb . append (vp [ i ] . t oS t r i ng ( ) ) ;sb . append ( " − " ) ;

}


}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;System . out . p r i n t ( " I n s e r i r e i l numero d i po s t i "

+ " d i s p o n i b i l i : " ) ;l i n e = scanner . nextLine ( ) ;int po s t i = In t eg e r . pa r s e In t ( l i n e ) ;

L i s t aPr eno ta z i on i l = new L i s t aPr eno ta z i on i ( p o s t i ) ;

do {stampaMenu ( ) ;System . out . p r i n t ( " Sc e l t a : " ) ;l i n e = scanner . nextLine ( ) ;switch ( l i n e ) {case "1" :

prenota ( l ) ;break ;

case "2" :e l im inaPrenotaz ione ( l ) ;break ;

case "3" :p o s t iD i s p o n i b i l i ( l ) ;break ;

case "4" :e s i s t eP r eno t a z i on e ( l ) ;break ;

case "5" :svuota ( l ) ;break ;

case "6" :stampa ( l ) ;break ;

case "7" :break ;



}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 : Prenota . " ) ;System . out . p r i n t l n ( " 2 : Elimina prenotaz ione . " ) ;System . out . p r i n t l n ( " 3 : Post i d i s p o n i b i l i . " ) ;


System . out . p r i n t l n ( " 4 : E s i s t e prenotaz ione . " ) ;System . out . p r i n t l n ( " 5 : Svuota . " ) ;System . out . p r i n t l n ( " 6 : Stampa . " ) ;System . out . p r i n t l n ( " 7 : Esc i . " ) ;

}

private stat ic void prenota ( L i s t aPr eno ta z i on i l ) {System . out . p r i n t ( " I n s e r i s c i matr i co la : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int matr = In t eg e r . pa r s e In t ( l i n e ) ;System . out . p r i n t ( " I n s e r i s c i nome : " ) ;S t r ing nome = scanner . nextLine ( ) ;i f ( l . prenota (matr , nome ) )

System . out . p r i n t l n ( "Prenotaz ione e f f e t t u a t a . " ) ;else

System . out . p r i n t l n ( "Prenotaz ione non e f f e t t u a t a " ) ;}

private stat ic void e l iminaPrenotaz ione ( L i s t aPr eno ta z i on i l ) {System . out . p r i n t ( " I n s e r i s c i matr i co la : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int matr = In t eg e r . pa r s e In t ( l i n e ) ;i f ( l . e l im inaPrenotaz ione (matr ) )

System . out . p r i n t l n ( "Prenotaz ione e l im ina ta . " ) ;else

System . out . p r i n t l n ( "Prenotaz ione non e l im ina ta " ) ;}

private stat ic void p o s t iD i s p o n i b i l i ( L i s t aPr eno ta z i on i l ) {System . out . p r i n t l n ( " I po s t i d i s p o n i b i l i sono : "

+ l . g e tPo s t iD i s p on i b i l i ( ) ) ;}

private stat ic void e s i s t eP r eno t a z i on e ( L i s t aPr eno ta z i on i l ) {System . out . p r i n t ( " I n s e r i s c i matr i co la : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int matr = In t eg e r . pa r s e In t ( l i n e ) ;i f ( l . e s i s t eP r eno t a z i on e (matr ) )

System . out . p r i n t l n ( "Prenotaz ione e s i s t e n t e . " ) ;else

System . out . p r i n t l n ( "Prenotaz ione non e s i s t e n t e " ) ;}

private stat ic void svuota ( L i s t aPr eno ta z i on i l ) {l . svuota ( ) ;System . out . p r i n t l n ( " L i s t a svuotata . " ) ;

}

private stat ic void stampa ( L i s t aPr eno ta z i on i l ) {System . out . p r i n t l n ( l . t oS t r i ng ( ) ) ;

}}

SX.7 Classi�ca

Traccia a pag. 40


File Squadra.java

public class Squadra {private f ina l St r ing nome ;private f ina l int punteggio ;

public Squadra ( S t r ing nome , int punteggio ) {this . nome = nome ;this . punteggio = punteggio ;

}


}

public int getPunteggio ( ) {return punteggio ;

}

public St r ing toS t r i ng ( ) {return nome + " : " + punteggio ;

}}

File Classifica.java

public class C l a s s i f i c a {private class Record {

public Squadra squadra ;public Record succ ;

}

private Record f i r s t ;private int nelem ;

private int e l im ina ( S t r ing nome) {// Questo metodo e l imina d a l l a s t r u t t u r a un even tua l e// elem . avente nome par i ad n . In caso d i e s i s t e n z a// ne r e s t i t u i s c e i l punteggio , a l t r imen t i r e s t i t u i s c e 0 .

// E ' i l primo elemento?i f ( ( f i r s t != null )

&& ( f i r s t . squadra . getNome ( ) . equa l s (nome ) ) ) {int punti = f i r s t . squadra . getPunteggio ( ) ;f i r s t = f i r s t . succ ;nelem−−;return punti ;

}

// E ' un elemento succe s s i vo a l primo?Record p = f i r s t ;while ( ( p != null ) && (p . succ != null ) ) {

// c on t r o l l o se i l s u c c e s s i vo d i p deve e s s e r e e l imina toi f (p . succ . squadra . getNome ( ) . equa l s (nome ) ) {

int punti = p . succ . squadra . getPunteggio ( ) ;p . succ = p . succ . succ ;nelem−−;return punti ;

}


p = p . succ ;}

// Elemento non t rova toreturn 0 ;

}

private void inser imentoOrdinato ( S t r ing nome , int punteggio ) {// Questo metodo e f f e t t u a un inser imento ord inato n e l l a// s t ru t t u ra , in base a l campo puntegg io . Si procede// a t t r a v e r s o i s e guen t i pa s s i :// − se l a l i s t a è vuota s i ins . l ' elem . e s i esce ;// − s i c on t r o l l a se ins . in t e s t a : se s ì , s i ins .// e s i esce ;// − s i cerca i l punto d i inser imento a t t r a v e r s o una// v i s i t a , s i i n s e r i s c e ( eventualmente in coda ) e// s i esce .

// In ogni caso a l l o c o un nuovo recordRecord nuovo = new Record ( ) ;nuovo . squadra = new Squadra (nome , punteggio ) ;nelem++;

i f ( f i r s t == null ) { // Se l a l i s t a è vuotaf i r s t = nuovo ; // In s e r i s c o a l l a t e s t anuovo . succ = null ;

} else {// Se i l puntegg io d e l l a nuova squadra è maggiore// d i q u e l l o puntato d a l l a t e s t a . . .i f ( punteggio >= f i r s t . squadra . getPunteggio ( ) ) {

nuovo . succ = f i r s t ; // . . . i n s e r i s c o in t e s t af i r s t = nuovo ;

} else { // Devo cercare i l punto d i i n s e r z i oneRecord p = f i r s t ;while (p . succ != null ) {

// Devo i n s e r i r e dopo l ' e lemento puntato da p?i f ( punteggio >= p . succ . squadra

. getPunteggio ( ) ) {nuovo . succ = p . succ ;p . succ = nuovo ;return ;

}

p = p . succ ;}

// Se sono qui , non ho ancora i n s e r i t o : inserim .// in coda , a l l a qua le punta pp . succ = nuovo ;nuovo . succ = null ;

}}

}

public C l a s s i f i c a ( ) {// f i r s t = nu l l ;// nelem = 0;// i n i z i a l i z z a z i o n i s up e r f l u e secondo// l o standard Java

}


public int agg iung i ( S t r ing nome , int punteggio ) {// Elimina d a l l a l i s t a l ' e lemento ( se e s i s t e )int p = e l imina (nome ) ;

// Lo ( re ) i n s e r i s c e a l pos to g i u s t oinser imentoOrdinato (nome , punteggio + p ) ;

// Re s t i t u i s c e i l g i u s t o puntegg ioreturn punteggio + p ;

}

public void svuota ( ) {f i r s t = null ;nelem = 0 ;

}


sb . append (p . squadra . t oS t r i ng ( ) ) ;// aggiungiamo un r i t o rno a caposb . append ( System . l i n eS epa r a t o r ( ) ) ;p = p . succ ;

}


public int count ( ) {return nelem ;

}}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;C l a s s i f i c a c = new C l a s s i f i c a ( ) ;


i n s e r i s c i ( c ) ;break ;

case "2" :svuota ( c ) ;break ;

case "3" :stampa ( c ) ;break ;

case "4" :


count ( c ) ;break ;

case "5" :break ;



}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 : I n s e r i s c i . " ) ;System . out . p r i n t l n ( " 2 : Svuota . " ) ;System . out . p r i n t l n ( " 3 : Stampa . " ) ;System . out . p r i n t l n ( " 4 : Count . " ) ;System . out . p r i n t l n ( " 5 : Esc i . " ) ;

}

private stat ic void i n s e r i s c i ( C l a s s i f i c a c ) {System . out . p r i n t ( " I n s e r i s c i nome : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;S t r ing nome = l i n e ;System . out . p r i n t ( " I n s e r i s c i punteggio : " ) ;l i n e = scanner . nextLine ( ) ;int punteggio = In t eg e r . pa r s e In t ( l i n e ) ;

System . out . p r i n t l n ( "La squadra " + nome + " ora ha "+ c . agg iung i (nome , punteggio ) + " punti . " ) ;

}

private stat ic void svuota ( C l a s s i f i c a c ) {c . svuota ( ) ;System . out . p r i n t l n ( " C l a s s i f i c a svuotata . " ) ;

}

private stat ic void stampa ( C l a s s i f i c a c ) {System . out . p r i n t l n ( c . t oS t r i ng ( ) ) ;

}

private stat ic void count ( C l a s s i f i c a c ) {System . out . p r i n t l n ( " I l numero d i squadre in "

+ " c l a s s i f i c a è " + c . count ( ) ) ;}

}

SX.8 Agenzia Matrimoniale

Traccia a pag. 41

File Persona.java

public class Persona {private f ina l St r ing nome ;private f ina l boolean maschio ;


Persona coniuge ;

public Persona ( S t r ing nome , boolean maschio ) {this . nome = nome ;this . maschio = maschio ;coniuge = null ;

}

public St r ing getnome ( ) {return nome ;

}

public boolean getMaschio ( ) {return maschio ;

}

public Persona getConiuge ( ) {return coniuge ;

}

public boolean coniugato ( ) {return coniuge != null ;

}

public boolean setConiuge ( Persona coniuge ) {// in ques to metodo , coniuge è l a v a r i a b i l e l o ca l e ,// mentre t h i s . coniuge s i r i f e r i s c e a l l a v a r i a b i l e// membro pr i va t a d e l l a c l a s s e .// Anche se hanno l o s t e s s o i d e n t i f i c a t i v o , sono due// r i f e r imen t i completamente ind ipenden t i .

// i l coniuge non può e s s e r e nu l li f ( coniuge == null )

return fa l se ;// non è dunque p r e v i s t o i l d i v o r z i o

// se io o i l coniuge siamo g ià s po s a t ii f ( ( this . coniuge != null ) | | ( coniuge . coniuge != null ) )

return fa l se ; // ques to matrimonio non s ' ha da fa r e

// se io e i l coniuge siamo d e l l o s t e s s o se s soi f ( maschio == coniuge . maschio )

return fa l se ; // ques to matrimonio non s ' ha da fa r e// non è dunque p r e v i s t o i l matrimonio e g u a l i t a r i o .

this . con iuge = coniuge ; // coniuge d iven ta mio coniuge econiuge . coniuge = this ; // io d iven to coniuge d i coniugereturn true ; // auguri e f i g l i maschi !

}

public St r ing toS t r i ng (boolean ancheConiuge ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;sb . append (nome ) ;sb . append ( " − " ) ;sb . append (maschio ? "maschio " : "femmina " ) ;i f ( ( ancheConiuge ) && ( coniuge != null ) ) {

sb . append ( " − Coniugat" + (maschio ? "o" : "a" )+ " con : " ) ;

sb . append ( coniuge . t oS t r i ng ( fa l se ) ) ;

// nota che s c r i v e r e ' t rue ' n e l l a r i ga d i// sopra innescherebbe una r i c o r s i one i n f i n i t a


// in caso d i stampa di persona coniugata .}


}

File AgenziaMatrimoniale.java

public class AgenziaMatrimoniale {private class Record {

public Persona persona ;public Record succ ;

}

private Record f i r s t ;

public AgenziaMatrimoniale ( ) {// f i r s t = nu l l ;// i n i z i a l i z z a z i o n e supe r f l ua secondo// l o standard Java

}

private Record ce rca ( S t r ing nome) {// Cerca n e l l a l i s t a l a persona avente i l nome// s p e c i f i c a t o . Re s t i t u i s c e i l puntatore a l l a// corr i spondente c e l l a se e s i s t e , n u l l a l t r im .Record p = f i r s t ;while (p != null ) {

i f (p . persona . getnome ( ) . equa l s (nome ) )return p ;

p = p . succ ;}

return null ;}

public boolean agg iungiPersona ( St r ing nome , boolean maschio ) {i f ( ce r ca (nome) != null )

return fa l se ;

// Inserimento in t e s t aRecord p = new Record ( ) ;p . persona = new Persona (nome , maschio ) ;p . succ = f i r s t ;f i r s t = p ;

return true ;}

public boolean sposa ( S t r ing nome1 , S t r ing nome2) {Record p1 = cerca (nome1 ) ;

// se i l primo nome non è s t a t o t rova toi f ( p1 == null )

return fa l se ; // r e s t i t u i s c o f a l s e

Record p2 = cerca (nome2 ) ;

// se i l secondo nome non è s t a t o t rova to


i f ( p2 == null )return fa l se ; // r e s t i t u i s c o f a l s e

return p1 . persona . setConiuge ( p2 . persona ) ;// l a chiamata a l metodo setConiuge () f o r za t u t t i i// c o n t r o l l i r i c h i e s t i per i l matrimonio t ra due// persone

}

public class RicercaConiugato {public boolean t rovato ;public boolean coniugato ;

public RicercaConiugato (boolean trovato ,boolean coniugato ) {

this . t rovato = trovato ;this . con iugato = coniugato ;

}}

public RicercaConiugato coniugato ( S t r ing nome) {Record p = cerca (nome ) ;

i f (p == null )return new RicercaConiugato ( false , fa l se ) ;

return new RicercaConiugato ( true , p . persona . coniugato ( ) ) ;}

public int numeroSposi ( ) {int numero = 0 ;Record p = f i r s t ;while (p != null ) {

i f (p . persona . coniugato ( ) )numero++;

p = p . succ ;}

return numero ;}

public int numeroCoppie ( ) {return numeroSposi ( ) / 2 ;

}

public void svuota ( ) {f i r s t = null ;

}


sb . append ( ( p . persona . t oS t r i ng ( true ) ) ) ;sb . append ( System . l i n eS epa r a t o r ( ) ) ;p = p . succ ;

}


}


File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;AgenziaMatrimoniale am = new AgenziaMatrimoniale ( ) ;


agg iungiPersona (am) ;break ;

case "2" :sposa (am) ;break ;

case "3" :con iugato (am) ;break ;

case "4" :numeroSposi (am) ;break ;

case "5" :numeroCoppie (am) ;break ;

case "6" :svuota (am) ;break ;

case "7" :stampa (am) ;break ;

case "8" :break ;



}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 : AggiungiPersona . " ) ;System . out . p r i n t l n ( " 2 : Sposa . " ) ;System . out . p r i n t l n ( " 3 : Coniugato . " ) ;System . out . p r i n t l n ( " 4 : NumeroSposi . " ) ;System . out . p r i n t l n ( " 5 : NumeroCoppie . " ) ;System . out . p r i n t l n ( " 6 : Svuota . " ) ;System . out . p r i n t l n ( " 7 : Stampa . " ) ;System . out . p r i n t l n ( " 8 : Esc i . " ) ;

}

private stat ic void agg iungiPersona ( AgenziaMatrimoniale am) {System . out . p r i n t ( " I n s e r i s c i nome : " ) ;S t r ing nome = scanner . nextLine ( ) ;


St r ing s e s s o ;boolean ok ;do {

System . out . p r i n t ( " S p e c i f i c a r e i l s e s s o (M, F ) : " ) ;s e s s o = scanner . nextLine ( ) ;ok = s e s s o . equa l s ( "M" ) | | s e s s o . equa l s ( "m" )

| | s e s s o . equa l s ( "F" ) | | s e s s o . equa l s ( " f " ) ;} while ( ! ok ) ;

boolean maschio = s e s s o . equa l s ( "M" ) | | s e s s o . equa l s ( "m" ) ;

i f (am. agg iungiPersona (nome , maschio ) )System . out . p r i n t l n ( "Persona aggiunta . " ) ;

else

System . out . p r i n t l n ( "Persona non aggiunta " ) ;}

private stat ic void sposa ( AgenziaMatrimoniale am) {System . out . p r i n t ( " I n s e r i s c i i l primo nome : " ) ;S t r ing nome1 = scanner . nextLine ( ) ;System . out . p r i n t ( " I n s e r i s c i i l secondo nome : " ) ;S t r ing nome2 = scanner . nextLine ( ) ;

i f (am. sposa (nome1 , nome2 ) )System . out . p r i n t l n ( "Matrimonio r e g i s t r a t o . " ) ;

else

System . out . p r i n t l n ( "Matrimonio non r e g i s t r a t o . " ) ;}

public stat ic void coniugato ( AgenziaMatrimoniale am) {System . out . p r i n t ( " I n s e r i s c i i l nome : " ) ;S t r ing nome = scanner . nextLine ( ) ;AgenziaMatrimoniale . RicercaConiugato rc = am. coniugato (nome ) ;i f ( ! r c . t rovato )

System . out . p r i n t l n ( "Persona non e s i s t e n t e . " ) ;else i f ( rc . con iugato )

System . out . p r i n t l n ( "E ' coniugato . " ) ;else

System . out . p r i n t l n ( "Non è coniugato . " ) ;}

private stat ic void numeroSposi ( AgenziaMatrimoniale am) {System . out . p r i n t ( " I l numero spo s i è pa r i a " ) ;System . out . p r i n t (am. numeroSposi ( ) ) ;System . out . p r i n t l n ( " . " ) ;

}

private stat ic void numeroCoppie ( AgenziaMatrimoniale am) {System . out . p r i n t ( " I l numero coppie è par i a " ) ;System . out . p r i n t (am. numeroCoppie ( ) ) ;System . out . p r i n t l n ( " . " ) ;

}

private stat ic void svuota ( AgenziaMatrimoniale am) {am. svuota ( ) ;System . out . p r i n t l n ( "Agenzia svuotata . " ) ;

}

private stat ic void stampa ( AgenziaMatrimoniale am) {System . out . p r i n t l n (am. toS t r i ng ( ) ) ;

}}


first 44 1 1 43 1 1 42 2 1

Taglia dei pattini

Numero pattinicomplessivo

Numero pattinidisponibili

Figura SX.1: La struttura che implementa il parco pattini.

SX.9 Parco Pattini

Traccia a pag. 43

La struttura dati può essere realizzata come una lista dinamica semplicemen-te collegata in cui ogni elemento rappresenta lo stato di tutti i pattini di unadata taglia. La generica cella della struttura contiene dunque:

• taglia dei pattini;

• numero totale di pattini della taglia data;

• numero totale di pattini disponibili della taglia data.A titolo esempli�cativo si immagini che il parco pattini disponga di un

paio di pattini della taglia 44, di un paio della taglia 43 e di due paia dellataglia 42. Se uno delle due paia di pattini della taglia 42 risulta �ttato, lostato della struttura è mostrato in Figura SX.1.

Si noti come la struttura ammetta una gestione di tipo tabellare, dalmomento che la taglia dei pattini risulta essere unica per ogni cella, e quindiassimilabile ad una chiave.

Di seguito si riporta il listato.

File StatoTaglia.java

public class StatoTag l ia {public int t a g l i a ;public int t o t a l i ;public int d i s p o n i b i l i ;

public St r ing toS t r i ng ( ) {return "Tagl ia : " + t a g l i a + " − to t . : " + t o t a l i

+ " − d i sp . : " + d i s p o n i b i l i ;}

}

File ParcoPattini.java


public class ParcoPatt in i {private class Record {

public StatoTag l ia s t a toTag l i a ;public Record succ ;

}

private Record f i r s t ;private int to t ;

private Record getRecordByTaglia ( int t a g l i a ) {// Questo metodo permette l a g e s t i one d e l l a l i s t a come// t a b e l l a . Re s t i t u i s c e i l punt . a l l a c e l l a contenente// i p a t t i n i d e l l a t a g l i a r i c h i e s t a , oppure 0 se t a l e// c e l l a non è n e l l a l i s t a .

Record p = f i r s t ;while (p != null )

i f (p . s t a t oTag l i a . t a g l i a == t a g l i a )return p ;

else

p = p . succ ;

return null ;}

public void agg i ung iPa t t i n i ( int t a g l i a ) {Record p = getRecordByTaglia ( t a g l i a ) ;

i f (p != null ) {p . s t a toTag l i a . t o t a l i ++;p . s t a toTag l i a . d i s p o n i b i l i ++;

} else {p = new Record ( ) ;p . s t a t oTag l i a = new StatoTag l ia ( ) ;p . s t a t oTag l i a . t a g l i a = t a g l i a ;p . s t a t oTag l i a . t o t a l i = 1 ;p . s t a toTag l i a . d i s p o n i b i l i = 1 ;p . succ = f i r s t ;f i r s t = p ;

}

to t++;}

public void svuota ( ) {f i r s t = null ;t o t = 0 ;

}

public int numeroTotPattini ( ) {return to t ;

}

public boolean f i t t a ( int t a g l i a ) {Record p = getRecordByTaglia ( t a g l i a ) ;

// c i sono p a t t i n i d e l l a t a g l i a s p e c i f i c a t a , e se s ì ,// ce ne sono di d i s p o n i b i l i ?i f ( ( p != null ) && (p . s t a toTag l i a . d i s p o n i b i l i > 0) ) {

p . s t a toTag l i a . d i s p o n i b i l i −−; // decrementa l a// d i s p o n i b i l i t à

return true ;


} else

return fa l se ;}

public int d i s p o n i b i l i t a ( int t a g l i a ) {Record p = getRecordByTaglia ( t a g l i a ) ;

i f (p != null )return p . s t a toTag l i a . d i s p o n i b i l i ;

return 0 ;}

public int numeroPattini ( int t a g l i a ) {Record p = getRecordByTaglia ( t a g l i a ) ;

i f (p != null )return p . s t a toTag l i a . t o t a l i ;

return 0 ;}

public boolean r e s t i t u z i o n e ( int t a g l i a ) {Record p = getRecordByTaglia ( t a g l i a ) ;

// c i sono p a t t i n i d e l l a t a g l i a s p e c i f . , e se s ì ,// ce ne sono di f i t t a t i ?i f ( ( p != null )

&& (p . s t a toTag l i a . d i s p o n i b i l i < p . s t a toTag l i a . t o t a l i ) ) {p . s t a toTag l i a . d i s p o n i b i l i ++;return true ;

}

return fa l se ;}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = f i r s t ;

while (p != null ) {sb . append (p . s t a toTag l i a . t oS t r i ng ( ) ) ;sb . append ( System . l i n eS epa r a t o r ( ) ) ;p = p . succ ;

}


}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;ParcoPatt in i parco = new ParcoPatt in i ( ) ;



agg i ung iPa t t i n i ( parco ) ;break ;

case "2" :svuota ( parco ) ;break ;

case "3" :numeroTotPattini ( parco ) ;break ;

case "4" :f i t t a ( parco ) ;break ;

case "5" :d i s p o n i b i l i t a ( parco ) ;break ;

case "6" :numeroPattini ( parco ) ;break ;

case "7" :r e s t i t u z i o n e ( parco ) ;break ;

case "8" :stampa ( parco ) ;break ;

case "9" :break ;



}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 : Agg iung iPatt in i . " ) ;System . out . p r i n t l n ( " 2 : Svuota . " ) ;System . out . p r i n t l n ( " 3 : NumeroTotPattini . " ) ;System . out . p r i n t l n ( " 4 : F i t ta . " ) ;System . out . p r i n t l n ( " 5 : D i s p on i b i l i t à . " ) ;System . out . p r i n t l n ( " 6 : NumeroPattini . " ) ;System . out . p r i n t l n ( " 7 : Re s t i tu z i one . " ) ;System . out . p r i n t l n ( " 8 : Stampa . " ) ;System . out . p r i n t l n ( " 9 : Esc i . " ) ;

}

private stat ic void agg iung iPa t t i n i ( ParcoPatt in i p ) {System . out . p r i n t ( " I n s e r i r e l a t a g l i a : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int t a g l i a = In t eg e r . pa r s e In t ( l i n e ) ;p . a gg i ung iPa t t i n i ( t a g l i a ) ;System . out . p r i n t l n ( " Pa t t i n i agg iun t i a l parco . " ) ;

}

private stat ic void svuota ( ParcoPatt in i p ) {p . svuota ( ) ;System . out . p r i n t l n ( "Parco svuotato . " ) ;


}

private stat ic void numeroTotPattini ( ParcoPatt in i p) {System . out . p r i n t ( " I l parco p a t t i n i cont i ene " ) ;System . out . p r i n t (p . numeroTotPattini ( ) ) ;System . out . p r i n t l n ( " paia d i p a t t i n i in t o t a l e . " ) ;

}

private stat ic void f i t t a ( ParcoPatt in i p ) {System . out . p r i n t ( " I n s e r i r e l a t a g l i a : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int t a g l i a = In t eg e r . pa r s e In t ( l i n e ) ;i f (p . f i t t a ( t a g l i a ) )

System . out . p r i n t l n ( " Pa t t i n i f i t t a t i . " ) ;else

System . out . p r i n t l n ( " Pa t t i n i non d i s p o n i b i l i . " ) ;}

private stat ic void d i s p o n i b i l i t a ( ParcoPatt in i p ) {System . out . p r i n t ( " I n s e r i r e l a t a g l i a : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int t a g l i a = In t eg e r . pa r s e In t ( l i n e ) ;System . out . p r i n t l n ( " D i s p on i b i l i t a ' t a g l i a " + t a g l i a

+ " : " + p . d i s p o n i b i l i t a ( t a g l i a ) + " . " ) ;}

private stat ic void numeroPattini ( ParcoPatt in i p) {System . out . p r i n t ( " I n s e r i r e l a t a g l i a : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int t a g l i a = In t eg e r . pa r s e In t ( l i n e ) ;System . out . p r i n t l n ( " I l parco cont i ene "

+ p . numeroPattini ( t a g l i a )+ " paia d i p a t t i n i d i t a g l i a " + t a g l i a + " . " ) ;

}

private stat ic void r e s t i t u z i o n e ( ParcoPatt in i p ) {System . out . p r i n t ( " I n s e r i r e l a t a g l i a : " ) ;S t r ing l i n e = scanner . nextLine ( ) ;int t a g l i a = In t eg e r . pa r s e In t ( l i n e ) ;i f (p . r e s t i t u z i o n e ( t a g l i a ) )

System . out . p r i n t l n ( " Pa t t i n i r e s t i t u i t i . " ) ;else

System . out . p r i n t l n ( "Errore . Pa t t i n i non f i t t a t i . " ) ;}

private stat ic void stampa ( ParcoPatt in i p ) {System . out . p r i n t l n (p . t oS t r i ng ( ) ) ;

}}

SX.10 Timer

Traccia a pag. 44

File Timer.java


import java . time . Duration ;import java . time . LocalDateTime ;

public class Timer {private LocalDateTime startTime ;private LocalDateTime stopTime ;

public void s t a r t ( ) {startTime = LocalDateTime . now ( ) ;// stopTime = nu l l ;

}

public void stop ( ) {stopTime = LocalDateTime . now ( ) ;

}

public void r e s e t ( ) {startTime = null ;stopTime = null ;

}

public int getTime ( ) {i f ( startTime == null ) // i l t imer è in s t a t o d i r e s e t ?

return 0 ;

i f ( stopTime == null ) // i l t imer è in moto?return ( int ) Duration . between ( startTime ,

LocalDateTime . now ( ) ) . getSeconds ( ) ; // s ìelse

return ( int ) Duration . between ( startTime , stopTime ). getSeconds ( ) ; // no

}}

File Main.java



public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;Timer t imer = new Timer ( ) ;

do {stampaMenu ( ) ;System . out . p r i n t ( " Sc e l t a : " ) ;l i n e = scanner . nextLine ( ) ;switch ( l i n e ) {case " s " :

s t a r t ( t imer ) ;break ;

case "x" :stop ( t imer ) ;break ;

case " r " :r e s e t ( t imer ) ;break ;

case "p" :


showTimer ( t imer ) ;break ;

case "e" :break ;


}} while ( ! l i n e . equa l s ( "e" ) ) ;

}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( "Timer sempl i ce . " ) ;System . out . p r i n t l n ( " s : s t a r t . " ) ;System . out . p r i n t l n ( "x : stop . " ) ;System . out . p r i n t l n ( " r : r e s e t . " ) ;System . out . p r i n t l n ( "p : show timer . " ) ;System . out . p r i n t l n ( "e : e x i t . " ) ;

}

private stat ic void s t a r t (Timer t ) {t . s t a r t ( ) ;System . out . p r i n t l n ( "Timer s t a r t ed . " ) ;

}

private stat ic void stop (Timer t ) {t . stop ( ) ;System . out . p r i n t l n ( "Timer stopped . " ) ;

}

private stat ic void r e s e t (Timer t ) {t . r e s e t ( ) ;System . out . p r i n t l n ( "Timer r e s e t . " ) ;

}

private stat ic void showTimer (Timer t ) {int seconds = t . getTime ( ) ;System . out . p r i n t l n ( "Timer shows : " + seconds + " . " ) ;

}}

SX.11 Timer Avanzato

Traccia a pag. 45

Il primo dei requisiti aggiuntivi imposti dalla traccia suggerisce intuitivamen-te che il timer è una sorta di accumulatore che tiene memoria della duratacomplessiva degli intervalli di tempo cronometrati �no ad un certo istante.Infatti l'esecuzione di un nuovo conteggio fornisce un contributo che va asommarsi a tutti gli eventuali contributi precedenti.

Ai �ni dello svolgimento di questo esercizio, il valore corrente del cronome-tro può essere pertanto considerato come la composizione di due contributi:

• la somma di tutti gli intervalli di tempo cronometrati nel passato, cioècompresi tra un segnale di START ed uno di STOP;

• l'eventuale contributo del conteggio corrente, se il timer è attivo.


È dunque possibile pensare al timer come una classe dotata di due membriprivati:

storedTime: contiene la somma di tutti i conteggi passati già terminati;questo membro va aggiornato al termine di ogni conteggio;

startTime: contiene l'istante di inizio dell'eventuale conteggio in corso; vale0 se il timer è inattivo.

In questo modo, all'arrivo del messaggio GETTIME, è su�ciente restituireil valore del membro storedTime, aggiungendo eventualmente la di�erenzatra l'istante attuale e l'istante startTime, se startTime è diverso da zero(cioè se c'è un conteggio in corso).

Dal momento che spesso sorge la necessità di valutare se c'è un conteggioin corso oppure no, in questa implementazione lo svolgimento di tale servizioè stato incapsulato nell'opportuno metodo privato

private boolean isRunning ( ) ;

import java . time . Duration ;import java . time . LocalDateTime ;

public class Timer {private int storedTime ;private LocalDateTime startTime ;

private boolean isRunning ( ) {return startTime != null ;

}

public void s t a r t ( ) {i f ( ! isRunning ( ) )

startTime = LocalDateTime . now ( ) ;}

public void stop ( ) {i f ( isRunning ( ) ) {

// accumula i l tempo de l cont . in corsostoredTime += Duration . between ( startTime ,

LocalDateTime . now ( ) ) . getSeconds ( ) ;startTime = null ; // ferma i l con tegg io

}}

public void r e s e t ( ) {storedTime = 0 ;startTime = null ;

}

public int getTime ( ) {int t = storedTime ;

i f ( isRunning ( ) )t += Duration


. between ( startTime , LocalDateTime . now ( ) )

. getSeconds ( ) ;

return t ;}

}

SX.12 Votazioni

Traccia a pag. 46

File Votazioni.java

public class Votaz ion i {private class Votazione {

private St r ing cod i c e ;private int vo t i ;

public Votazione ( S t r ing cod i c e ) {this . c od i c e = cod i c e ;

}

public int getVot i ( ) {return vo t i ;

}

public int incrementaVoti ( ) {return ++vot i ;

}

public St r ing toS t r i ng ( ) {return cod i c e + " : " + vo t i ;

}}

private class Record {public Votazione votaz ione ;public Record succ ;

}

private Record f i r s t ;int numVoti ;

Record c e r c aPa r t i t o ( S t r ing cod i c e ) {// La s t r u t t u r a è g e s t i b i l e con metodo t a b e l l a r e : i n f a t t i// i l cod ice p a r t i t o rappresenta una ch iave per l a// t a b e l l a de i v o t i . Questo metodo r e s t i t u i s c e i l// puntatore a l l a c e l l a avente cod ice par i a q u e l l o// s p e c i f i c a t o in ing re s so se e s i s t e n t e .// nu l l a l t r imen t i .Record p = f i r s t ;while (p != null ) {

i f (p . votaz ione . cod i c e . equa l s ( cod i c e ) )


return p ;p = p . succ ;

}

return null ;}

public int aggiungiVoto ( S t r ing cod i c e ) {numVoti++; // incremento i l numero d i v o t i comp l e s s i v iRecord p = ce r c aPa r t i t o ( cod i c e ) ;

i f (p != null ) {return p . votaz ione . incrementaVoti ( ) ;

} else {p = new Record ( ) ;p . votaz ione = new Votazione ( cod i c e ) ;int v = p . votaz ione . incrementaVoti ( ) ;p . succ = f i r s t ;f i r s t = p ;return v ;

}}

public void svuota ( ) {f i r s t = null ;numVoti = 0 ;

}

public int ge tVot iPar t i t o ( S t r ing cod i c e ) {Record p = ce r c aPa r t i t o ( cod i c e ) ;

i f (p != null )return p . votaz ione . getVot i ( ) ;

return 0 ;}

public int getNumeroVoti ( ) {return numVoti ;

}

public St r ing toS t r i ng ( ) {S t r i ngBu i l d e r sb = new St r i ngBu i l d e r ( ) ;Record p = f i r s t ;

while (p != null ) {sb . append (p . votaz ione . t oS t r i ng ( )

+ System . l i n eS epa r a t o r ( ) ) ;

p = p . succ ;}


}

File Main.java




public stat ic void main ( St r ing [ ] a rgs ) {St r ing l i n e ;Votaz ion i vo t a z i on i = new Votaz ion i ( ) ;


aggiungiVoto ( vo t a z i on i ) ;break ;

case "2" :svuota ( vo t a z i on i ) ;break ;

case "3" :g e tVot iPar t i t o ( vo t a z i on i ) ;break ;

case "4" :getNumeroVoti ( vo t a z i on i ) ;break ;

case "5" :g e tS i tua z i one ( vo t a z i on i ) ;break ;

case "6" :break ;



}

private stat ic void stampaMenu ( ) {System . out . p r i n t l n ( " 1 : AggiungiVoto . " ) ;System . out . p r i n t l n ( " 2 : Svuota . " ) ;System . out . p r i n t l n ( " 3 : Vot iPar t i to . " ) ;System . out . p r i n t l n ( " 4 : NumeroVoti . " ) ;System . out . p r i n t l n ( " 5 : S i tuaz i one . " ) ;System . out . p r i n t l n ( " 6 : Esc i . " ) ;

}

private stat ic void aggiungiVoto ( Votaz ion i v ) {System . out . p r i n t ( " Ind i c a r e i l cod i c e pa r t i t o : " ) ;S t r ing cod i c e = scanner . nextLine ( ) ;

int vo t i = v . aggiungiVoto ( cod i c e ) ;System . out . p r i n t l n ( "Voto aggiunto . Ora i l p a r t i t o ha "

+ vo t i + " vot " + ( vo t i == 1 ? "o" : " i " ) + " . " ) ;}

private stat ic void svuota ( Votaz ion i v ) {v . svuota ( ) ;System . out . p r i n t l n ( " St rut tura svuotata . " ) ;

}

private stat ic void ge tVot iPa r t i t o ( Votaz ion i v ) {System . out . p r i n t ( " Ind i c a r e i l cod i c e pa r t i t o : " ) ;S t r ing cod i c e = scanner . nextLine ( ) ;


System . out . p r i n t l n ( " I l p a r t i t o " + cod i c e+ " ha ottenuto vo t i : "+ v . ge tVot iPa r t i t o ( cod i c e ) ) ;

}

private stat ic void getNumeroVoti ( Votaz ion i v ) {System . out . p r i n t l n ( " I vo t i comp l e s s i v i sono : " +

v . getNumeroVoti ( ) + " . " ) ;}

private stat ic void ge tS i tua z i one ( Votaz ion i v ) {System . out . p r i n t l n (v . t oS t r i ng ( ) ) ;

}}

Appendice A

GNU Free Documentation License

Version 1.3, 3 November 2008Copyright c⃝ 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.

<http://fsf.org/>

Everyone is permitted to copy and distribute verbatim copies of this license document,but changing it is not allowed.

Preamble

The purpose of this License is to make a manual, textbook, or other functional anduseful document �free� in the sense of freedom: to assure everyone the e�ective freedomto copy and redistribute it, with or without modifying it, either commercially or noncom-mercially. Secondarily, this License preserves for the author and publisher a way to getcredit for their work, while not being considered responsible for modi�cations made byothers.

This License is a kind of �copyleft�, which means that derivative works of the documentmust themselves be free in the same sense. It complements the GNU General PublicLicense, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, becausefree software needs free documentation: a free program should come with manuals provi-ding the same freedoms that the software does. But this License is not limited to softwaremanuals; it can be used for any textual work, regardless of subject matter or whether itis published as a printed book. We recommend this License principally for works whosepurpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that contains anotice placed by the copyright holder saying it can be distributed under the terms of thisLicense. Such a notice grants a world-wide, royalty-free license, unlimited in duration,to use that work under the conditions stated herein. The �Document�, below, refers toany such manual or work. Any member of the public is a licensee, and is addressed as

148

A. GNU Free Documentation License 149

�you�. You accept the license if you copy, modify or distribute the work in a way requiringpermission under copyright law.

A �Modi�ed Version� of the Document means any work containing the Documentor a portion of it, either copied verbatim, or with modi�cations and/or translated intoanother language.

A �Secondary Section� is a named appendix or a front-matter section of the Do-cument that deals exclusively with the relationship of the publishers or authors of theDocument to the Document's overall subject (or to related matters) and contains nothingthat could fall directly within that overall subject. (Thus, if the Document is in part atextbook of mathematics, a Secondary Section may not explain any mathematics.) Therelationship could be a matter of historical connection with the subject or with relatedmatters, or of legal, commercial, philosophical, ethical or political position regarding them.

The �Invariant Sections� are certain Secondary Sections whose titles are designated,as being those of Invariant Sections, in the notice that says that the Document is releasedunder this License. If a section does not �t the above de�nition of Secondary then it is notallowed to be designated as Invariant. The Document may contain zero Invariant Sections.If the Document does not identify any Invariant Sections then there are none.

The �Cover Texts� are certain short passages of text that are listed, as Front-CoverTexts or Back-Cover Texts, in the notice that says that the Document is released underthis License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text maybe at most 25 words.

A �Transparent� copy of the Document means a machine-readable copy, representedin a format whose speci�cation is available to the general public, that is suitable for re-vising the document straightforwardly with generic text editors or (for images composedof pixels) generic paint programs or (for drawings) some widely available drawing editor,and that is suitable for input to text formatters or for automatic translation to a varietyof formats suitable for input to text formatters. A copy made in an otherwise Transpa-rent �le format whose markup, or absence of markup, has been arranged to thwart ordiscourage subsequent modi�cation by readers is not Transparent. An image format is notTransparent if used for any substantial amount of text. A copy that is not �Transparent�is called �Opaque�.

Examples of suitable formats for Transparent copies include plain ASCII without mar-kup, Texinfo input format, LaTeX input format, SGML or XML using a publicly availableDTD, and standard-conforming simple HTML, PostScript or PDF designed for humanmodi�cation. Examples of transparent image formats include PNG, XCF and JPG. Opa-que formats include proprietary formats that can be read and edited only by proprietaryword processors, SGML or XML for which the DTD and/or processing tools are not gene-rally available, and the machine-generated HTML, PostScript or PDF produced by someword processors for output purposes only.

The �Title Page� means, for a printed book, the title page itself, plus such followingpages as are needed to hold, legibly, the material this License requires to appear in thetitle page. For works in formats which do not have any title page as such, �Title Page�means the text near the most prominent appearance of the work's title, preceding thebeginning of the body of the text.

The �publisher� means any person or entity that distributes copies of the Documentto the public.

A section �Entitled XYZ� means a named subunit of the Document whose titleeither is precisely XYZ or contains XYZ in parentheses following text that translates XYZin another language. (Here XYZ stands for a speci�c section name mentioned below,


such as �Acknowledgements�, �Dedications�, �Endorsements�, or �History�.) To�Preserve the Title� of such a section when you modify the Document means that itremains a section �Entitled XYZ� according to this de�nition.

The Document may include Warranty Disclaimers next to the notice which states thatthis License applies to the Document. These Warranty Disclaimers are considered to beincluded by reference in this License, but only as regards disclaiming warranties: any otherimplication that these Warranty Disclaimers may have is void and has no e�ect on themeaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially ornoncommercially, provided that this License, the copyright notices, and the license noticesaying this License applies to the Document are reproduced in all copies, and that youadd no other conditions whatsoever to those of this License. You may not use technicalmeasures to obstruct or control the reading or further copying of the copies you make ordistribute. However, you may accept compensation in exchange for copies. If you distributea large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you maypublicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have printed covers)of the Document, numbering more than 100, and the Document's license notice requiresCover Texts, you must enclose the copies in covers that carry, clearly and legibly, allthese Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on theback cover. Both covers must also clearly and legibly identify you as the publisher ofthese copies. The front cover must present the full title with all words of the title equallyprominent and visible. You may add other material on the covers in addition. Copyingwith changes limited to the covers, as long as they preserve the title of the Document andsatisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to �t legibly, you should putthe �rst ones listed (as many as �t reasonably) on the actual cover, and continue the restonto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100,you must either include a machine-readable Transparent copy along with each Opaquecopy, or state in or with each Opaque copy a computer-network location from whichthe general network-using public has access to download using public-standard networkprotocols a complete Transparent copy of the Document, free of added material. If you usethe latter option, you must take reasonably prudent steps, when you begin distribution ofOpaque copies in quantity, to ensure that this Transparent copy will remain thus accessibleat the stated location until at least one year after the last time you distribute an Opaquecopy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document wellbefore redistributing any large number of copies, to give them a chance to provide youwith an updated version of the Document.


4. MODIFICATIONSYou may copy and distribute a Modi�ed Version of the Document under the conditions

of sections 2 and 3 above, provided that you release the Modi�ed Version under preciselythis License, with the Modi�ed Version �lling the role of the Document, thus licensingdistribution and modi�cation of the Modi�ed Version to whoever possesses a copy of it.In addition, you must do these things in the Modi�ed Version:

A. Use in the Title Page (and on the covers, if any) a title distinct from that of theDocument, and from those of previous versions (which should, if there were any,be listed in the History section of the Document). You may use the same title as aprevious version if the original publisher of that version gives permission.

B. List on the Title Page, as authors, one or more persons or entities responsible forauthorship of the modi�cations in the Modi�ed Version, together with at least �veof the principal authors of the Document (all of its principal authors, if it has fewerthan �ve), unless they release you from this requirement.

C. State on the Title page the name of the publisher of the Modi�ed Version, as thepublisher.

D. Preserve all the copyright notices of the Document.

E. Add an appropriate copyright notice for your modi�cations adjacent to the othercopyright notices.

F. Include, immediately after the copyright notices, a license notice giving the publicpermission to use the Modi�ed Version under the terms of this License, in the formshown in the Addendum below.

G. Preserve in that license notice the full lists of Invariant Sections and required CoverTexts given in the Document's license notice.

H. Include an unaltered copy of this License.

I. Preserve the section Entitled �History�, Preserve its Title, and add to it an itemstating at least the title, year, new authors, and publisher of the Modi�ed Version asgiven on the Title Page. If there is no section Entitled �History� in the Document,create one stating the title, year, authors, and publisher of the Document as givenon its Title Page, then add an item describing the Modi�ed Version as stated inthe previous sentence.

J. Preserve the network location, if any, given in the Document for public access toa Transparent copy of the Document, and likewise the network locations given inthe Document for previous versions it was based on. These may be placed in the�History� section. You may omit a network location for a work that was publishedat least four years before the Document itself, or if the original publisher of theversion it refers to gives permission.

K. For any section Entitled �Acknowledgements� or �Dedications�, Preserve the Titleof the section, and preserve in the section all the substance and tone of each of thecontributor acknowledgements and/or dedications given therein.

L. Preserve all the Invariant Sections of the Document, unaltered in their text and intheir titles. Section numbers or the equivalent are not considered part of the sectiontitles.


M. Delete any section Entitled �Endorsements�. Such a section may not be included inthe Modi�ed Version.

N. Do not retitle any existing section to be Entitled �Endorsements� or to con�ict intitle with any Invariant Section.

O. Preserve any Warranty Disclaimers.

If the Modi�ed Version includes new front-matter sections or appendices that qualifyas Secondary Sections and contain no material copied from the Document, you may atyour option designate some or all of these sections as invariant. To do this, add their titlesto the list of Invariant Sections in the Modi�ed Version's license notice. These titles mustbe distinct from any other section titles.

You may add a section Entitled �Endorsements�, provided it contains nothing butendorsements of your Modi�ed Version by various parties�for example, statements ofpeer review or that the text has been approved by an organization as the authoritativede�nition of a standard.

You may add a passage of up to �ve words as a Front-Cover Text, and a passage ofup to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modi�edVersion. Only one passage of Front-Cover Text and one of Back-Cover Text may be addedby (or through arrangements made by) any one entity. If the Document already includesa cover text for the same cover, previously added by you or by arrangement made by thesame entity you are acting on behalf of, you may not add another; but you may replacethe old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permissionto use their names for publicity for or to assert or imply endorsement of any Modi�edVersion.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License,under the terms de�ned in section 4 above for modi�ed versions, provided that you includein the combination all of the Invariant Sections of all of the original documents, unmodi�ed,and list them all as Invariant Sections of your combined work in its license notice, andthat you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identicalInvariant Sections may be replaced with a single copy. If there are multiple InvariantSections with the same name but di�erent contents, make the title of each such sectionunique by adding at the end of it, in parentheses, the name of the original author orpublisher of that section if known, or else a unique number. Make the same adjustmentto the section titles in the list of Invariant Sections in the license notice of the combinedwork.

In the combination, you must combine any sections Entitled �History� in the variousoriginal documents, forming one section Entitled �History�; likewise combine any sectionsEntitled �Acknowledgements�, and any sections Entitled �Dedications�. You must deleteall sections Entitled �Endorsements�.

6. COLLECTIONS OF DOCUMENTS


You may make a collection consisting of the Document and other documents releasedunder this License, and replace the individual copies of this License in the various docu-ments with a single copy that is included in the collection, provided that you follow therules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it indivi-dually under this License, provided you insert a copy of this License into the extracteddocument, and follow this License in all other respects regarding verbatim copying of thatdocument.

7. AGGREGATION WITH INDEPENDENTWORKS

A compilation of the Document or its derivatives with other separate and independentdocuments or works, in or on a volume of a storage or distribution medium, is called an�aggregate� if the copyright resulting from the compilation is not used to limit the legalrights of the compilation's users beyond what the individual works permit. When theDocument is included in an aggregate, this License does not apply to the other works inthe aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document,then if the Document is less than one half of the entire aggregate, the Document's CoverTexts may be placed on covers that bracket the Document within the aggregate, or theelectronic equivalent of covers if the Document is in electronic form. Otherwise they mustappear on printed covers that bracket the whole aggregate.

8. TRANSLATIONTranslation is considered a kind of modi�cation, so you may distribute translations of

the Document under the terms of section 4. Replacing Invariant Sections with translationsrequires special permission from their copyright holders, but you may include translationsof some or all Invariant Sections in addition to the original versions of these InvariantSections. You may include a translation of this License, and all the license notices inthe Document, and any Warranty Disclaimers, provided that you also include the originalEnglish version of this License and the original versions of those notices and disclaimers.In case of a disagreement between the translation and the original version of this Licenseor a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled �Acknowledgements�, �Dedications�, or �Hi-story�, the requirement (section 4) to Preserve its Title (section 1) will typically requirechanging the actual title.

9. TERMINATIONYou may not copy, modify, sublicense, or distribute the Document except as expres-

sly provided under this License. Any attempt otherwise to copy, modify, sublicense, ordistribute it is void, and will automatically terminate your rights under this License.

However, if you cease all violation of this License, then your license from a particularcopyright holder is reinstated (a) provisionally, unless and until the copyright holder ex-plicitly and �nally terminates your license, and (b) permanently, if the copyright holder


fails to notify you of the violation by some reasonable means prior to 60 days after thecessation.

Moreover, your license from a particular copyright holder is reinstated permanentlyif the copyright holder noti�es you of the violation by some reasonable means, this is the�rst time you have received notice of violation of this License (for any work) from thatcopyright holder, and you cure the violation prior to 30 days after your receipt of thenotice.

Termination of your rights under this section does not terminate the licenses of partieswho have received copies or rights from you under this License. If your rights have beenterminated and not permanently reinstated, receipt of a copy of some or all of the samematerial does not give you any rights to use it.

10. FUTURE REVISIONS OF THIS LICENSEThe Free Software Foundation may publish new, revised versions of the GNU Free

Documentation License from time to time. Such new versions will be similar in spirit tothe present version, but may di�er in detail to address new problems or concerns. Seehttp://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Documentspeci�es that a particular numbered version of this License �or any later version� appliesto it, you have the option of following the terms and conditions either of that speci�edversion or of any later version that has been published (not as a draft) by the Free SoftwareFoundation. If the Document does not specify a version number of this License, you maychoose any version ever published (not as a draft) by the Free Software Foundation. Ifthe Document speci�es that a proxy can decide which future versions of this License canbe used, that proxy's public statement of acceptance of a version permanently authorizesyou to choose that version for the Document.

11. RELICENSING�Massive Multiauthor Collaboration Site� (or �MMC Site�) means any World Wide

Web server that publishes copyrightable works and also provides prominent facilities foranybody to edit those works. A public wiki that anybody can edit is an example of sucha server. A �Massive Multiauthor Collaboration� (or �MMC�) contained in the site meansany set of copyrightable works thus published on the MMC site.

�CC-BY-SA� means the Creative Commons Attribution-Share Alike 3.0 license pu-blished by Creative Commons Corporation, a not-for-pro�t corporation with a principalplace of business in San Francisco, California, as well as future copyleft versions of thatlicense published by that same organization.

�Incorporate� means to publish or republish a Document, in whole or in part, as partof another Document.

An MMC is �eligible for relicensing� if it is licensed under this License, and if allworks that were �rst published under this License somewhere other than this MMC, andsubsequently incorporated in whole or in part into the MMC, (1) had no cover texts orinvariant sections, and (2) were thus incorporated prior to November 1, 2008.

The operator of an MMC Site may republish an MMC contained in the site underCC-BY-SA on the same site at any time before August 1, 2009, provided the MMC iseligible for relicensing.


ADDENDUM: How to use this License for yourdocuments

To use this License in a document you have written, include a copy of the License inthe document and put the following copyright and license notices just after the title page:

Copyright c⃝ YEAR YOUR NAME. Permission is granted to copy, distributeand/or modify this document under the terms of the GNU Free Documenta-tion License, Version 1.3 or any later version published by the Free SoftwareFoundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled �GNUFree Documentation License�.

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the�with . . . Texts.� line with this:

with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other combination of thethree, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend relea-sing these examples in parallel under your choice of free software license, such as the GNUGeneral Public License, to permit their use in free software.

Bibliogra�a

[1] Marcello Esposito. 50 Esercizi di C++ con soluzioni. http://esercizicpp.

sourceforge.net.

[2] Bruce Eckel. Thinking in Java. Prentice-Hall, Upper Saddle River, NJ, 4th edition,2006. http://www.mindviewinc.com/Books/TIJ4/.

[3] E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns: Elements of

Reusable Object-Oriented Software. Addison-Wesley, 1995.

156

51 Esercizi di Java - TIM e Telecom in un unico portale | TIM · delle strutture dati può basarsi...

Documents

Transcript of 51 Esercizi di Java - TIM e Telecom in un unico portale | TIM · delle strutture dati può basarsi...