Sei sulla pagina 1di 61

Algoritmi e Strutture Dati

Introduzione
Liliana Lo Presti
A.A. 2018/2019
Outline
• Problema Computazionale vs Algoritmo
• Pseudo-codice
• Introduzione alla valutazione dell’efficienza di un algoritmo
• Introduzione alla valutazione della correttezza di un algoritmo
Definizioni di base
• Problema computazionale: dato un dominio di input ed un dominio
di output, un problema computazionale è una relazione che associa
ad ogni elemento del dominio di input un elemento del dominio di
output (rappresenta una classe di problemi concreti/istanze)

• Algoritmo: dato un problema computazionale, un algoritmo è una


sequenza finita di passi elementari e non ambigui in un sistema
formale di calcolo capace di individuare, per ogni istanza del
problema, una soluzione - nel caso in cui essa esista - o di certificare
l’inesistenza di una soluzione per l’istanza considerata
Es. Problema
• Date le altezze di un gruppo di persone, individuare le altezze delle
persone alte
Es. Problema
• Date le altezze di un gruppo di persone, individuare le altezze delle
persone alte

Formulazione ambigua del problema


Non è un algoritmo…
Per ogni persona nel gruppo di persone
stabilire se la persona è alta o meno

È una sequenza di passi


I passi sono ambigui: cosa significa
«una persona è alta»?
Manca una definizione!
Es. Problema
• Date le altezze in metri di un gruppo di N persone, restituire le
altezze delle persone che sono alte. Le persone sono alte se la loro
altezza è maggiore di H m

• Date le altezze in metri di un gruppo di 100 persone, restituire le


altezze delle persone che sono alte. Le persone sono alte se la loro
altezza è maggiore di 1,70 m

Con una definizione più formale del problema...


Questo è un algoritmo!
Definisci R come l’insieme delle altezze da restituire
Per ogni persona nel gruppo di N persone
Se l’altezza della persona è superiore a H aggiungi questa altezza ad R
Restituisci R
Esempi di Problemi Computazionali
1. Calcolare il minimo di un insieme S. Il minimo è quell’elemento di S
che è minore o uguale ad ogni elemento di S

2. Sia S = [s1, s2… sn] una sequenza di dati ordinati e distinti.


Eseguire una ricerca della posizione di un dato v in S consiste nel
restituire l’indice i tale che 1 ≤ # ≤ $ se v è presente nella posizione
i, 0 se v non è presente in S
Esempi di Problemi Computazionali
1. Calcolare il minimo di un insieme S. Il minimo è quell’elemento di S
che è minore o uguale ad ogni elemento di S

2. Sia S = [s1, s2… sn] una sequenza di dati ordinati e distinti.


Eseguire una ricerca della posizione di un dato v in S consiste nel
restituire l’indice i tale che 1 ≤ # ≤ $ se v è presente nella posizione
i, 0 se v non è presente in S

Obiettivi, informazioni sui dati di output attesi


Esempi di Problemi Computazionali
1. Calcolare il minimo di un insieme S. Il minimo è quell’elemento di S
che è minore o uguale ad ogni elemento di S

2. Sia S = [s1, s2… sn] una sequenza di dati ordinati e distinti.


Eseguire una ricerca della posizione di un dato v in S consiste nel
restituire l’indice i tale che 1 ≤ # ≤ $ se v è presente nella posizione
i, 0 se v non è presente in S

Definizione esatta e non ambigua di come il


risultato dev’essere ottenuto
Esempi di Problemi Computazionali
Possiamo esser più precisi nella definizione del problema usando un
linguaggio ancora più formale:

min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

0 0/ ∃ 0 ∈ 1 … 1 ∶ 78 = 3
/012 3, $ = 4
0 :;7:
Problemi Computazionali

• Il primo step è ottenere una formulazione chiara e non ambigua del


problema
Esempio: Soluzioni (non efficienti) dei problemi

• Per trovare il minimo di un insieme, confronta ogni elemento con tutti gli
altri; l’elemento che è minore di tutti è il minimo

• Per trovare la posizione di v nella sequenza S, confronta v con tutti gli


elementi di S e restituisci la posizione corrispondente; restituisci 0 se
nessuno degli elementi di S è uguale a v
Esempio: Soluzioni (non efficienti) dei problemi

• Per trovare il minimo di un insieme, confronta ogni elemento con tutti gli
altri; l’elemento che è minore di tutti è il minimo

• Per trovare la posizione di v nella sequenza S, confronta v con tutti gli


elementi di S e restituisci la posizione corrispondente; restituisci 0 se
nessuno degli elementi di S è uguale a v

La descrizione della soluzione non è sufficientemente formale e gli step


non sono chiaramente definiti (sono soggetti a varie interpretazioni)
Formulazione degli algoritmi
Le descrizioni in linguaggio naturale sono imprecise e spesso ambigue
Tali descrizioni non rendono agevole il confronto tra soluzioni diverse
Inoltre, non è semplice stabilire la correttezza dell’algoritmo

Cosa ci serve?

1. un linguaggio più formale


2. definizione del concetto di “migliore”
3. definizione del concetto di correttezza
Pseudo-codice
• Non usiamo un linguaggio di programmazione o il linguaggio naturale

• Definizione: lo pseudo-codice è un linguaggio formale e non ambiguo


(non standardizzato) che richiama i linguaggi di programmazione.

• Permette di definire gli algoritmi in modo indipendente dal linguaggio di


programmazione sganciandosi dai dettagli implementativi (per esempio,
non mi preoccupo di come le variabili logiche devono essere dichiarate:
bool in C/C++, boolean in Java)
Pseudo-codice
• Permette di definire gli algoritmi in modo più formale di quanto faremmo
con il linguaggio naturale

• Permette di scegliere il livello di dettaglio con cui descriviamo il nostro


algoritmo

• Es.:, se l’algoritmo richiede di ordinare gli elementi di un insieme S ma


l’ordinamento non è il cuore dell’algoritmo stesso possiamo scrivere

S = sort(S)

omettendo i dettagli relativi al modo in cui ordiniamo gli elementi di S


Esempio: pseudo-codice
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do
3: isMin True
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then
6: isMin False
7: if isMin = True then
8: return S[i]
Esempio: pseudo-codice
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do Questo algoritmo può essere
3: isMin True implementato in qualsiasi linguaggio di
4: for j 1 to n do programmazione.
5: if i 6= j and S[j] < S[i] then Scelto il linguaggio di programmazione,
6: isMin False
dovrò preoccuparmi di come dichiarare e
7: if isMin = True then
8: return S[i]
definire tutte le variabili coinvolte
Algorithm 1 Find the minimum value of n elements in S
1: function min(S, n)
2: for i 1 to n do
3: isMin True
Esempio: pseudo-codice
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then
6: isMin False
7: if isMin = True then " "! ∃ " ∈ 1 … # ∶ /0 = %
!"#$ %, ' = )
8: return S[i] 0 23/2

Algorithm 2 Search the value v among the n elements of S


1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
5: return 0

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
Quanti algoritmi per una classe di problemi?
• A volte, per una classe di problemi, è possibile formulare più di un
algoritmo risolutivo

• Nasce quindi la necessità di scegliere tra più alternative

• La scelta dell’algoritmo da utilizzare per risolvere il problema mira a


selezionare l’algoritmo più conveniente in termini di risorse utilizzate

• Gli algoritmi vengono eseguiti su macchine e, pertanto, consumano


risorse di calcolo (tempo di CPU, numero di operazioni da eseguire) e
di memoria (storage dei dati in input, output e variabili intermedie)
Valutazione degli algoritmi - Efficienza
• Complessità di un algoritmo: analisi delle risorse impiegate da un
algoritmo per risolvere un problema in funzione della dimensione e
della tipologia dell’input

• Risorse:
• Tempo
• Spazio
• Banda
Valutazione degli algoritmi - Efficienza
• Complessità di un algoritmo: analisi delle risorse impiegate da un
algoritmo per risolvere un problema in funzione della dimensione e
della tipologia dell’input

• Risorse:
• Tempo cosa misuriamo? Tempo esecuzione? Numero di operazioni
rilevanti? Numero di operazioni elementari?
• Spazio
• Banda
Valutazione degli algoritmi - Efficienza
• Complessità di un algoritmo: analisi delle risorse impiegate da un
algoritmo per risolvere un problema in funzione della dimensione e
della tipologia dell’input

• Risorse:
• Tempo
• Spazio quantità di memoria usata
• Banda quantità di bit inviati (algoritmi distribuiti)
Valutazione in base al tempo di esecuzione
• Scelto un linguaggio di programmazione, possiamo implementare il nostro
algoritmo

• Per misurare le prestazioni dell’algoritmo, possiamo condurre un insieme


di esperimenti che consistono in:
• eseguire lo stesso algoritmo su diversi insiemi di dati;
• calcolare le prestazioni medie dell’algoritmo (per es. velocità di esecuzione)

• Questo tipo di valutazione ha diversi limiti:


• Devo implementare l’algoritmo prima di sapere se è o meno la soluzione più
conveniente;
• Difficilmente è possibile testare l’algoritmo su qualsiasi insieme di dati in input
Valutazione in base al tempo di esecuzione
• Il tempo effettivamente impiegato per eseguire l’algoritmo

• Dipende da:
• Bravura del programmatore;
• Linguaggio di programmazione e compilatore;
• Hardware (processore, tipi di cache)
• Sistema operativo e processi attualmente in esecuzione
Analisi degli algoritmi
• Per selezionare l’alternativa più conveniente conduciamo un’analisi
matematica degli algoritmi in modo da stimare le «prestazioni»

• Questa analisi è normalmente più affidabile rispetto alla valutazione


sperimentale dell’algoritmo perché:
• Non richiede l’implementazione dell’algoritmo in un linguaggio di
programmazione;
• Evince dai dati in input all’algoritmo
Valutazione di algoritmi in base al numero di
operazioni rilevanti
• Contiamo il numero di operazioni che caratterizzano l’algoritmo

• Es.:
• Calcolo del minimo, numero di confronti (<)
• Ricerca, numero di confronti (==)
Es.: Valutazione algoritmo
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do
3: isMin True
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then
6: isMin False
7: if isMin = True then
8: return S[i]
Es.: Valutazione algoritmo
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do
3: isMin True
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then (n-1) operazioni
6: isMin False
7: if isMin = True then
8: return S[i]
Es.: Valutazione algoritmo
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do
3: isMin True
4: for j 1 to n do
n volte nel
5: if i 6= j and S[j] < S[i] then (n-1)
6: isMin False
caso peggiore
7: if isMin = True then
8: return S[i]
Es.: Valutazione algoritmo
min $ = & ⇔ ∃ & ∈ $ ∶ ∀ , ∈ $, & ≤ ,

Algorithm 1 Find the minimum value of n elements in S


1: function min(S, n)
2: for i 1 to n do
3: isMin True
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then n * (n -1) circa n2
6: isMin False
7: if isMin = True then
8: return S[i]
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Un algoritmo «migliore»
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
min
4: $ = & return
⇔ ∃ &i ∈ $ ∶ ∀ , ∈ $, & ≤ ,
5: return 0

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
4: if S[i] < minValue then
5: minValue S[i]
6: return minValue
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Un algoritmo «migliore»
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
min
4: $ = & return
⇔ ∃ &i ∈ $ ∶ ∀ , ∈ $, & ≤ ,
5: return 0

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
4: if S[i] < minValue then (n -1) confronti
5: minValue S[i]
6: return minValue
Graficamente…
! = #$ − #

! =#−1
Algorithm 1 Find the minimum value of n elements in S
1: function min(S, n)
2: for i 1 to n do
3: isMin True
Es.: Valutazione algoritmo
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then
6: isMin False
7: if isMin = True then " "! ∃ " ∈ 1 … # ∶ /0 = %
!"#$ %, ' = )
8: return S[i] 0 23/2

Algorithm 2 Search the value v among the n elements of S


1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
5: return 0

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
Algorithm 1 Find the minimum value of n elements in S
1: function min(S, n)
2: for i 1 to n do
3: isMin True
Es.: Valutazione algoritmo
4: for j 1 to n do
5: if i 6= j and S[j] < S[i] then
6: isMin False
7: if isMin = True then " "! ∃ " ∈ 1 … # ∶ /0 = %
!"#$ %, ' = )
8: return S[i] 0 23/2

Algorithm 2 Search the value v among the n elements of S


1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then n confronti
4: return i
5: return 0

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
Ricerca di un elemento…
Sia S = [s1, s2… sn] una sequenza di dati ordinati e distinti.
Eseguire una ricerca della posizione di un dato v in S consiste nel
restituire l’indice i tale che 1 ≤ # ≤ $ se v è presente nella posizione i,
0 se v non è presente in S

1 5 13 17 20 23 25

Cerchiamo il numero 21
Ricerca di un elemento…
Se non ho elementi in S da controllare
restituisci 0
Altrimenti, analizza elemento centrale (con indice m)
1. S[m] = v, trovato
2. v<S[m], cerco a sinistra di m
3. v>S[m], cerco a destra

1 5 13 17 20 23 25

Cerchiamo il numero 21
Ricerca di un elemento…
Se non ho elementi in S da controllare
restituisci 0
Altrimenti, analizza elemento centrale (con indice m)
1. S[m] = v, trovato
2. v<S[m], cerco a sinistra di m
3. v>S[m], cerco a destra.
m
1 5 13 17 20 23 25

Cerchiamo il numero 21 Caso 3


Ricerca di un elemento…
Se non ho elementi in S da controllare
restituisci 0
Altrimenti, analizza elemento centrale (con indice m)
1. S[m] = v, trovato
2. v<S[m], cerco a sinistra di m
3. v>S[m], cerco a destra
m
1 5 13 17 20 23 25

Cerchiamo il numero 21 Caso 2


Ricerca di un elemento…
Se non ho elementi in S da controllare
restituisci 0
Altrimenti, analizza elemento centrale (con indice m)
1. S[m] = v, trovato
2. v<S[m], cerco a sinistra di me
3. v>S[m], cerco a destra
m
1 5 13 17 20 23 25

Cerchiamo il numero 21 Caso 3


Ricerca di un elemento…
Se non ho elementi in S da controllare
restituisci 0
Altrimenti, analizza elemento centrale (con indice m)
1. S[m] = v, trovato
2. v<S[m], cerco a sinistra di me
3. v>S[m], cerco a destra

1 5 13 17 20 23 25

Cerchiamo il numero 21 Caso base: restituisci 0


Ricerca binaria
Algorithm 4 Search the value v among the n ordered elements of S
1: function binarySearch(S, v, first, last)
2: if first > last then
3: return 0
4: m b first+last
2 c
5: if S[m] = v then Algorithm 4 Search the value v among
6: return m
7:
8:
function binarySearch(S, v, first,
else if S[m] > v then1:
return binarySearch(S, v, first, m 1)
9:
10:
else 2:if first > last then
return binarySearch(S, v, m + 1, last)
3: return 0
4: m b first+last
2 c = Intero inferiore

5: if S[m] = v then
6: return m
Ricerca binaria
Algorithm 4 Search the value v among the n ordered elements of S
1: function binarySearch(S, v, first, last)
2: if first > last then m
3: return 0
1 5 13 17 20 23 25
4: m b first+last
2 c
5: if S[m] = v then Algorithm 4 Search the value vlastamong
first
6: return m
7:
8:
else if S[m] > v then1: function binarySearch(S, v, first,
return binarySearch(S, v, first, m 1)
9:
10:
else 2: if first > last then
return binarySearch(S, v, m + 1, last)
3: return 0
Ogni volta dimezzo la dimensione first+last = Intero inferiore
4:
dei dati in cui effettuare la ricerca m b 2 c
5: if S[m] = v then
6: return m
Ricerca binaria Ad un certo punto, avremo un
unico elemento
Algorithm 4 Search the value v among the n ordered elements of S
1: function binarySearch(S, v, first, last)
2: if first > last then m
3: return 0
first+last 1 Algorithm
5 13 4 Search
17 the value
20 23 v 25among the
4: m b 2 c
1: function binarySearch(S, v, first, las
5: if S[m] = v then last
2: if first > last firstthen
6: return m
7: else if S[m] > v then 3: return 0
first+last =first = last = m
8: return binarySearch(S, v, first, m 1) 4: m b 2 c
9: else 5: if S[m] = v then
All’iterazione successiva il
10: return binarySearch(S, v, m + 1, last) 6: return m
primo indice sarà sempre
7: else ifmaggiore
S[m] >del v then
secondo e ci
8: return binarySearch(S,
ritroviamo nel caso base v, first,
9: else
10: return binarySearch(S, v, m +
Valutazione algoritmo: Ricerca binaria
Algorithm 4 Search the value v among the n ordered elements of S
1: function binarySearch(S, v, first, last)
2: if first > last then
3: return 0
4: m b first+last
2 c
5: if S[m] = v then Quanti confronti?
6: return m
7: else if S[m] > v then
8: return binarySearch(S, v, first, m 1)
9: else
10: return binarySearch(S, v, m + 1, last)
Algorithm 4 Search the value v among
1: function binarySearch(S, v, first,
if first > last then
Valutazione algoritmo: Ricerca binaria
2:
3: return 0
4: m b first+last
2 c
Algorithm 4 Search the value v among the n ordered
5: elements
if S[m] of S= v then
1: function binarySearch(S, v, first, last)
2: if first > last then 6: return m
Ogni volta che chiamo la funzione
3: return 0
first+last
7: else if confronto
faccio un S[m] > v then
4: m b c
5:
2
if S[m] = v then
8: return
Richiamo binarySearch(S,
la funzione finchè ho dati v, fi
6: return m 9: else
Ad ogni passo, dimezzo il numero di
7: else if S[m] > v then dati return binarySearch(S, v, m
10:
8: return binarySearch(S, v, first, m 1)
9: else 11: mQuindi blog nc
2
10: return binarySearch(S, v, m + 1, last)
1: function binarySearch(S, v, first,
2: if first > last then
3: return 0
4: m b first+last
2 c
5: if S[m] = v then
Graficamente… 6: return m
7: else if S[m] > v then
n
8: return binarySearch(S, v, fi
9: else
10: return binarySearch(S, v, m
11: m blog2 nc
Valutazione Algoritmo
• Di un algoritmo valutiamo e dimostriamo anche la correttezza,
ovvero la capacità dell’algoritmo di risolvere il problema in modo
corretto

• Ci serviamo del concetto di Invariante

• Un Invariante è una condizione che deve esser vera in determinati


punti dell’algoritmo
Invariante
• Invariante: condizione vera in un certo punto del programma

• Invariante di ciclo: condizione vera all’inizio dell’iterazione di un


ciclo

• Invariante di classe: condizione vera al termine dell’esecuzione di un


metodo di una classe
Invariante di ciclo
• Usato per dimostrare la correttezza di un algoritmo iterativo

• Distinguiamo 3 fasi:
• Inizializzazione (caso base): condizione vera alla prima iterazione

• Conservazione (passo induttivo): se la condizione è vera all’inizio


dell’iterazione, rimane vera al suo termine

• Conclusione: quando il ciclo termina, l’invariante rappresenta la correttezza


dell’algoritmo
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Es.: Valutazione Correttezza
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
• Invariante di ciclo: all’inizio dell’iterazione i-esima, la variabile
5: return 0
minValue contiene il minimo parziale di S[1…i-1]

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1]
3: for i 2 to n do
4: if S[i] < minValue then
5: minValue S[i]
6: return minValue
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Es.: Valutazione Correttezza
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
• Invariante di ciclo: all’inizio dell’iterazione i-esima,, la variabile
5: return 0
minValue contiene il minimo parziale di S[1…i-1]

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1] Inizializzazione:
3: for i 2 to n do Quando i = 2, minValue = min(S[1…1]) Vero
4: if S[i] < minValue then
5: minValue S[i]
6: return minValue
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Es.: Valutazione Correttezza
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
• Invariante di ciclo: all’inizio dell’iterazione i-esima,, la variabile
5: return 0
minValue contiene il minimo parziale di S[1…i-1]

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1] Conservazione:
3: for i 2 to n do Quando termino l’iterazione i-esima,
4: if S[i] < minValue then minValue = min(minValue, S[i])=
5: minValue S[i] = min(S[1…i-1], S[i])=
6: return minValue = min(S[1…i]) Vero

La conservazione garantisce che la condizione sarà


vera anche all’inizio del prossimo ciclo
6: isMin False
7: if isMin = True then
8: return S[i]

Algorithm 2 Search the value v among the n elements of S


Es.: Valutazione Correttezza
1: function find(S, n, v)
2: for i 1 to n do
3: if S[i] = v then
4: return i
• Invariante di ciclo: all’inizio dell’iterazione i-esima,, la variabile
5: return 0
minValue contiene il minimo parziale di S[1…i-1]

Algorithm 3 Find the minimum value of n elements in S v.2


1: function min(S, n)
2: minValue S[1] Conclusione:
3: for i 2 to n do Il ciclo termina quando i = n + 1
4: if S[i] < minValue then In tale situazione, Vero
5: minValue S[i] minValue = min(S[1…i-1])= min(S[1…n])
6: return minValue
Es.: Valutazione Correttezza
Uso una dimostrazione per induzione per verificare la correttezza di un algoritmo ricorsivo.
Indichiamo con n il numero di elementi passati all’algoritmo, dimostriamo correttezza per ogni n

Algorithm 4 Search the value v among the n ordered elements of S


1: function binarySearch(S, v, first, last) Caso base:
2: if first > last then n = 0 (i>j). Banalmente corretto
3: return 0
4: m b first+last
2 c
5: if S[m] = v then
6: return m
7: else if S[m] > v then
8: return binarySearch(S, v, first, m 1)
9: else
10: return binarySearch(S, v, m + 1, last)
Es.: Valutazione Correttezza
Uso una dimostrazione per induzione per verificare la correttezza di un algoritmo ricorsivo.
Indichiamo con n il numero di elementi passati all’algoritmo, dimostriamo correttezza per ogni n

Algorithm 4 Search the value v among the n ordered elements of S


1: function binarySearch(S, v, first, last) Caso base:
2: if first > last then n = 0 (i>j). Banalmente corretto
3: return 0
4: m b first+last
2 c
Ipotesi induttiva:
5: if S[m] = v then Supponiamo sia corretto per ogni
6: return m n’<n
7: else if S[m] > v then
8: return binarySearch(S, v, first, m 1)
9: else Passo induttivo:
10: return binarySearch(S, v, m + 1, last) Dimostriamo che è corretto per n
Es.: Valutazione Correttezza
Uso una dimostrazione per induzione per verificare la correttezza di un algoritmo ricorsivo.
Indichiamo con n il numero di elementi passati all’algoritmo, dimostriamo correttezza per ogni n

Algorithm 4 Search the value v among the n ordered elements of S


1: function binarySearch(S, v, first, last) Dato n posso considerare 3 casi:
2: if first > last then 1. Elemento cercato è quello centrale à
3: return 0 algoritmo è corretto
4: m b first+last
2 c
2. l’elemento si trova a sinistra di quello centrale,
5: if S[m] = v then ripeto algoritmo su un numero di elementi n’ =
6: return m n/2 <n à per l’ipotesi induttiva l’algoritmo è
7: else if S[m] > v then corretto
8: return binarySearch(S, v, first, m 1)
9: else 3. l’elemento si trova a destra di quello centrale,
10: return binarySearch(S, v, m + 1, last) ripeto algoritmo su un numero di elementi n’ =
n/2 <n à per l’ipotesi induttiva l’algoritmo è
corretto
In definitiva
• Problema vs Problema Computazionale vs Algoritmo
• L’importanza di definizioni formali e non ambigue
• Pseudo-codice
• Valutazione dell’efficienza di un algoritmo
• Valutazione della correttezza di un algoritmo

Potrebbero piacerti anche