Json on

DesignPatternTeoria - Structural - adapter

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: ADAPTER

L’Adapter (o Adattatore / Wrapper) è un pattern strutturale che consente a due classi con interfacce incompatibili di collaborare.

L’adattatore funge da “traduttore” tra l’interfaccia attesa dal codice client (Target) e quella realmente offerta da un oggetto esistente (Adaptee), senza modificare né il client né la classe originale.

QUANDO UTILIZZARLO

Integrazione di librerie o componenti di terze parti.
Uniformare formati di input/output differenti (es. XML ⇆ JSON, sistemi di coordinate diversi).
Migrare verso una nuova API senza interrompere il funzionamento del codice esistente.

VANTAGGI

Basso accoppiamento: il client dipende solo dall’interfaccia Target.
Nessuna modifica a codice esistente: adattamento non invasivo.
Flessibilità nella sostituzione: puoi introdurre più adattatori per transizioni graduali.
Riutilizzo di codice: componenti vecchi possono integrarsi con sistemi nuovi.

POTENZIALI SVANTAGGI

Aumento della complessità: più formati = più adapter da gestire.
Prestazioni: un layer aggiuntivo può introdurre overhead.
Soluzione temporanea: spesso è un “cerotto” invece di una riprogettazione strutturale.

CODICE

/**
 * Sorgenti dati JSON ok
 */
class JSONData {
	content: Object;

	constructor(content: Object) {
		this.content = content;
	}
}

/**
 * Sorgenti dati XML ok => da adattare con il nostro design pattern
 */
class XMLData {
	content: string;

	constructor(content: string) {
		this.content = content;
	}
}

/**
 * ADAPTER
 * Interfaccia comune per l'adattamento a un MCM
 */
interface CommonData {
	convertToCommonData(): JSONData;
}

/**
 * CONVERTITORE JSON
 */
class convertJSONData implements CommonData {
	jsonData: JSONData;

	constructor(jsonData: JSONData) {
		this.jsonData = jsonData;
	}

	convertToCommonData(): JSONData {
		return this.jsonData;
	}
}

/**
 * CONVERTITORE XML
 */
class convertXMLData implements CommonData {
	xmlData: XMLData;

	constructor(xmlData: XMLData) {
		this.xmlData = xmlData;
	}

	convertToCommonData(): JSONData {
		//Parsing manuale semplificato (solo per esempio)
		const matches = this.xmlData.content.match(/<campo1 xml>(.*?)<\/campo1 xml>[\s\S]*<campo2 xml>(.*?)<\/campo2 xml>/);

		if (!matches) {
			throw new Error("Formato XML non valido");
		}

		const jsonObj: Object = {
			"campo 1 xml": matches[1],
			"campo 2 xml": matches[2]
		};

		return new JSONData(jsonObj);
	}
}

//USO ADAPTER
const jsonData: JSONData = new JSONData({
	"campo 1 json": "valore 1 json",
	"campo 2 json": "valore 2 json",
});

const xmlData: XMLData = new XMLData(`
 <root>
 <campo1 xml>valore 1 xml</campo1 xml>
 <campo2 xml>valore 2 xml</campo2 xml>
 </root>
`);

const commonDataFromJSON: JSONData = new convertJSONData(jsonData).convertToCommonData();
const commonDataFromXML: JSONData = new convertXMLData(xmlData).convertToCommonData();
console.log("JSON convertito a JSON: ", commonDataFromJSON);
console.log("XML convertito a JSON: ", commonDataFromXML);

DesignPatternTeoria - Structural - decorator

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: DECORATOR

Il Decorator è un pattern strutturale che consente di aggiungere, in modo dinamico, nuove funzionalità a un oggetto senza modificarne la classe originale.

Il principio di base è “impacchettare” (wrapping) l’oggetto originale all’interno di un altro oggetto che implementa la stessa interfaccia, delegando le chiamate e arricchendole prima o dopo l’esecuzione.

QUANDO UTILIZZARLO

Vuoi estendere il comportamento di un oggetto a runtime senza usare l’ereditarietà.
Vuoi evitare la proliferazione di sottoclassi per ogni combinazione di funzionalità (es. ButtonBlueLargeWithIcon, ButtonRedSmallNoIcon, ecc.).
Necessiti di combinare funzionalità in modo flessibile e modulare.

VANTAGGI

Modularità: aggiungi funzionalità senza toccare la classe originale.
Flessibilità: puoi impilare più decoratori in qualunque ordine.
Open/Closed Principle: estendi il comportamento senza modificare codice esistente.

POTENZIALI SVANTAGGI

Maggiore complessità: troppi oggetti annidati possono rendere il flusso poco chiaro.
Configurazione verbosa: la creazione e combinazione dei decoratori può diventare prolissa.

CODICE

/**
 * Interfaccia comune per DataSource
 */
interface DataSource {
	writeData(data: string): void;
	readData(): string;
}

/**
 * Classe concreta: sorgente dati base
 */
class FileDataSource implements DataSource {
	private storage: string = "";

	writeData(data: string): void {
		console.log("Scrittura dati nel file:", data);
		this.storage = data;
	}

	readData(): string {
		console.log("Lettura dati dal file");
		return this.storage;
	}
}

/**
 * DECORATOR
 * Decoratore concreto che implementa DataSource e ha un riferimento a un DataSource
 * Inoltre aggiunge compressione ai dati
 * Serve per dare piu struttura al codice ma si può evitare e fare direttamente il Decoratore concreto
 */
class DataSourceDecorator implements DataSource{
	//Oggetto di base wrappato
	protected wrapper: DataSource;

	constructor(source: DataSource) {
		this.wrapper = source;
	}

	//riutilizzo le funzioni del wrapper e aggiungo altra logica
	writeData(data: string): void {
		data = this.compress(data);
		this.wrapper.writeData(data);
	}

	readData(): string {
		let data = this.wrapper.readData();
		return this.decompress(data);
	}

	//aggiungo ulteriori funzioni
	private compress(data: string): string {
		//Implementazione di compressione fittizia (esempio semplice)
		return data.split("").reverse().join("");
	}

	private decompress(data: string): string {
		//Decompressione fittizia(in questo caso inversa della compressione)
		return data.split("").reverse().join("");
	}
}

//Da questo momento in poi potrei procedere in 2 modi:
//VERTICALE: Aggiungo un nuovo decoratore(virtuale e concreto) 'wrappando' un oggetto di tipo CompressionDecorator
//ORIZZONTALE: Aggiungo un nuovo decoratore(virtuale e concreto) 'wrappando' un oggetto di tipo DataSource => Consigliato

//USO DECORATOR
const fileSource: FileDataSource = new FileDataSource();
const compressedSource: DataSourceDecorator = new DataSourceDecorator(fileSource);

compressedSource.writeData("Questo è un testo da salvare");
const result: string = compressedSource.readData();

console.log("Dati letti decompressi:", result);

DesignPatternTeoria - Structural - facade

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: FACADE

Il Facade è un pattern strutturale che fornisce un’interfaccia unificata e semplificata a un insieme di sottosistemi complessi.

La “facciata” nasconde i dettagli interni e offre al client un solo punto di accesso, riducendo l’accoppiamento tra componenti e migliorando la leggibilità.

QUANDO USARLO

Quando il sistema ha API verbose, complesse o frammentate.
Quando vuoi esporre solo facciate e non classi interne ai livelli superiori.

VANTAGGI

Semplifica l’uso del sistema, nascondendo la complessità.
Riduce l’accoppiamento tra client e sottosistemi.
Fornisce un punto unico di controllo (utile per logging, sicurezza, transazioni).
Facilita modifiche e manutenzione, isolando le dipendenze.

POTENZIALI SVANTAGGI

Se il client necessita di funzionalità molto specifiche, potrebbe comunque dover accedere ai sottosistemi.
Un eccessivo numero di facciate può portare a duplicazione di logica già presente nei moduli interni.

CODICE

/**
 * Interfaccia comune
 */
interface Crypto {
	currency: string;
	doPayment(amount: number): void;
	getCurrency(): string;
}

/**
 * Implementazioni concrete
 */
class BTC implements Crypto {
	currency: string = "BTC";

	doPayment(amount: number): void {
		console.log("[BTC] Avvio pagamento di " + amount + " BTC");
		console.log("[BTC] Operazione riuscita");
		console.log("[BTC] Invio mail di conferma");
	}

	getCurrency(): string {
		return this.currency;
	}
}

class Dogecoin implements Crypto {
	currency: string = "Dogecoin";

	doPayment(amount: number): void {
		console.log("[Dogecoin] Avvio pagamento di " + amount + " Dogecoin");
		console.log("[Dogecoin] Operazione riuscita");
		console.log("[Dogecoin] Invio mail di conferma");
	}

	getCurrency(): string {
		return this.currency;
	}
}

/**
 * FACADE
 * Espone un'interfaccia semplificata per il client
 */
class CryptoFacade {
	private wallet: Map<string, Crypto> = new Map();

	constructor() {
		// Registrazione delle crypto disponibili
		const btc = new BTC();
		const dogecoin = new Dogecoin();
		this.wallet.set(btc.getCurrency(), btc);
		this.wallet.set(dogecoin.getCurrency(), dogecoin);
	}

	// Metodo comune per pagare
	public pay(amount: number, currency: string): void {
		const crypto = this.wallet.get(currency);
		if (!crypto) {
			console.log("Valuta non supportata: " + currency);
			return;
		}
		console.log("=== Avvio pagamento tramite Facade ===");
		crypto.doPayment(amount);
		console.log("=== Fine pagamento ===");
	}
}

/**
 * USO DEL FACADE
 * Il client vede solo la Facade, non le classi concrete
 */
const paymentSystem = new CryptoFacade();
paymentSystem.pay(500, "BTC");
paymentSystem.pay(2000, "Dogecoin");
paymentSystem.pay(100, "Ethereum"); // non supportata

DesignPatternTeoria - Creational - builder

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: BUILDER

Il Builder è un pattern creazionale che consente di costruire oggetti complessi passo dopo passo.

A differenza del Factory, che si concentra solo sulla creazione, il Builder gestisce anche la composizione graduale dell’oggetto, rendendo il processo più leggibile e flessibile.

QUANDO UTILIZZARLO

La costruzione dell’oggetto richiede molti passaggi o parametri opzionali.
Vuoi evitare il “telescoping constructor” (costruttori con troppi parametri).
Vuoi che l’oggetto finale sia immutabile, ma la sua creazione rimanga flessibile.
Necessiti di creare varianti partendo da una configurazione di base.

VANTAGGI

Chiarezza: sequenze come .setX().setY().build() rendono il codice leggibile e modulare.
Flessibilità: permette di configurare solo ciò che serve.
Immutabilità: l’oggetto finale può essere reso non modificabile.
Pulizia del costruttore: evita l’uso di costruttori con troppi parametri.
Riutilizzo: puoi partire da un builder già configurato per creare varianti.

POTENZIALI SVANTAGGI

Maggiore complessità: richiede classi aggiuntive anche per casi semplici.
Overkill: non necessario per oggetti con poche proprietà.
Validazione assente: di default non impone controlli sui dati forniti.

CHICCA OPZIONALE: DIRETTIVE

Nel caso in cui notiamo nel codice dei casi in cui abbiamo diversi build che hanno lo stesso set di parametri allora conviene utilizzare oltre ai builder anche le DIRETTIVE, ovvero dei builder pre-compilati

DesignPatternTeoria - Creational - factory method

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: FACTORY METHOD

Il Factory Method è un pattern creazionale che definisce un’interfaccia per la creazione di oggetti, delegando alle sottoclassi la decisione su quale classe concreta istanziare.

Questo approccio separa la logica di creazione dal codice che utilizza gli oggetti, migliorando flessibilità e manutenibilità.

QUANDO UTILIZZARLO

Quando non conosci a priori la classe concreta da istanziare.
Quando vuoi centralizzare la logica di creazione degli oggetti.
Quando desideri ridurre le dipendenze dirette da classi specifiche.

VANTAGGI

Separazione delle responsabilità: isola la logica di istanziazione dal codice client.
Estendibilità: per supportare nuovi tipi di oggetti basta estendere la factory.
Open/Closed Principle: il codice client dipende da interfacce, non da implementazioni concrete.
Codice più pulito e modulare: la creazione è incapsulata.

POTENZIALI SVANTAGGI

Potrebbe richiedere molte sottoclassi o rami condizionali per gestire vari tipi di oggetti.
Non è ottimale per oggetti con numerose varianti di configurazione.
L’aggiunta di nuovi tipi può richiedere modifiche alla factory esistente.

CODICE

/**
 * Interfaccia di base(necessaria)
 */
interface Notifica {
 invia(messaggio: string): void;
}

/**
 * Classi specializzate che implementano l'interfaccia di partenza
 */
class NotificaEmail implements Notifica {
 //Override del metodo
 invia(messaggio: string): void {
 console.log(`Invio email con messaggio: ${messaggio}`);
 }
}

/**
 * Classi specializzate che implementano l'interfaccia di partenza
 */
class NotificaSMS implements Notifica {
 //Override del metodo
 invia(messaggio: string): void {
 console.log(`Invio SMS con messaggio: ${messaggio}`);
 }
}

/**FACTORY
* Andremo a eseguire le new passando per il metodo statico della factory
* Deleghiamo come avviene la creazione/costruzione dell'oggetto alla factory
* Per funzionare le classi devono avere un padre comune(interfaccia o classe)
*/
class NotificaFactory {
 static creaNotifica(tipo: string) {
 switch (tipo) {
 case "email":
 return new NotificaEmail();
 case "sms":
 return new NotificaSMS();
 default:
 throw new Error("Tipo di notifica non supportato");
 }
 }
}

//USO FACORY
//Nelle righe a seguire io non so come viene creata una notifica -> delego questa logica alla 'NotificaFactory'
let notifica = NotificaFactory.creaNotifica("sms");
notifica.invia("Ciao utente!");
notifica = NotificaFactory.creaNotifica("email");
notifica.invia("Come stai?");

DesignPatternTeoria - Creational - singleton

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: SINGLETON

Il pattern Singleton è una soluzione architetturale che garantisce la creazione di una sola istanza di una determinata classe per l’intera durata dell’applicazione.

Viene utilizzato quando è necessario un unico punto di accesso globale a una risorsa condivisa, ad esempio:

configurazioni dell’applicazione
connessioni a database
sistemi di logging

QUANDO UTILIZZARLO

Serve una sola istanza condivisa
Lo stato deve essere centralizzato
L’oggetto è costoso da creare
È richiesta una visione globale dello stato

VANTAGGI

Consistenza globale: tutti gli utilizzatori condividono lo stesso stato.
Controllo centralizzato: gestione unificata della risorsa.
Risparmio di memoria: un’unica istanza evita duplicazioni inutili.

POTENZIALI SVANTAGGI

Testing più complesso: può introdurre dipendenze nascoste, ostacolando i test unitari.
Accesso globale rischioso: se abusato, può portare a un design meno modulare e più difficile da manutenere.

CODICE

/**
 * SINGLETON
 */
class Logger {
	//Istanza statica per conservare le informazioni
	private static instance?: Logger;
	private message?: string;

	//Costruttore privato
	private constructor(message: string) {
		this.message = message;
	}

	//Punto in cui avviene la magia
	static getInstance(message: string): Logger {
		//Attenzione nei linguaggi multi thread in questo punto 
		if (this.instance) {
			return this.instance;
		}

		this.instance = new Logger(message);
		return this.instance
	}

	public getMessage() {
		return this.message;
	}
}

//USO SINGLETON
const logger1 = Logger.getInstance("ciao mondo");
const logger2 = Logger.getInstance("seconda instanza, non mi vedi");

console.log(logger1 === logger2); // true -> stessa istanza!
console.log(logger1.getMessage());
console.log(logger2.getMessage());

DesignPatternTeoria - Behavioral - command

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: COMMAND

Il Command è un pattern comportamentale che incapsula una richiesta all’interno di un oggetto, consentendo di parametrizzare i client con richieste differenti, mettere in coda o salvare operazioni, e supportare funzionalità come undo/redo.

Il pattern separa chi invoca un’operazione (Invoker) da chi la esegue (Receiver), permettendo maggiore flessibilità nella gestione delle azioni.

QUANDO USARLO

Vuoi separare il codice che invoca un’operazione dal codice che la esegue.
Vuoi implementare operazioni annullabili (undo/redo).
Vuoi registrare, ritardare o eseguire operazioni in batch.
Vuoi implementare macro che combinano più comandi in sequenza.

VANTAGGI

Separazione delle responsabilità: chi invoca non conosce i dettagli dell’esecuzione.
Flessibilità: code di comandi, esecuzione ritardata, batch, macro.
Undo/Redo: possibile mantenendo lo stato o registrando operazioni inverse.
Estendibilità: nuovi comandi possono essere aggiunti senza modificare il codice esistente.

POTENZIALI SVANTAGGI

Maggiore complessità: richiede una classe separata per ogni comando.
Overkill per sistemi semplici: il vantaggio si percepisce in scenari più complessi.

CODICE

/**
 * Classe ricevente(del comando)
 */
class Light {
	private state: boolean = false;

	getState(): boolean {
		return this.state;
	}

	setState(newState: boolean): void {
		this.state = newState;
	}

	toString(): string {
		return this.state ? "accesa" : "spenta";
	}
}

/**
 * COMMAND
 */
interface CommandLight {
	//comando astratto
	executeSwitchOnOffLight(): void;
}

/**
 * Classe mandante(del comando)
 * Deve implementare correttamente l'interfaccia command
 */
class Room implements CommandLight {
	roomLight: Light;

	constructor(light: Light) {
		this.roomLight = light;
	}

	/**
	 * Comando contreto
	 */
	executeSwitchOnOffLight(): void {
		const oldState = this.roomLight.getState();
		this.roomLight.setState(!oldState);
		console.log("La lampadina è", this.roomLight.toString());
	}
}

//USO COMMAND
let light: Light = new Light();
let room: Room = new Room(light);
room.executeSwitchOnOffLight();
room.executeSwitchOnOffLight();

DesignPatternTeoria - Behavioral - observer

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: OBSERVER

L’Observer è un pattern comportamentale che permette a un oggetto (Subject) di notificare automaticamente un insieme di oggetti (Observers) ogni volta che il suo stato cambia.
È alla base di molti sistemi basati su eventi e della programmazione reattiva.

QUANDO USARLO

Più oggetti devono reagire ai cambiamenti di stato di un altro oggetto.
Vuoi implementare sistemi di eventi o flussi di dati asincroni.
Vuoi disaccoppiare il publisher dai subscriber, evitando dipendenze dirette.

VANTAGGI

Broadcasting semplice verso più listener contemporaneamente.
Disaccoppiamento tra chi emette eventi e chi li gestisce.
Perfetto per UI reattive, flussi di dati in tempo reale e sistemi asincroni.
Supportato nativamente in librerie come RxJS.

POTENZIALI SVANTAGGI

Possibili memory leak se gli observer non vengono disiscritti.
La complessità aumenta con il numero di observer e interazioni.
Debug più complesso in sistemi con molti eventi concatenati.

STRUTTURA

SUBJECT -> OBSERVER 1, OBSERVER 2, …, OBSERVER N(stesso tipo) -> NOTIFICATION

DesignPatternTeoria - Behavioral - state

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: STATE

Lo State è un pattern comportamentale che permette a un oggetto di modificare il proprio comportamento quando cambia il suo stato interno.
È come se l’oggetto cambiasse “classe” in modo dinamico.

QUANDO USARLO

Un oggetto deve cambiare comportamento in base al suo stato.
Vuoi evitare grandi istruzioni if o switch che controllano lo stato.
Vuoi centralizzare i comportamenti di uno stato in una classe dedicata.

VANTAGGI

Elimina if-else o switch-case complessi.
Ogni stato è isolato in una classe separata (Single Responsibility Principle).
Facile aggiungere nuovi stati senza modificare quelli esistenti.
Migliora leggibilità e manutenzione del codice.

POTENZIALI SVANTAGGI

Aumenta il numero di classi nel sistema.
Può risultare eccessivo per macchine a stati semplici.

CODICE

/**
 * Classe con internamente il riferimento a uno degli stati esterni
 */
class Semaforo {
 //Determino solo che esiste uno stato, non mi interessa la logica di aggiornamento
 private stato: StatoSemaforo = new Rosso();

 aggiornataStato(): void {
 this.stato = this.stato.cambia();
 }

 getStato(): void {
 this.stato.mostra();
 }
}

/**
 * STATE
 * State interfaccia comune
 */
interface StatoSemaforo {
 cambia(): StatoSemaforo;
 mostra(): void;
}

/**
 * Stati concreto => Rosso 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Rosso implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da ROSSO a VERDE');
 return new Verde();
 }

 mostra(): void {
 console.log('Rosso: STOP');
 }
}

/**
 * Stati concreto => Verde 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Verde implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da VERDE a GIALLO');
 return new Giallo();
 }

 mostra(): void {
 console.log('Verde: VAI');
 }
}

/**
 * Stati concreto => Giallo 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Giallo implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da GIALLO a ROSSO');
 return new Rosso();
 }

 mostra(): void {
 console.log('Giallo: ATTENZIONE');
 }
}

// USO STATE
const semaforo = new Semaforo();

semaforo.getStato();
semaforo.aggiornataStato();

semaforo.getStato();
semaforo.aggiornataStato();

semaforo.getStato();
semaforo.aggiornataStato();

DesignPatternTeoria - Behavioral - strategy

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: STRATEGY

Lo Strategy è un pattern comportamentale che permette di definire una famiglia di algoritmi, incapsularli e renderli intercambiabili a runtime senza modificare il contesto che li utilizza.
In pratica, consente di cambiare il “comportamento” di un oggetto in modo flessibile.

QUANDO USARLO

Più algoritmi alternativi devono essere scelti dinamicamente.
Vuoi evitare lunghi if-else o switch-case pieni di logica condizionale.
Vuoi rispettare l’Open/Closed Principle: estendere il comportamento senza modificare il codice esistente.

VANTAGGI

Possibilità di aggiungere nuovi algoritmi senza modificare il codice principale.
Migliora leggibilità eliminando if/switch complessi.
Promuove la composizione invece dell’ereditarietà.
Algoritmi intercambiabili a runtime.

POTENZIALI SVANTAGGI

Aumenta il numero di classi/funzioni (una per strategia).
Il contesto deve conoscere l’interfaccia comune.
Più complesso rispetto a una semplice funzione inline per problemi banali.

CODICE

/**
 * Strategy astratta comune
 */
interface Strategy {
 esegui(a: number, b: number): number;
}

/**
 * Strategy concrete
 */
class StrategiaAddizione implements Strategy {
 esegui(a: number, b: number): number {
 return a + b;
 }
}

/**
 * Strategy concrete
 */
class StrategiaSottrazione implements Strategy {
 esegui(a: number, b: number): number {
 return a - b;
 }
}

/**
 * Strategy concrete
 */
class StrategiaMoltiplicazione implements Strategy {
 esegui(a: number, b: number): number {
 return a * b;
 }
}

/**
 * STRATEGY
 * Classe che utilizza una strategia interna
 */
class Calcolatrice {
 private StrategiaCalcolo: Strategy;

 constructor(strategia: Strategy) {
 this.StrategiaCalcolo = strategia;
 }

 setStrategia(strategia: Strategy): void {
 this.StrategiaCalcolo = strategia;
 }

 eseguiStrategia(a: number, b: number): number {
 return this.StrategiaCalcolo.esegui(a, b);
 }
}

// USO STRATEGY
const calcolatrice = new Calcolatrice(new StrategiaAddizione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

calcolatrice.setStrategia(new StrategiaSottrazione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

calcolatrice.setStrategia(new StrategiaMoltiplicazione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

AlgoritmiTeoria - 7 - graph - belman-ford

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: BELLMAN-FORD

L’algoritmo di Bellman-Ford calcola i percorsi minimi da un nodo sorgente a tutti gli altri nodi in un grafo orientato o non orientato pesato, anche con archi a peso negativo, a condizione che non siano presenti cicli negativi raggiungibili dalla sorgente.

PRECONDIZIONI

Il grafo può contenere archi con peso negativo.
Non devono esserci cicli negativi raggiungibili dalla sorgente.
Funziona su grafi orientati e non orientati pesati.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso (positivo o negativo).
Distanza → costo cumulativo minimo dal nodo sorgente a un nodo.
Predecessore (Parent/Predecessor) → nodo precedente lungo il percorso minimo.
Rilassamento (Relaxation) → operazione che aggiorna la distanza di un nodo se si trova un percorso più corto.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice nel grafo.
aggiungiArco(v1, v2, peso) → aggiunge un arco orientato o non orientato con peso.
bellmanFord(start) → calcola i percorsi minimi dal nodo sorgente start a tutti gli altri nodi, restituendo:
- le distanze minime
- i predecessori per ricostruire i percorsi.
Rileva cicli negativi: se dopo |V|-1 rilassamenti un arco può ancora essere rilassato, esiste un ciclo negativo raggiungibile dalla sorgente.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza tutte le distanze a ∞, eccetto il nodo sorgente (distanza = 0).
Ripeti |V| - 1 volte (dove |V| è il numero di vertici):
- Per ogni arco (u, v) con peso w:
  - Se distanza[u] + w < distanza[v] → aggiorna distanza[v] e imposta u come predecessore.
Controlla tutti gli archi una volta in più per rilevare eventuali cicli negativi.
Al termine:
- le distanze minime sono corrette se non ci sono cicli negativi.
- è possibile ricostruire i percorsi minimi seguendo i predecessori.

COMPLESSITÀ

Tempo → O(V * E)
Spazio → O(V) per memorizzare distanze e predecessori

ESEMPIO DI USCITA

Grafo: A -> B(4), C(2) B -> C(-1), D(5) C -> D(3), E(4) D -> E(7) E ->

AlgoritmiTeoria - 7 - graph - dijkstra

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: DIJKSTRA

L’algoritmo di Dijkstra calcola i percorsi minimi da un nodo sorgente a tutti gli altri nodi in un grafo orientato o non orientato pesato, con pesi non negativi.
È uno degli algoritmi fondamentali per il calcolo di percorsi minimi in informatica e nelle reti.

PRECONDIZIONI

Il grafo può essere orientato o non orientato.
I pesi degli archi devono essere non negativi.
Non gestisce correttamente grafi con archi a peso negativo (per quelli serve Bellman-Ford).

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con peso associato.
Distanza → costo cumulativo minimo dal nodo sorgente a un nodo.
Predecessore (Parent/Predecessor) → nodo precedente lungo il percorso minimo.
Coda di Priorità (Priority Queue / Min-Heap) → struttura utilizzata per selezionare il nodo con distanza minima.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice nel grafo.
aggiungiArco(v1, v2, peso) → aggiunge un arco orientato o non orientato con peso.
dijkstra(start) → calcola i percorsi minimi dal nodo sorgente start a tutti gli altri nodi, restituendo:
- le distanze minime
- i predecessori per ricostruire i percorsi.

RAPPRESENTAZIONE

Lista di adiacenza con pesi:
Esempio → { A: [{node: B, peso: 4}, {node: C, peso: 2}], B: [{node: C, peso: 5}], ... }

FUNZIONAMENTO DELL’ALGORITMO

Inizializza tutte le distanze a ∞, eccetto il nodo sorgente (distanza = 0).
Inserisci tutti i nodi in una coda di priorità basata sulla distanza minima.
Finché la coda non è vuota:
- Estrai il nodo con distanza minima.
- Aggiorna le distanze dei suoi vicini se si trova un percorso più corto.
- Aggiorna i predecessori dei vicini per tracciare il percorso minimo.
Al termine, si ottengono:
- la distanza minima da sorgente a ogni nodo
- il cammino più breve ricostruibile seguendo i predecessori.

COMPLESSITÀ

Inserimento vertice → O(1)
Inserimento arco → O(1)
Calcolo percorso minimo:
- Con min-heap / coda di priorità → O(V + E log V)
- Con semplice array → O(V^2)

ESEMPIO DI USCITA

Grafo: A -> B(4), C(2) B -> C(5), D(10) C -> D(3), E(4) D -> E(7) E ->

AlgoritmiTeoria - 7 - graph - edmonds-karp

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: EDMONDS-KARP

L’algoritmo di Edmonds-Karp è una specifica implementazione dell’algoritmo di Ford-Fulkerson per il calcolo del flusso massimo in un grafo connesso e pesato.
La differenza principale è l’uso della ricerca in ampiezza (BFS) per trovare i percorsi aumentanti.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco con Capacità (Capacity Edge) → connessione tra due vertici con capacità massima.
Flusso (Flow) → quantità di risorsa trasportata lungo un arco.
Percorso Aumentante (Augmenting Path) → percorso dalla sorgente al pozzo con capacità residua disponibile.
Sorgente (Source) → nodo iniziale del flusso.
Pozzo / Destinazione (Sink) → nodo finale del flusso.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza il flusso di tutti gli archi a 0.
Usa BFS per trovare il percorso aumentante più corto (minimo numero di archi) dalla sorgente alla destinazione.
Determina il flusso massimo possibile lungo questo percorso (minima capacità residua).
Aggiorna il flusso lungo gli archi diretti e inversi del percorso.
Ripeti finché non esistono più percorsi aumentanti.

STRUTTURE DI SUPPORTO

Grafo con capacità residua → memorizza capacità disponibili sugli archi.
Coda per BFS → utilizzata per individuare il percorso aumentante più breve.

COMPLESSITÀ

Tempo → O(V * E²) nel caso peggiore.
Spazio → O(V + E) per memorizzare il grafo e le capacità residue.

ESEMPIO DI UTILIZZO

Grafo con capacità: S → A(10), S → B(5), A → B(15), A → T(10), B → T(10)

AlgoritmiTeoria - 7 - graph - ford-fulkerson

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: FORD-FULKERSON

L’algoritmo di Ford-Fulkerson calcola il flusso massimo in un grafo connesso e pesato, dove i pesi rappresentano le capacità massime degli archi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco con Capacità (Capacity Edge) → connessione tra due vertici con capacità massima.
Flusso (Flow) → quantità di risorsa trasportata lungo un arco.
Percorso Aumentante (Augmenting Path) → percorso dalla sorgente al pozzo con capacità residua disponibile.
Sorgente (Source) → nodo iniziale del flusso.
Pozzo / Destinazione (Sink) → nodo finale del flusso.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza il flusso di tutti gli archi a 0.
Cerca un percorso aumentante dalla sorgente alla destinazione con capacità residua > 0.
Determina il flusso massimo possibile lungo questo percorso (minima capacità residua).
Aumenta il flusso sugli archi del percorso di questa quantità.
Aggiorna le capacità residue lungo gli archi diretti e inversi.
Ripeti finché non esistono più percorsi aumentanti.

STRUTTURE DI SUPPORTO

Grafo con capacità residua → memorizza capacità disponibili lungo gli archi.
Algoritmo di ricerca → BFS (Edmonds-Karp) o DFS per trovare percorsi aumentanti.

COMPLESSITÀ

Dipende dalla scelta della tecnica di ricerca:
- Con BFS (Edmonds-Karp) → O(V * E²)
- Con DFS → complessità può variare e dipende dai valori dei flussi.
Spazio → O(V + E) per memorizzare il grafo e le capacità residue.

ESEMPIO DI UTILIZZO

Grafo con capacità: S → A(10), S → B(5), A → B(15), A → T(10), B → T(10)

AlgoritmiTeoria - 7 - graph - kruskal

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: KRUSKAL

L’algoritmo di Kruskal è utilizzato per trovare un albero ricoprente minimo (Minimum Spanning Tree - MST) in un grafo connesso e pesato.
L’MST collega tutti i vertici senza formare cicli e minimizza la somma dei pesi degli archi inclusi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso associato.
Albero Ricoprente (Spanning Tree) → sottoinsieme di archi che collega tutti i vertici senza cicli.
MST (Minimum Spanning Tree) → albero ricoprente con somma minima dei pesi degli archi.
Union-Find / Disjoint Set → struttura dati per rilevare cicli durante l’inclusione degli archi.

FUNZIONAMENTO DELL’ALGORITMO

Ordina tutti gli archi del grafo in ordine crescente di peso.
Inizia con un grafo MST vuoto.
Per ciascun arco (u, v) nell’ordine ordinato:
- Se aggiungendo l’arco non si forma un ciclo → includilo nel MST.
- Altrimenti → scartalo.
Ripeti fino a includere V - 1 archi, dove V è il numero di vertici.

STRUTTURE DI SUPPORTO

Union-Find (Disjoint Set) → per verificare rapidamente se due vertici appartengono allo stesso sottoalbero (evita cicli).
Array / Lista di archi → per ordinare gli archi in base al peso.

COMPLESSITÀ

Tempo → O(E log E), principalmente per l’ordinamento degli archi.
Spazio → O(V + E) per memorizzare il grafo e le strutture ausiliarie.

ESEMPIO DI UTILIZZO

Grafo con archi pesati: A - B(4), A - C(2), B - C(1), B - D(5), C - D(3)

AlgoritmiTeoria - 7 - graph - not-oriented-graph

Wed, 25 Feb 2026 14:00:07 +0000

STRUTTURA DATI: GRAFO NON ORIENTATO

Un grafo non orientato è una collezione di nodi (vertici) connessi da archi che rappresentano relazioni bidirezionali.

PROPRIETÀ PRINCIPALI

Rappresentato come coppia (V, E):
- V → insieme dei vertici (nodi).
- E → insieme degli archi (coppie non ordinate di vertici).
Gli archi non hanno direzione:
se esiste un arco tra A e B, si può navigare sia da A a B che da B a A.

TERMINOLOGIA

Vertice (Vertex) → un nodo del grafo.
Arco (Edge) → connessione tra due vertici.
Grado (Degree) → numero di archi connessi a un vertice.
Percorso (Path) → sequenza di vertici connessi da archi.
Ciclo (Cycle) → percorso chiuso (inizio = fine).
Componente Connessa → sottoinsieme di vertici in cui ogni coppia è collegata direttamente o indirettamente.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice.
aggiungiArco(v1, v2) → crea un arco tra due vertici (aggiunge i vertici se non esistono).
rimuoviArco(v1, v2) → elimina un arco se presente.
rimuoviVertice(v) → elimina un vertice e tutti i suoi archi.
verificaConnesso(v1, v2) → controlla se esiste un percorso tra due vertici.
visitaAmpiezza(v) → BFS a partire da un vertice.
visitaProfondità(v) → DFS a partire da un vertice.

RAPPRESENTAZIONE

Lista di adiacenza (efficiente in grafi sparsi):
Esempio → { A: [B, C], B: [A, D], C: [A], D: [B] }
Matrice di adiacenza (più adatta in grafi densi).

EFFICIENZA

Inserimento vertice → O(1)
Inserimento arco → O(1)
Rimozione arco → O(d) (d = grado massimo tra i due vertici).
Attraversamento BFS/DFS → O(V + E)

APPLICAZIONI

Reti sociali.
Mappe stradali.
Reti di computer.
Pianificazione di percorsi senza direzione.
Analisi di sistemi complessi.

VANTAGGI

Struttura flessibile, adatta a molti problemi reali.
Operazioni ottimizzabili a seconda della rappresentazione.

LIMITAZIONI

Grafi densi → memoria elevata.
Operazioni come rimozione arco o verifica connessione possono essere costose rispetto a strutture specializzate.

NOTE

Base per algoritmi fondamentali:
- calcolo delle componenti connesse,
- rilevamento cicli,
- cammino minimo.

CODICE

/**
 * Interfaccia che rappresenta un arco pesato.
 */
export interface Edge<E> {
 node: E;
 weight: number;
}

/**
 * Implementazione di un grafo generico pesato e non orientato.
 * @typeParam E - Tipo dei vertici
 */
export class NotOrientedGraph<E> {
 private adjacencyList: Record<string, Edge<E>[]>;

 constructor() {
 this.adjacencyList = {};
 }

 /**
 * Aggiunge un vertice al grafo.
 * Se il vertice è già presente, non fa nulla.
 * @param vertex - Il vertice da aggiungere
 */
 aggiungiVertice(vertex: E): void {
 const key = String(vertex);
 if (!this.adjacencyList[key]) {
 this.adjacencyList[key] = [];
 }
 }

 /**
 * Aggiunge un arco pesato non orientato tra due vertici.
 * Se i vertici non esistono, vengono creati automaticamente.
 * @param vertex1 - Primo vertice
 * @param vertex2 - Secondo vertice
 * @param weight - Peso dell'arco
 */
 aggiungiArco(vertex1: E, vertex2: E, weight: number): void {
 const v1 = String(vertex1);
 const v2 = String(vertex2);

 if (!this.adjacencyList[v1]) {
 this.aggiungiVertice(vertex1);
 }
 if (!this.adjacencyList[v2]) {
 this.aggiungiVertice(vertex2);
 }

 this.adjacencyList[v1].push({
 node: vertex2, weight
 });
 this.adjacencyList[v2].push({
 node: vertex1, weight
 });
 }

 /**
 * Rimuove un arco tra due vertici, se esiste.
 * @param vertex1 - Primo vertice
 * @param vertex2 - Secondo vertice
 */
 rimuoviArco(vertex1: E, vertex2: E): void {
 const v1 = String(vertex1);
 const v2 = String(vertex2);

 this.adjacencyList[v1] = this.adjacencyList[v1]?.filter(edge => edge.node !== vertex2) || [];
 this.adjacencyList[v2] = this.adjacencyList[v2]?.filter(edge => edge.node !== vertex1) || [];
 }

 /**
 * Rimuove un vertice e tutti i relativi archi.
 * @param vertex - Il vertice da rimuovere
 */
 rimuoviVertice(vertex: E): void {
 const v = String(vertex);
 while (this.adjacencyList[v]?.length) {
 const adjacentEdge = this.adjacencyList[v].pop() as Edge<E>;
 this.rimuoviArco(vertex, adjacentEdge.node);
 }
 delete this.adjacencyList[v];
 }

 /**
 * Visualizza il grafo in console.
 */
 display(): void {
 for (const vertex in this.adjacencyList) {
 const edges = this.adjacencyList[vertex];
 const rappresentazione = edges.length > 0
 ? edges.map(e => `${e.node}(${e.weight})`).join(", ")
 : "NULL";
 console.log(`${vertex} -> ${rappresentazione}`);
 }
 }

 /**
 * Verifica se il grafo è connesso.
 * @returns true se il grafo è connesso, false altrimenti
 */
 verificaConnesso(): boolean {
 const visitati = new Set<string>();
 const vertices = Object.keys(this.adjacencyList);

 if (vertices.length === 0) return true; // grafo vuoto = connesso

 const dfs = (vertex: string) => {
 visitati.add(vertex);
 for (const edge of this.adjacencyList[vertex]) {
 const key = String(edge.node);
 if (!visitati.has(key)) {
 dfs(key);
 }
 }
 };

 dfs(vertices[0]);

 return vertices.length === visitati.size;
 }

 /**
 * Visita in ampiezza (BFS) a partire da un vertice.
 * @param start - Vertice di partenza
 * @returns Lista dei vertici visitati in ordine BFS
 */
 visitaAmpiezza(start: E): E[] {
 const result: E[] = [];
 const visitati = new Set<string>();
 const queue: E[] = [start];

 visitati.add(String(start));

 while (queue.length > 0) {
 const nodo = queue.shift() as E;
 result.push(nodo);

 for (const edge of this.adjacencyList[String(nodo)]) {
 const key = String(edge.node);
 if (!visitati.has(key)) {
 visitati.add(key);
 queue.push(edge.node);
 }
 }
 }

 return result;
 }

 /**
 * Visita in profondità (DFS) a partire da un vertice.
 * @param start - Vertice di partenza
 * @returns Lista dei vertici visitati in ordine DFS
 */
 visitaProfondita(start: E): E[] {
 const result: E[] = [];
 const visitati = new Set<string>();

 const dfs = (vertex: E) => {
 visitati.add(String(vertex));
 result.push(vertex);

 for (const edge of this.adjacencyList[String(vertex)]) {
 if (!visitati.has(String(edge.node))) {
 dfs(edge.node);
 }
 }
 };

 dfs(start);
 return result;
 }

 /**
 * Restituisce tutti i vertici del grafo
 * @returns tutti i vertici del grafo
 */
 getVertices(): E[] {
 const verticesSet = new Set<E>();
 for (const key in this.adjacencyList) {
 verticesSet.add(key as unknown as E);
 for (const edge of this.adjacencyList[key]) {
 verticesSet.add(edge.node);
 }
 }
 return Array.from(verticesSet);
 }
 
 /**
 * Restituisce tutti gli archi senza duplicati
 * @returns tutti gli archi senza duplicati
 */
 getEdges(): { from: E; to: E; weight: number }[] {
 const edges: { from: E; to: E; weight: number }[] = [];
 const visited = new Set<string>();

 for (const key in this.adjacencyList) {
 for (const edge of this.adjacencyList[key]) {
 // Crea un id unico indipendente dall'ordine dei nodi
 const id = [String(key), String(edge.node)].sort().join('-');
 if (!visited.has(id)) {
 edges.push({ from: key as unknown as E, to: edge.node, weight: edge.weight });
 visited.add(id);
 }
 }
 }

 return edges;
 }

 /**
 * Fornisce la lista di adiacenza dei nodi del grafo 
 * @returns lista di adiacenza
 */
 getAdjacencyList(){
 return this.adjacencyList;
 }
}

// =============================
// Test della struttura dati
// =============================

const graph = new NotOrientedGraph<string>();

graph.aggiungiVertice("A");
graph.aggiungiVertice("B");
graph.aggiungiVertice("C");

graph.aggiungiArco("A", "B", 5);
graph.aggiungiArco("A", "C", 2);
graph.aggiungiArco("B", "C", 3);

graph.display();

console.log("\nGrafo connesso:", graph.verificaConnesso());
console.log("Visita in ampiezza da A:", graph.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graph.visitaProfondita("A"));

graph.rimuoviArco("A", "C");
console.log("\nDopo aver rimosso l'arco A-C:");
graph.display();

graph.rimuoviVertice("B");
console.log("\nDopo aver rimosso il vertice B:");
graph.display();

console.log("\nGrafo connesso:", graph.verificaConnesso());
console.log("Visita in ampiezza da A:", graph.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graph.visitaProfondita("A"));

AlgoritmiTeoria - 7 - graph - oriented-graph

Wed, 25 Feb 2026 14:00:07 +0000

STRUTTURA DATI: GRAFO ORIENTATO

Un grafo orientato è una collezione di nodi (vertici) connessi da archi direzionati, dove ciascun arco rappresenta una relazione unidirezionale tra due nodi.

PROPRIETÀ PRINCIPALI

Rappresentato come coppia (V, E):
- V → insieme dei vertici (nodi).
- E → insieme degli archi (coppie ordinate di vertici).
Gli archi hanno direzione:
se esiste un arco da A a B, si può navigare solo da A a B e non viceversa.

TERMINOLOGIA

Vertice (Vertex) → un nodo del grafo.
Arco (Edge) → connessione direzionata tra due vertici.
Grado di Entrata (In-Degree) → numero di archi che arrivano a un vertice.
Grado di Uscita (Out-Degree) → numero di archi che partono da un vertice.
Percorso (Path) → sequenza di vertici connessi da archi direzionati.
Ciclo (Cycle) → percorso chiuso (inizio = fine).
Componente Fortemente Connessa → sottoinsieme di vertici in cui ogni coppia è raggiungibile reciprocamente.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice.
aggiungiArco(v1, v2) → crea un arco orientato da v1 a v2.
rimuoviArco(v1, v2) → elimina l’arco orientato da v1 a v2.
rimuoviVertice(v) → elimina un vertice e tutti i suoi archi.
verificaConnesso() → controlla se il grafo è fortemente connesso.
visitaAmpiezza(v) → BFS a partire da un vertice.
visitaProfondità(v) → DFS a partire da un vertice.

RAPPRESENTAZIONE

Lista di adiacenza (più comune):
Esempio → { A: [B, C], B: [D], C: [], D: [B] }
Matrice di adiacenza (più adatta in grafi densi).

EFFICIENZA

Inserimento vertice → O(1)
Inserimento arco → O(1)
Rimozione arco → O(d) (d = grado di uscita del vertice).
Attraversamento BFS/DFS → O(V + E)

APPLICAZIONI

Reti sociali con relazioni asimmetriche.
Modellazione di flussi di dati.
Reti di computer.
Pianificazione di percorsi con direzione.
Analisi di dipendenze in sistemi complessi.

VANTAGGI

Modellano in modo naturale relazioni asimmetriche.
Utili per processi sequenziali e dipendenze.

LIMITAZIONI

Più complessi da visualizzare rispetto ai grafi non orientati.
La connettività richiede algoritmi specifici.

NOTE

Base per algoritmi fondamentali:
- calcolo delle componenti fortemente connesse,
- rilevamento di cicli orientati,
- calcolo dei percorsi minimi.

CODICE

/**
 * Classe che rappresenta un arco orientato e pesato
 */
export class Edge<E> {
 nodo: E;
 peso: number;

 constructor(nodo: E, peso: number) {
 this.nodo = nodo;
 this.peso = peso;
 }
}

/**
 * Classe che rappresenta un grafo orientato pesato
 */
export class DirectedGraph<E> {
 private adjacencyList: Map<E, Edge<E>[]>;

 constructor() {
 this.adjacencyList = new Map();
 }

 /**
 * Aggiunge un vertice al grafo.
 * Se il vertice esiste già, non fa nulla.
 */
 aggiungiVertice(vertex: E): void {
 if (!this.adjacencyList.has(vertex)) {
 this.adjacencyList.set(vertex, []);
 }
 }

	/**
	 * Fornisce la lista di adiacenza dei nodi del grafo 
	 * @returns lista di adiacenza
	 */
	getAdjacencyList(){
		return this.adjacencyList;
	}

 /**
 * Aggiunge un arco orientato e pesato tra due vertici.
 * Se i vertici non esistono, vengono creati automaticamente.
 */
 aggiungiArco(from: E, to: E, peso: number = 1): void {
 if (!this.adjacencyList.has(from)) this.aggiungiVertice(from);
 if (!this.adjacencyList.has(to)) this.aggiungiVertice(to);

 this.adjacencyList.get(from)!.push(new Edge(to, peso));
 }

 /**
 * Rimuove un arco orientato dal grafo.
 */
 rimuoviArco(from: E, to: E): void {
 if (this.adjacencyList.has(from)) {
 this.adjacencyList.set(
 from,
 this.adjacencyList.get(from)!.filter((edge) => edge.nodo !== to)
 );
 }
 }

 /**
 * Rimuove un vertice e tutti gli archi entranti/ uscenti.
 */
 rimuoviVertice(vertex: E): void {
 this.adjacencyList.delete(vertex);

 for (const [key, edges] of this.adjacencyList.entries()) {
 this.adjacencyList.set(
 key,
 edges.filter((edge) => edge.nodo !== vertex)
 );
 }
 }

 /**
 * Visualizza il grafo (lista di adiacenza).
 */
 display(): void {
 for (const [vertex, edges] of this.adjacencyList.entries()) {
 const out = edges.map((e) => `${e.nodo}(${e.peso})`).join(", ");
 console.log(`${vertex} -> ${out || "NULL"}`);
 }
 }

 /**
 * Verifica se il grafo è fortemente connesso.
 * (Semplificato: controlla raggiungibilità da un nodo di partenza)
 */
 verificaConnesso(): boolean {
 const vertices = Array.from(this.adjacencyList.keys());
 if (vertices.length === 0) return true;

 const visitati = new Set<E>();

 const dfs = (start: E) => {
 const stack: E[] = [start];
 visitati.add(start);

 while (stack.length) {
 const v = stack.pop()!;
 for (const vicino of this.adjacencyList.get(v)!) {
 if (!visitati.has(vicino.nodo)) {
 visitati.add(vicino.nodo);
 stack.push(vicino.nodo);
 }
 }
 }
 };

 dfs(vertices[0]);
 return visitati.size === vertices.length;
 }

 /**
 * Visita in ampiezza (BFS).
 */
 visitaAmpiezza(start: E): E[] {
 const visitati = new Set<E>();
 const risultato: E[] = [];
 const coda: E[] = [start];

 visitati.add(start);

 while (coda.length > 0) {
 const nodo = coda.shift()!;
 risultato.push(nodo);

 for (const vicino of this.adjacencyList.get(nodo)!) {
 if (!visitati.has(vicino.nodo)) {
 visitati.add(vicino.nodo);
 coda.push(vicino.nodo);
 }
 }
 }

 return risultato;
 }

 /**
 * Visita in profondità (DFS).
 */
 visitaProfondita(start: E): E[] {
 const visitati = new Set<E>();
 const risultato: E[] = [];

 const dfs = (v: E) => {
 visitati.add(v);
 risultato.push(v);

 for (const vicino of this.adjacencyList.get(v)!) {
 if (!visitati.has(vicino.nodo)) {
 dfs(vicino.nodo);
 }
 }
 };

 dfs(start);
 return risultato;
 }
}

// =============================
// Test della struttura dati
// =============================
let graphTest = new DirectedGraph<string>();

graphTest.aggiungiVertice("A");
graphTest.aggiungiVertice("B");
graphTest.aggiungiVertice("C");

graphTest.aggiungiArco("A", "B", 2);
graphTest.aggiungiArco("A", "C", 5);
graphTest.aggiungiArco("B", "C", 1);

graphTest.display();

console.log("\nGrafo fortemente connesso:", graphTest.verificaConnesso());
console.log("Visita in ampiezza da A:", graphTest.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graphTest.visitaProfondita("A"));

graphTest.rimuoviArco("A", "C");
console.log("\nDopo aver rimosso l'arco A->C:");
graphTest.display();

graphTest.rimuoviVertice("B");
console.log("\nDopo aver rimosso il vertice B:");
graphTest.display();

AlgoritmiTeoria - 7 - graph - prim

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: PRIM

L’algoritmo di Prim è utilizzato per trovare un albero ricoprente minimo (Minimum Spanning Tree - MST) in un grafo connesso e pesato.
L’MST collega tutti i vertici senza formare cicli e minimizza la somma dei pesi degli archi inclusi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso associato.
Albero Ricoprente (Spanning Tree) → sottoinsieme di archi che collega tutti i vertici senza cicli.
MST (Minimum Spanning Tree) → albero ricoprente con somma minima dei pesi degli archi.
Nodo Visitato / Non Visitato → stato dei vertici durante l’esecuzione dell’algoritmo.

FUNZIONAMENTO DELL’ALGORITMO

Scegli un nodo sorgente e aggiungilo al MST.
Seleziona l’arco più leggero che connette un nodo del MST con un nodo non ancora incluso.
Aggiungi il nodo collegato al MST e marca come visitato.
Ripeti fino a includere tutti i nodi.

STRUTTURE DI SUPPORTO

Coda di priorità (Min-Heap) → per selezionare rapidamente l’arco di peso minimo.
Array / Lista di adiacenza → per memorizzare il grafo pesato.

COMPLESSITÀ

Tempo → O(E log V) con coda di priorità.
Spazio → O(V + E) per memorizzare il grafo e le strutture ausiliarie.

ESEMPIO DI UTILIZZO

Grafo con archi pesati: A - B(4), A - C(2), B - C(1), B - D(5), C - D(3)

AlgoritmiTeoria - 6 - tree - AVL tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO AVL

L’Albero AVL (Adelson-Velsky e Landis) è una variante bilanciata dei Binary Search Tree (BST).
Mantiene l’altezza dei sottoalberi sempre bilanciata, evitando il problema degli alberi sbilanciati e garantendo prestazioni efficienti.

PROPRIETÀ DI BILANCIAMENTO

Per ogni nodo N:
|altezza(sottoalbero sinistro) - altezza(sottoalbero destro)| ≤ 1

Questa proprietà viene mantenuta dinamicamente attraverso rotazioni dopo inserimenti o eliminazioni.

PROPRIETÀ DI RICERCA

Come in un BST:

AlgoritmiTeoria - 6 - tree - binary search tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO BINARIO DI RICERCA (BST)

Un Binary Search Tree (BST) è una struttura dati ad albero che organizza i valori in modo ordinato per consentire ricerca, inserimento e rimozione efficienti.

PROPRIETÀ DI RICERCA

Ogni nodo contiene un valore univoco.
Per ogni nodo N:
- Sottoalbero sinistro → valori < N.value
- Sottoalbero destro → valori > N.value
Grazie a questa proprietà, è possibile sfruttare la ricerca binaria durante la navigazione.

TERMINOLOGIA

Nodo → contiene un valore e i puntatori a sinistra e destra.
Radice (Root) → nodo principale dell’albero.
Foglia (Leaf) → nodo senza figli.
Padre (Parent) → nodo con almeno un figlio.
Figlio (Child) → nodo collegato a un padre.
Sottoalbero (Subtree) → albero discendente da un nodo.
Altezza dell’Albero → percorso più lungo dalla radice a una foglia.

OPERAZIONI PRINCIPALI

inserisci(valore) → aggiunge un nodo rispettando la proprietà BST.
cerca(valore) → verifica la presenza di un valore.
elimina(valore) → rimuove un nodo:
- Nessun figlio → eliminato direttamente.
- Un figlio → sostituito con il figlio.
- Due figli → sostituito dal successore in ordine (minimo del sottoalbero destro).
visitaInOrdine() → restituisce valori ordinati crescenti.
visitaPreOrdine() → visita radice → sottoalbero sinistro → sottoalbero destro.
visitaPostOrdine() → visita sottoalberi → radice.
altezza() → calcola la profondità massima.
contaNodi() → numero totale di nodi.

OPERAZIONI AUSILIARIE

getMin() → valore minimo (nodo più a sinistra).
getMax() → valore massimo (nodo più a destra).
isBalanced() → verifica che le altezze dei sottoalberi differiscano al massimo di 1.

EFFICIENZA

Ricerca → O(log n) (medio), O(n) (peggiore caso).
Inserimento → O(log n) (medio), O(n) (peggiore caso).
Eliminazione → O(log n) (medio), O(n) (peggiore caso).
Spazio → O(n).

APPLICAZIONI

Strutture di database.
Implementazioni di insiemi e mappe ordinate.
Algoritmi di ordinamento.
Gestione di intervalli e dati gerarchici.

NOTE

Più semplice rispetto ad AVL.
Non garantisce bilanciamento automatico.
Può degradare in una lista se i dati sono inseriti in ordine.

CODICE

class Node<E> {
 value: E;
 left: Node<E> | null;
 right: Node<E> | null;

 constructor(value: E) {
 this.value = value;
 this.left = null;
 this.right = null;
 }
}

class BinarySearchTree<E> {
 root: Node<E> | null;

 constructor() {
 this.root = null;
 }

 /**
 * Inserisce un valore nell'albero rispettando la proprieta di ricerca
 * @param value valore da inserire nell'albero
 * @returns nuovo nodo inserito
 */
 insert(value: E) : Node<E> | null{
 const newNode = new Node(value);
 if (!this.root) {
 this.root = newNode;
 return this.root;
 }

 let current = this.root;
 while (true) {
 // valori duplicati non consentiti
 if (value === current.value) return null;
 if (value < current.value) {
 if (!current.left) {
 current.left = newNode;
 return this.root;
 }
 current = current.left;
 } else {
 if (!current.right) {
 current.right = newNode;
 return this.root;
 }
 current = current.right;
 }
 }
 }

 /**
 * Cerca un valore nell'albero sfruttando la proprietà di ricerca
 * @param value valore da cercare nell'albero
 * @returns true se esiste un nodo con il valore "value", false altrimenti
 */
 find(value: E): boolean {
 if (!this.root) return false;
 let current: Node<E> | null = this.root;
 while (current) {
 if (value === current.value) return true;
 if (value < current.value) {
 current = current.left;
 } else {
 current = current.right;
 }
 }
 return false;
 }

 /**
 * Funzione ausiliaria che effettua l'eleminazione
 * @param node nodo da cui deve partire l'eliminazione, valore di partenza la radice
 * @param value valore da eliminare
 * @returns nuova radice dell'albero
 */
 private auxRemove(node: Node<E> | null, value: E): Node<E> | null {
 if (!node) return null;
 if (value < node.value) {
 node.left = this.auxRemove(node.left, value);
 return node;
 } else if (value > node.value) {
 node.right = this.auxRemove(node.right, value);
 return node;
 } else {
 // Caso 1: Nessun figlio
 if (!node.left && !node.right) return null;
 // Caso 2: Un figlio
 if (!node.left) return node.right;
 if (!node.right) return node.left;
 // Caso 3: Due figli
 let temp = this.getMin(node.right);
 if (temp) {
 node.value = temp.value;
 node.right = this.auxRemove(node.right, temp.value);
 return node;
 }
 return null;
 }
 }

 /**
 * Rimuove un nodo dall'albero
 * @param value valore del nodo da eliminare
 */
 remove(value: E): void {
 this.root = this.auxRemove(this.root, value);
 }

 /**
 * Trova il valore minimo in un sottoalbero sfruttando la proprietà di ricerca
 * @param node nodo da cui deve partire la ricerca, valore di partenza la radice
 * @returns nodo con il valore minimo, null se l'albero è vuoto
 */
 getMin(node: Node<E> | null = this.root): Node<E> | null {
 while (node && node.left) {
 node = node.left;
 }
 return node;
 }

 /**
 * Trova il valore massimo in un sottoalbero sfruttando la proprietà di ricerca
 * @param node nodo da cui deve partire la ricerca, valore di partenza la radice
 * @returns nodo con il valore massimo, null se l'albero è vuoto
 */
 getMax(node: Node<E> | null = this.root): Node<E> | null {
 while (node && node.right) {
 node = node.right;
 }
 return node;
 }

 /**
 * Funzione ausiliara che detrmina se l'albero radicato su nodo in input è bilanciato o meno
 * @param node nodo da verificare se è bilanciato
 * @returns oggetto con contenuto se è bilanciato o meno e l'altezza
 */
 private isBalancedAux(node: Node<E> | null): { balanced: boolean, height: number } {
 if (!node) return { balanced: true, height: 0 };

 const left = this.isBalancedAux(node.left);
 const right = this.isBalancedAux(node.right);

 const balanced = left.balanced && right.balanced && Math.abs(left.height - right.height) <= 1;
 const height = Math.max(left.height, right.height) + 1;

 return { balanced, height };
 };

 /**
 * Verifica che l'albero è bilanciato
 * @returns oggetto con contenuto se è bilanciato o meno e l'altezza 
 */
 isBalanced(): { balanced: boolean, height: number } {
 return this.isBalancedAux(this.root);
 }

 /**
 * Visita in ordine dell'albero
 * @returns array con i
 */
 inOrderTraversal(): E[] {
 let result: E[] = [];
 let node = this.root;
 this.auxInOrderTraversal(node, result)
 return result
 }

 /**
 * Ritorna l'albero in ordine (in-order traversal)[sx - r - dx]
 * @param node nodo da cui far partire la visita, di solito la radice
 * @param result array contenente i valori in ordine in base alla visita
 */
 auxInOrderTraversal(node: Node<E> | null, result: E[]) {
 if (node) {
 if (node.left)
 this.auxInOrderTraversal(node.left, result);

 result.push(node.value);

 if (node.right)
 this.auxInOrderTraversal(node.right, result);
 }
 }
};

// test della struttura dati
const bst = new BinarySearchTree();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(3);
bst.insert(7);
bst.insert(13);
bst.insert(18);

console.log("Attraversamento in preordine:", bst.inOrderTraversal());
console.log("Ricerca di valori:");
console.log("Cerca 7:", bst.find(7));
console.log("Cerca 20:", bst.find(20));

console.log("Eliminazione di un nodo (10)");
bst.remove(10);
console.log("Attraversamento in preordine dopo aver rimosso il 10:", bst.inOrderTraversal());

AlgoritmiTeoria - 6 - tree - binary tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO BINARIO

L’Albero Binario è una struttura dati gerarchica formata da nodi, dove ciascun nodo può avere al massimo due figli:
➡ un figlio sinistro e un figlio destro.

È ideale per rappresentare dati con relazioni gerarchiche e per implementare altre strutture complesse (es. BST, Heap, Alberi Bilanciati).

TERMINOLOGIA

Nodo → elemento dell’albero contenente un valore e puntatori ai figli.
Radice (Root) → il nodo principale, punto di partenza di tutte le operazioni.
Foglia (Leaf) → nodo senza figli.
Padre (Parent) → nodo che ha almeno un figlio.
Figlio (Child) → nodo collegato a un padre.
Fratelli (Siblings) → nodi che condividono lo stesso padre.
Sottoalbero (Subtree) → albero derivato da un nodo specifico.
Albero Vuoto → struttura senza nodi (radice nulla).
Profondità (Depth) → distanza di un nodo dalla radice.
Altezza di un Nodo → distanza fino alla foglia più lontana.
Livello (Level) → insieme dei nodi alla stessa profondità.
Altezza dell’Albero → percorso più lungo radice → foglia.
Dimensione (Size) → numero totale di nodi.

OPERAZIONI DI VISITA

Pre-Ordine → Nodo → Sottoalbero Sinistro → Sottoalbero Destro.
In-Ordine → Sottoalbero Sinistro → Nodo → Sottoalbero Destro.
Post-Ordine → Sottoalbero Sinistro → Sottoalbero Destro → Nodo.
Per Livelli (Level-Order) → attraversamento livello per livello (con una coda).

OPERAZIONI PRINCIPALI

inserisci(valore) → aggiunge un nuovo nodo nell’albero.
cerca(valore) → verifica se un valore è presente.
elimina(valore) → rimuove un nodo con valore specifico.
visitaInOrdine() → restituisce i valori in ordine simmetrico.
visitaPreOrdine() → attraversa prima il nodo, poi i sottoalberi.
visitaPostOrdine() → attraversa prima i sottoalberi, poi il nodo.
altezza() → calcola la profondità massima.
contaNodi() → restituisce il numero totale di nodi.

PRESTAZIONI

Alberi bilanciati:
• Inserimento → O(log n)
• Ricerca → O(log n)
• Eliminazione → O(log n)
Alberi sbilanciati:
• Tutte le operazioni possono degradare a O(n).

➡ L’efficienza dipende dal bilanciamento dell’albero.

AlgoritmiTeoria - 6 - tree - k-tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: K-ARY TREE

Un K-Ary Tree è una struttura dati gerarchica in cui ogni nodo può avere al massimo K figli.
È una generalizzazione dell’albero binario (dove K=2) e viene usato in contesti dove servono più di due rami di navigazione.

QUANDO USARLO

Implementazione di B-Tree e B+ Tree per database.
File system gerarchici.
rappresentazione di alberi di decisione con più alternative.
Strutture per trie (alberi di prefissi).

TERMINOLOGIA

K → numero massimo di figli per ogni nodo.
Nodo → contenitore del valore e array di figli.
Radice (Root) → nodo principale dell’albero.
Foglia (Leaf) → nodo senza figli.
Altezza → percorso più lungo dalla radice a una foglia.
Profondità → livello del nodo (radice = 0).

OPERAZIONI PRINCIPALI

inserisci(valore, parent) → aggiunge un nodo come figlio di parent.
cerca(valore) → verifica la presenza di un valore.
rimuovi(valore) → rimuove un nodo e i suoi discendenti.
visitaLivelli() → attraversamento livello per livello.
contaNodi() → numero totale di nodi.
getProfondità() → profondità massima dell’albero.

IMPLEMENTAZIONE

Ogni nodo ha un array figli di dimensione massima K.
L’inserimento fillows la prima posizione disponibile nell’array.
La ricerca è tipicamente in ampiezza (BFS) o profondità (DFS).

PRESTAZIONI

Inserimento → O(1) (se c’è spazio nel parent), altrimenti ricerca.
Ricerca → O(n) (caso peggiore, bisogna visitare tutti i nodi).
Attraversamento → O(n).

NOTE

Più flessibile dell’albero binario per rappresentare strutture complesse.
L’efficienza dipende dalla scelta di K e dalla distribuzione dei figli.
Spesso usato come base per algoritmi ottimizzati di ricerca.

CODICE

class KNode<T> {
 value: T;
 children: KNode<T>[];

 constructor(value: T) {
 this.value = value;
 this.children = [];
 }
}

class KTree<T> {
 root: KNode<T> | null;
 k: number; // massimo numero di figli

 constructor(k: number = 2) {
 this.root = null;
 this.k = k;
 }

 /**
 * Inserisce un nodo come figlio di un nodo padre esistente
 * @param value valore del nuovo nodo
 * @param parentValue valore del nodo padre (se null, inserisce alla radice)
 * @returns true se l'inserimento è riuscito, false altrimenti
 */
 insert(value: T, parentValue: T | null): boolean {
 const newNode = new KNode(value);

 // Se non c'è radice, il primo nodo diventa radice
 if (!this.root) {
 if (parentValue === null) {
 this.root = newNode;
 return true;
 }
 return false;
 }

 // Se parentValue è null, inserisci alla radice
 if (parentValue === null) {
 if (this.root.children.length < this.k) {
 this.root.children.push(newNode);
 return true;
 }
 return false;
 }

 // Trova il padre e inserisci
 return this.insertNode(this.root, parentValue, newNode);
 }

 /**
 * Funzione ausiliaria ricorsiva per inserire un nodo
 */
 private insertNode(node: KNode<T>, parentValue: T, newNode: KNode<T>): boolean {
 if (node.value === parentValue) {
 if (node.children.length < this.k) {
 node.children.push(newNode);
 return true;
 }
 return false;
 }

 // Cerca nei figli
 for (const child of node.children) {
 if (this.insertNode(child, parentValue, newNode)) {
 return true;
 }
 }
 return false;
 }

 /**
 * Cerca un valore nell'albero
 * @param value valore da cercare
 * @returns true se trovato, false altrimenti
 */
 search(value: T): boolean {
 if (!this.root) return false;
 return this.searchNode(this.root, value);
 }

 /**
 * Funzione ausiliaria per la ricerca
 */
 private searchNode(node: KNode<T>, value: T): boolean {
 if (node.value === value) return true;
 for (const child of node.children) {
 if (this.searchNode(child, value)) return true;
 }
 return false;
 }

 /**
 * Attraversamento livello per livello (BFS)
 * @returns array con i valori nell'ordine di visita
 */
 levelOrderTraversal(): T[] {
 if (!this.root) return [];
 
 const result: T[] = [];
 const queue: KNode<T>[] = [this.root];
 
 while (queue.length > 0) {
 const node = queue.shift()!;
 result.push(node.value);
 
 for (const child of node.children) {
 queue.push(child);
 }
 }
 
 return result;
 }

 /**
 * Conta il numero totale di nodi
 * @returns numero di nodi
 */
 countNodes(): number {
 if (!this.root) return 0;
 return this.countNodesRecursive(this.root);
 }

 /**
 * Funzione ausiliaria per contare i nodi
 */
 private countNodesRecursive(node: KNode<T>): number {
 let count = 1;
 for (const child of node.children) {
 count += this.countNodesRecursive(child);
 }
 return count;
 }

 /**
 * Calcola la profondità massima dell'albero
 * @returns profondità massima
 */
 getDepth(): number {
 if (!this.root) return 0;
 return this.getDepthRecursive(this.root);
 }

 /**
 * Funzione ausiliaria per calcolare la profondità
 */
 private getDepthRecursive(node: KNode<T>): number {
 if (node.children.length === 0) return 1;
 
 let maxDepth = 0;
 for (const child of node.children) {
 maxDepth = Math.max(maxDepth, this.getDepthRecursive(child));
 }
 return maxDepth + 1;
 }
}

// Esempio d'uso
const kTree = new KTree<number>(3); // K = 3

kTree.insert(1, null); // Radice
kTree.insert(2, 1); // Figlio di 1
kTree.insert(3, 1); // Figlio di 1
kTree.insert(4, 1); // Figlio di 1
kTree.insert(5, 2); // Figlio di 2
kTree.insert(6, 2); // Figlio di 2

console.log("Attraversamento livello per livello:", kTree.levelOrderTraversal());
console.log("Cerca 5:", kTree.search(5));
console.log("Cerca 10:", kTree.search(10));
console.log("Numero nodi:", kTree.countNodes());
console.log("Profondità:", kTree.getDepth());

AlgoritmiTeoria - 5 - map - map

Wed, 25 Feb 2026 14:00:05 +0000

STRUTTURA DATI: MYMAP

La MyMap è una struttura dati che implementa il concetto di mappa (o dizionario):
➡ Consente di memorizzare e recuperare coppie chiave-valore in modo rapido ed efficiente.

È ideale per scenari dove occorre associare un identificatore a un valore, ad esempio:

rubrica telefonica (nome → numero),
cache di dati,
configurazioni applicative.

STRUTTURA INTERNA

Utilizza un array come struttura sottostante.
Una funzione di hash converte la chiave in un indice dell’array.
In caso di collisione (più chiavi con stesso indice), viene utilizzato il chaining → ogni bucket contiene una lista di coppie [chiave, valore].

OPERAZIONI PRINCIPALI

set(key, value) → inserisce una nuova coppia o aggiorna il valore se la chiave esiste già.
get(key) → restituisce il valore associato a una chiave, oppure undefined se non trovata.
has(key) → verifica se una chiave è presente nella mappa (true/false).
delete(key) → rimuove una coppia chiave-valore, restituisce true se eliminata, altrimenti false.
keys() → restituisce un array contenente tutte le chiavi.
values() → restituisce un array contenente tutti i valori.
size() → restituisce il numero totale di coppie presenti.
clear() → rimuove tutte le coppie chiave-valore.

PRESTAZIONI

set → O(1) in media, O(n) in caso di collisioni estreme.
get → O(1) in media, O(n) in caso di collisioni estreme.
has → O(1) in media.
delete → O(1) in media.
keys / values → O(n) (serve attraversare tutti i bucket).

➡ La mappa è molto efficiente per la maggior parte delle operazioni, ma la qualità della funzione di hash influisce notevolmente sulle prestazioni.

AlgoritmiTeoria - 4 - queue - queue

Wed, 25 Feb 2026 14:00:04 +0000

STRUTTURA DATI: QUEUE (CODA)

La Queue (coda) è una struttura dati lineare che segue il principio FIFO (First In, First Out):
➡ Il primo elemento inserito è anche il primo a essere rimosso.

È ideale per gestire dati in ordine di arrivo, come:

gestione delle richieste in un server,
code di stampa,
algoritmi di scheduling dei processi.

STRUTTURA INTERNA

Gli elementi vengono inseriti in fondo (enqueue).
Gli elementi vengono rimossi dalla testa (dequeue).
L’ordine di arrivo viene sempre rispettato.

OPERAZIONI PRINCIPALI

enqueue(element) → inserisce un elemento in fondo alla coda.
dequeue() → rimuove e restituisce l’elemento in testa (oppure undefined se vuota).
peek() → restituisce l’elemento in testa senza rimuoverlo.
isEmpty() → restituisce true se la coda è vuota, false altrimenti.
size() → restituisce il numero di elementi nella coda.
printQueue() → stampa tutti gli elementi dalla testa alla fine.

PRESTAZIONI

enqueue → O(1)
dequeue → O(1)
peek → O(1)
isEmpty → O(1)
size → O(1)

➡ Tutte le operazioni principali sono in tempo costante.
La coda è particolarmente efficiente per scenari di gestione in tempo reale.

AlgoritmiTeoria - 3 - stack - stack

Wed, 25 Feb 2026 14:00:03 +0000

STRUTTURA DATI: STACK (PILA)

Lo Stack (pila) è una struttura dati lineare che segue il principio LIFO (Last In, First Out):
➡ L’ultimo elemento inserito è il primo a essere rimosso.

È molto utile in contesti in cui i dati devono essere gestiti in ordine inverso rispetto all’inserimento, ad esempio:

gestione delle chiamate annidate (call stack),
algoritmi di backtracking,
undo/redo in editor di testo.

STRUTTURA INTERNA

Gli elementi vengono inseriti e rimossi solo dalla cima (top).
Gli elementi sottostanti restano temporaneamente inaccessibili finché non si rimuove quello in cima.

OPERAZIONI PRINCIPALI

push(element) → inserisce un elemento in cima allo stack.
pop() → rimuove e restituisce l’elemento in cima (oppure undefined se vuoto).
peek() → restituisce l’elemento in cima senza rimuoverlo.
isEmpty() → restituisce true se la pila è vuota, false altrimenti.
size() → restituisce il numero di elementi nello stack.
printStack() → stampa tutti gli elementi dallo top alla base.

PRESTAZIONI

push → O(1)
pop → O(1)
peek → O(1)
isEmpty → O(1)
size → O(1)

➡ Tutte le operazioni avvengono in tempo costante, poiché non richiedono spostamenti o ridistribuzioni degli elementi.

AlgoritmiTeoria - 2 - list - linked list

Wed, 25 Feb 2026 14:00:02 +0000

STRUTTURA DATI: LISTA SEMPLICE

La Lista Semplice è una struttura dati dinamica composta da nodi collegati tra loro.
A differenza degli array, non ha una dimensione fissa e permette di inserire o rimuovere elementi senza dover ridimensionare l’intera struttura.
L’accesso agli elementi, però, è sequenziale, poiché non esiste un indice diretto.

STRUTTURA INTERNA

Ogni nodo della lista è composto da due campi:

data: il valore contenuto nel nodo.
next: riferimento al nodo successivo (oppure null se è l’ultimo).

La lista è gestita tramite un puntatore alla testa (head), che rappresenta il primo nodo e consente di accedere all’intera struttura.

AlgoritmiTeoria - 1 - array - binary search

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RICERCA BINARIA

La ricerca binaria è un algoritmo che consente di verificare se un elemento è presente all’interno di un array ordinato. Funziona dividendo progressivamente l’array a metà fino a trovare l’elemento cercato o determinare che non esiste.

QUANDO USARLO

Vuoi cercare un elemento in un array ordinato (crescente o decrescente).
Vuoi ridurre i tempi di ricerca rispetto alla scansione sequenziale.
Vuoi un algoritmo efficiente con complessità logaritmica.

FUNZIONAMENTO

Si considerano gli estremi dell’array (inizialmente 0 e n-1).
Si calcola l’indice dell’elemento centrale.
Si confronta l’elemento centrale con quello da cercare:

Se uguale, restituisce la posizione.
Se maggiore, si ripete la ricerca nella prima metà.
Se minore, si ripete la ricerca nella seconda metà.

Il processo continua fino a trovare l’elemento o esaurire l’array.

OUTPUT

Restituisce la posizione (tra 0 e n-1) se l’elemento è presente.
Restituisce -1 se l’elemento non è stato trovato.

COMPLESSITÀ

Caso peggiore: O(log n) a ogni passo la dimensione del problema si dimezza.

AlgoritmiTeoria - 1 - array - bubble sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: BUBBLE SORT

Il Bubble Sort è un algoritmo di ordinamento semplice che riordina un array confrontando ripetutamente coppie di elementi adiacenti e scambiandoli se sono nell’ordine sbagliato. Il processo continua finché l’array non risulta ordinato.

Visualizzazione: https://en.wikipedia.org/wiki/Bubble_sort#/media/File:Bubble-sort-example-300px.gif

QUANDO USARLO

Vuoi un algoritmo di ordinamento semplice da comprendere e implementare.
Stai lavorando con array di piccole dimensioni.
Vuoi un algoritmo didattico per introdurre i concetti di ordinamento.

FUNZIONAMENTO

Si confrontano due elementi consecutivi:

Se il primo ≤ il secondo, non si fa nulla. Esempio: (1, 3) → (1, 3)
Se il primo > il secondo, si scambiano. Esempio: (3, 2) → (2, 3)

Questo confronto viene fatto per tutte le coppie di elementi.
Una scansione completa dell’array si chiama passata.
Alla fine di ogni passata, l’elemento più grande “scivola” in fondo all’array, nella sua posizione definitiva.
L’algoritmo termina quando una passata non esegue alcuno scambio.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n) (quando l’array è già ordinato, basta una sola passata).
Caso medio: O(n²) (numerosi scambi distribuiti tra le passate).
Caso peggiore: O(n²) (array ordinato al contrario, massimo numero di scambi).

NOTE

È un algoritmo semplice ma inefficiente per array grandi.
È stabile (non cambia l’ordine relativo di elementi uguali).
Non è adatto a contesti pratici di ordinamento su grandi dataset.

CODICE

/**
 * Ordina l'array seguendo le logiche del bubbleSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function bblSort(arr: number[]): number[] {
	for (let i = 0; i < arr.length; i++) {
		for (let j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] && arr[j + 1] && arr[j]! > arr[j + 1]!) {
				const temp: number = arr[j]!;
				arr[j] = arr[j + 1]!;
				arr[j + 1] = temp;
			}
		}
	}
	return arr;
}

// Test sort
const arr = [234, 43, 55, 63, 5, 6, 235, 547];
console.log("TEST DEL BUBBLESORT");
console.log("Pre ordinamento:", arr);
const sorted = bblSort(arr)
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - counting sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: COUNTING SORT

Questo algoritmo permette di mettere in ordine un array in base agli elementi che lo compongono visualizzazione: https://it.wikipedia.org/wiki/Counting_sort#/media/File:Counting_Sort_Animation.gif

Descrizione dell’algoritmo Questo algoritmo presenta una precondizione fondamentale:

Gli elementi dell’array devono trovarsi in un intervallo compreso tra 0 e K.
La grandezza dell’intervallo determina anche la sua efficenza

FUNZIONAMENTO

Creazione di un array di supporto:
- Viene creato un array di supporto di dimensione K chiamato “array delle occorrenze” (o countArray).
- Tutti i valori di questo array vengono inizializzati a 0.
Conteggio delle occorrenze:
- L’algoritmo scorre l’array di partenza e utilizza ogni elemento come indice nell’array delle occorrenze.
- Incrementa il valore corrispondente in countArray di 1.
  Esempio: se l’elemento è 5, viene eseguito countArray[5]++.
Calcolo delle somme prefix:
- Viene modificato l’array delle occorrenze per calcolare la somma cumulativa (o somma dei prefissi) per ogni indice.
- Ogni posizione di countArray conterrà il numero totale di elementi minori o uguali a quell’indice.
Ordinamento dell’array di partenza:
- Utilizzando i prefissi calcolati nel passo precedente, l’algoritmo determina la posizione corretta di ogni elemento nell’array ordinato.

Questo processo garantisce un ordinamento stabile e rapido per array che soddisfano la precondizione iniziale.

AlgoritmiTeoria - 1 - array - insertion sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: INSERTION SORT

L’Insertion Sort è un algoritmo di ordinamento semplice e intuitivo, che costruisce progressivamente una parte ordinata dell’array inserendo ogni nuovo elemento nella posizione corretta.
Funziona in modo simile al processo di ordinare manualmente le carte da gioco in mano.

Visualizzazione:
https://it.wikipedia.org/wiki/Insertion_sort#/media/File:Sorting_insertion_sort_anim.gif

QUANDO USARLO

L’array ha piccole dimensioni o è già quasi ordinato.
Vuoi un algoritmo semplice da implementare e stabile.
È utile come parte di algoritmi più complessi (es. Shell Sort).

FUNZIONAMENTO

Si assume che il primo elemento sia già ordinato.
Per ogni elemento successivo (dal secondo fino all’ultimo):
- Si confronta l’elemento con quelli nella parte ordinata.
- Se l’elemento è maggiore del massimo ordinato → viene posto in fondo alla parte ordinata.
- Altrimenti, si spostano (shift) gli elementi più grandi di lui per fare spazio e inserirlo nella posizione corretta.
La parte ordinata cresce progressivamente di un elemento per volta, fino a includere l’intero array.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n)
(array già ordinato → basta un confronto per elemento).
Caso medio: O(n²)
(inserimenti distribuiti con vari spostamenti).
Caso peggiore: O(n²)
(array ordinato in senso opposto, massimo numero di spostamenti).

NOTE

È un algoritmo stabile (mantiene l’ordine relativo di elementi uguali).
Funziona bene su insiemi piccoli o quasi ordinati.
Per array grandi non è efficiente rispetto a QuickSort, MergeSort, ecc.

CODICE

/**
 * Ordina l'array seguendo le logiche del insertionSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function insertionSort(arr: number[]): number[] {
	for (let i = 1; i < arr.length; i++) {
		const key = arr[i]!;
		let j = i - 1;

		// Sposta gli elementi maggiori di "key" una posizione avanti
		while (j >= 0 && arr[j] && arr[j]! > key) {
			arr[j + 1] = arr[j]!;
			j = j - 1;
		}
		arr[j + 1] = key;
	}
	return arr;
}

// Test sort
const arr = [12, 11, 13, 5, 6];
console.log("TEST DELL'INSERTIONSORT");
console.log("Pre ordinamento:", arr);
const sorted = insertionSort(arr);
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - linear search

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RICERCA LINEARE

La ricerca lineare è un algoritmo che consente di verificare se un elemento è presente all’interno di un array.
Non richiede che l’array sia ordinato: controlla gli elementi uno a uno fino a trovare il valore cercato oppure fino alla fine dell’array.

QUANDO USARLO

Vuoi cercare un elemento in un array non ordinato.
L’array è di piccole dimensioni, quindi la semplicità conta più dell’efficienza.
Non hai bisogno di strutture dati avanzate o logiche di ricerca complesse.

FUNZIONAMENTO

Si scorre l’array dall’inizio alla fine.
Per ogni elemento si confronta con quello da cercare:
- Se uguale, restituisce la posizione e termina.
- Se diverso, continua con l’elemento successivo.
Se si arriva alla fine senza trovare l’elemento, l’algoritmo restituisce -1.

OUTPUT

Restituisce la posizione (tra 0 e n-1) se l’elemento è presente.
Restituisce -1 se l’elemento non è stato trovato.

COMPLESSITÀ

Caso migliore: O(1)
(se l’elemento si trova subito all’inizio).
Caso medio: O(n)
(in media deve scorrere metà dell’array).
Caso peggiore: O(n)
(se l’elemento è alla fine o non è presente).

CODICE

/**
 * Ricerca di un elmento all'interno dell'array tramite scansione lineare
 * @param arr array sul quale dobbiamo fare la ricerca
 * @param x elemento da cercare
 * @returns posizione dell'elemento all'interno dell'array se esiste, altrimenti -1
 */
function linearSearch(array: number[], x: number): number {
	for (let i = 0; i < array.length; i++) {
		if (array[i] === x) {
			return i;
		}
	}
	return -1;
}

let numbers = [1, 3, 5, 7, 8, 9];
console.log("Visualizza array:", numbers);
console.log("Ricerca all'interno dell'array dell'elemento 8, indice:", linearSearch(numbers, 8));
console.log("Ricerca all'interno dell'array dell'elemento 28, indice:", linearSearch(numbers, 28));

AlgoritmiTeoria - 1 - array - merge sort

Wed, 25 Feb 2026 14:00:01 +0000

sort/mergesort.ts

ALGORITMO: MERGE SORT

Il Merge Sort è un algoritmo di ordinamento basato sul paradigma Divide et Impera.
Divide ricorsivamente l’array in parti sempre più piccole, le ordina e poi le ricompone fino a ottenere l’array ordinato completo.

Visualizzazione:
https://it.wikipedia.org/wiki/Merge_sort#/media/File:Merge_sort_animation2.gif

QUANDO USARLO

L’array è di grandi dimensioni.
Vuoi un algoritmo stabile e con complessità garantita O(n log n).
È utile quando serve un ordinamento prevedibile, indipendente dalla disposizione iniziale dei dati.

FUNZIONAMENTO

Divisione:
- L’array viene suddiviso ricorsivamente in due metà fino a ottenere micro-array di un solo elemento.
Ricombinazione ordinata (Merge):
- Due micro-array vengono uniti confrontando i loro elementi e inserendoli in ordine crescente in un array temporaneo.
- Questo processo si ripete risalendo la ricorsione, fino a ricomporre l’intero array ordinato.

OUTPUT

Restituisce l’array ordinato sfruttando dei sottoarray

COMPLESSITÀ

Caso migliore: O(n log n)
Caso medio: O(n log n)
Caso peggiore: O(n log n)

Nota di merito alla complessità spaziale aggiuntiva, che in questo caso è O(n) in quanto ho bisogno di un array di supporto grande quanto quello di input

AlgoritmiTeoria - 1 - array - quick sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: QUICK SORT

Il Quick Sort è un algoritmo di ordinamento Divide et Impera che suddivide ricorsivamente l’array intorno a un elemento chiamato pivot.
Gli elementi minori del pivot vengono posizionati a sinistra, quelli maggiori a destra, e il processo viene ripetuto su entrambe le sotto-sezioni.

Visualizzazione:
https://en.wikipedia.org/wiki/Quicksort#/media/File:Sorting_quicksort_anim.gif

QUANDO USARLO

Vuoi un algoritmo di ordinamento rapido e con buona performance media.
L’array è di grandi dimensioni.
Puoi tollerare casi peggiori rari (O(n²)) con scelte di pivot non ottimali.
È utile quando serve un algoritmo in-place (senza array aggiuntivi significativi).

FUNZIONAMENTO

Scelta del pivot:
- Si seleziona un elemento dell’array (spesso primo, ultimo o centrale).
Partizionamento:
- Gli elementi minori del pivot vengono spostati a sinistra.
- Gli elementi maggiori del pivot vengono spostati a destra.
- Il pivot viene posizionato nella sua posizione finale.
Ricorsione:
- La procedura viene applicata ricorsivamente alla sotto-sezione sinistra e destra del pivot.
L’array diventa ordinato quando tutte le sotto-sezioni sono ordinate.

OUTPUT

Restituisce l’array ordinato come side effect (modifica in-place).

COMPLESSITÀ

Caso migliore: O(n log n)
(pivot divide sempre in modo bilanciato).
Caso medio: O(n log n)
Caso peggiore: O(n²)
(pivot scelto male, ad esempio array già ordinato e pivot sempre massimo/minimo).

NOTE

È un algoritmo non stabile (l’ordine relativo di elementi uguali può cambiare).
Molto efficiente in media e con poca memoria aggiuntiva.
L’uso di strategie di pivot migliori (es. pivot casuale) riduce il rischio di caso peggiore.

CODICE

/**
 * Funzione ausiliaria del quickSort per individuare e posizionare correttamente il pivot
 * @param arr array da ordinare
 * @param low estremo sx dell'array
 * @param high estremo dx dell'array
 * @returns la posizione del pivot una volta ordinato
 */
function partition(arr: any, low: number, high: number): number {
	const pivot = arr[high]; // pivot finale
	let i = low - 1;

	for (let j = low; j <= high - 1; j++) {
		if (arr[j] < pivot) { // nessun !
			i++;
			[arr[i], arr[j]] = [arr[j], arr[i]];
		}
	}

	[arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
	return i + 1;
}

/**
 * Ordina l'array seguendo le logiche del quickSort
 * @param arr array da ordinare
 * @param low estremo sx dell'array, valore di partenza 0
 * @param high estremo dx dell'array, valore di partenza "dimensione dell'array - 1"
 * @returns array ordinato
 */
function quickSort(arr: number[], low: number, high: number): number[] {
	if (low < high) {
		const pi = partition(arr, low, high);
		quickSort(arr, low, pi - 1);
		quickSort(arr, pi + 1, high);
		return arr;
	} else {
		return [];
	}
}

// Test
const arr = [10, 7, 8, 9, 1, 5];
console.log("TEST DEL QUICKSORT");
console.log("Pre ordinamento:", arr);
const sorted = quickSort(arr, 0, arr.length - 1);
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - radix sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RADIX SORT

Il Radix Sort è un algoritmo di ordinamento non basato sui confronti che ordina i numeri considerando le loro cifre, dalla meno significativa alla più significativa (LSD – Least Significant Digit).
È molto efficiente quando gli elementi hanno un numero limitato di cifre.

Visualizzazione:
https://it.wikipedia.org/wiki/Radix_sort#/media/File:Radix.JPG

QUANDO USARLO

Gli elementi sono numeri interi non negativi.
Le cifre dei numeri si trovano in un intervallo limitato [0, K].
Vuoi un ordinamento stabile e più efficiente di O(n log n) per insiemi di numeri con range limitato.
Utile come base per algoritmi più complessi di ordinamento di grandi dataset.

FUNZIONAMENTO

Si considerano tutti i numeri dell’array.
Si ordina ogni numero cifra per cifra, partendo dalla cifra meno significativa (unità) fino alla più significativa:
- Esempio: Array iniziale: 142, 456, 228
  - Passo 1: ordino le cifre meno significative → 142, 228, 456
  - Passo 2: ordino le cifre successive → 142, 228, 456
  - Passo 3: ordino le cifre più significative → 142, 228, 456
Dopo l’ultima iterazione, l’array risulta completamente ordinato.

OUTPUT

Restituisce l’array ordinato in modo stabile.

COMPLESSITÀ

Caso migliore: O(m(n + K))
Caso medio: O(m(n + K))
Caso peggiore: O(m(n + K))
Dove:
- m = numero di elementi nell’array
- n = numero di cifre di ciascun elemento
- K = valore massimo possibile delle cifre

NOTE

È un algoritmo stabile, quindi mantiene l’ordine relativo di elementi uguali.
Non utilizza confronti diretti tra numeri.
Particolarmente efficiente per grandi array di numeri con cifre limitate.

CODICE

/**
 * Calcola la cifra di un numero in una certa posizione
 * @param num numero di partenza
 * @param place posizione di cui si vuole sapere la cifra
 * @returns la cifra in posizione "place" del numero "num"
 */
function getDigit(num: number, place: number) {
	return Math.floor(Math.abs(num) / Math.pow(10, place)) % 10
}

/**
 * Calcola il numero di cifre totali di un numero
 * @param num numero di partenza
 * @returns totale delle cifre del numero "num"
 */
function digitCount(num: number) {
	if (num === 0) return 1
	return Math.floor(Math.log10(Math.abs(num))) + 1
}

/**
 * Calcola quall'è il numero con piu cifre in assoluto di un array
 * @param nums array di numeri
 * @returns quante cifre ha il numero con più cifre all'interno di "nums"
 */
function mostDigits(nums: number[]) {
	let maxDigits = 0
	for (let i = 0; i < nums.length; i++) {
		maxDigits = Math.max(maxDigits, digitCount(nums[i]!))
	}
	return maxDigits
}

/**
 * Ordina l'array seguendo le logiche del radicSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function radixSort(arr: number[]): number[] {
	const maxDigitCount = mostDigits(arr);

	for (let k = 0; k < maxDigitCount; k++) {
		const digitBuckets: number[][] = Array.from({ length: 10 }, () => []);

		for (const num of arr) {
			const digit = getDigit(num, k);
			if (digitBuckets[digit]) { // controllo
				digitBuckets[digit].push(num);
			}
		}

		// Ricostruisci l'array in base ai buckets
		arr = ([] as number[]).concat(...digitBuckets);
	}

	return arr;
}

// Test sort
const arr = [1, 33, 444, 0, 3, 2];
console.log("TEST DEL RADICSORT");
console.log("Pre ordinamento:", arr);
const sorted = radixSort(arr)
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - selection sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: SELECTION SORT

Il Selection Sort è un algoritmo di ordinamento semplice che funziona selezionando ripetutamente il minimo elemento da un sotto-array non ordinato e scambiandolo con il primo elemento non ordinato.
Ripetendo questo processo, l’array diventa ordinato.

Visualizzazione:
https://en.wikipedia.org/wiki/Selection_sort#/media/File:Selection-Sort-Animation.gif

QUANDO USARLO

L’array è di piccole dimensioni.
Vuoi un algoritmo semplice da implementare.
Non hai necessità di stabilità nell’ordinamento.

FUNZIONAMENTO

Si individua l’elemento minimo nell’array o sotto-array corrente.
Si scambia il minimo con il primo elemento non ordinato.
Si ripete la procedura sul sotto-array che va dalla posizione successiva fino alla fine dell’array.
L’array è ordinato quando tutti gli elementi sono stati posizionati.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n²)
Caso medio: O(n²)
Caso peggiore: O(n²)

NOTE

È un algoritmo non stabile (l’ordine relativo degli elementi uguali può cambiare).
Funziona bene su array piccoli ma inefficiente su array grandi.
Ha il vantaggio di fare un numero minimo di scambi rispetto ad altri algoritmi O(n²).

CODICE

/**
 * Ordina l'array seguendo le logiche del selectionSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function selectionSort(arr: number[]): number[] {
	const arrToSort = [...arr]; // copia locale
	const n = arrToSort.length;

	for (let i = 0; i < n; i++) {
		let min = i;
		for (let j = i + 1; j < n; j++) {
			if (arrToSort[j] && arrToSort[min] && arrToSort[j]! < arrToSort[min]!) {
				min = j;
			}
		}
		if (min !== i && arrToSort[i] && arrToSort[min]) {
			const tmp = arrToSort[i]!;
			arrToSort[i] = arrToSort[min]!;
			arrToSort[min] = tmp;
		}
	}

	return arrToSort;
}

// Test sort
let arr: number[] = [234, 43, 55, 63, 5, 6, 235, 547];
console.log("TEST DEL SELECTIONSORT");
console.log("Pre ordinamento:", arr);
const sorted = selectionSort(arr);
console.log("Post ordinamento:", sorted);