ITERAZIONE e RICORSIONE (eseguire uno stesso calcolo ripetutamente) ITERAZIONE: ripetere piu’ volte una sequenza di operazioni istruzioni: for, while, do while. Es. somma i primi n interi: ( ( ( (1)+ 2) +3)+…+ n) somma=0 somma=0+1=1 somma=1+2=3 … somma= somma + n for (i=1, i<=n, i++) somma=somma +i

ITERAZIONE e RICORSIONE (eseguire uno stesso calcolo ripetutamente) ITERAZIONE: ripetere piu’ volte una sequenza di operazioni istruzioni: for, while, do while. Es. Cerca il minimo tra A[0],…,A[n-1] min=A[0] min=min{min, A[1]} min=min{min, A[2]} … min=min{min, A[n-1]} {min=A[0]; for (i=1, i<n, i++) if (A[i]<min) min=A[i]} [5, 7, 3, 1, 4] min=5 min=min{5,7}=5 min=min{5,3}=3=min{5,7,3} min=min{3,1}=1 =min{5,7,3,1} min=min {1,4}=1 =min {5,7,3,1,4}

SORTING (Ordinamento) Ordinare una lista significa permutare gli elementi in modo da averli in ordine non decrescente da sinistra a destra lista iniziale (3,1,4,1,5,9,2,6,3)

SORTING (Ordinamento) Ordinare una lista significa permutare gli elementi in modo da averli in ordine non decrescente da sinistra a destra lista iniziale (3,1,4,1,5,9,2,6,3) lista ordinata (1,1,2,3,3,4,5,6,9) La lista ordinata contiene gli stessi elementi e conserva il numero di occorrenze di ogni valore

LISTA ORDINATA Date le variabili a e b, a£b se e solo se il valore di a è minore di quello di b oppure a e b hanno lo stesso valore Una lista (a0,a1,…,an-1) è ordinata (sorted) se a0£ a1£ … £ an-1

SORTING (Ordinamento) LISTA ORDINATA Date le variabili a e b, a£b sse il valore di a è minore di quello di b oppure a e b hanno lo stesso valore Una lista (a0,a1,…,an-1) è ordinata (sorted) se a0£ a1£ … £ an-1 SORTING (Ordinamento) Input: lista (a0,a1,…,an-1) output: lista (b0,b1,…,bn-1) tale che 1. è una lista ordinata 2. è una permutazione della lista input, ogni elemento appare con la stessa molteplicità nelle due liste Es. (3,5,7,2,3,5) => (2,3,3,5,5,7)

SELECTION SORT (algoritmo iterativo) La lista da ordinare è contenuta in un array A di n interi. METODO. Iteriamo il seguente passo: l’array A è diviso in 2 parti Parte iniziale ordinata | parte finale da ordinare cerchiamo l’elemento minimo nella parte non ordinata e lo scambiamo con il primo della parte non ordinata

SELECTION SORT (algoritmo iterativo) La lista da ordinare è contenuta in un array A di n interi. METODO. Iteriamo il passo: l’array A è diviso in 2 parti A= Parte iniziale ordinata | parte finale da ordinare cerchiamo l’elemento minimo nella parte non ordinata e lo scambiamo con il primo elemento della parte non ord. I iterazione: A[0..n-1] non ordinato, cerca minimo di A[0..n-1] e scambialo con A[0]. Quindi: A[0] |A[1..n-1] Es: [5,2,1,3] => [1,2,5,3]

SELECTION SORT (algoritmo iterativo) Parte iniziale ordinata | parte finale da ordinare I iterazione: A[0..n-1] non ordinato, cerca minimo di A[0..n-1] e scambialo con A[0]. Quindi: A[0] |A[1..n-1] Es: [5,2,1,3] => [1,2,5,3] II iterazione: A[0] ordinato, A[1..n-1] non ordinato, cerca minimo di A[1..n-1] e scambialo con A[1]. Quindi: A[0]A[1] A[2..n-1] Es: [1,2,5,3] => [1,2,5,3]

SELECTION SORT (algoritmo iterativo) Parte iniziale ordinata | parte finale da ordinare generica iterazione: A[0..i-1] ordinato, A[i..n-1] non ordinato, cerca minimo di A[i..n-1] e scambialo con A[i]. Quindi: A[0..i] A[i+1..n-1] Per i=n-2: A[0..n-2] A[n-1]. ARRAY ORDINATO Es: [5,2,1,3] => [1,2,5,3] => [1,2,5,3] => [1,2,3,5] = =[1,2,3,5]

SELECTION SORT (algoritmo iterativo) (1) for (i=0,i<=n-2,i++) { (2) small=i /* variabile small rappresenta la prima occorrenza del minimo di A[i..n-1]*/ (3) for (j=i+1, j<n,j++) if (A[j]<A[small]) small=j; /* trova indice del minimo e mettilo in small */ (4) temp=A[small]; (5) A[small]=A[i]; (6) A[i]=temp; /* scambia valori di A[i] ed A[small]*/ }

SELECTION SORT (algoritmo iterativo) (1) for (i=0,i<n-1,i++) { (2) small=i /* variabile small rappresenta la prima occorrenza del minimo di A[i..n-1]*/ (3) for (j=i+1, j<n,j++) if (A[j]<A[small]) small=j; /* trova indice del minimo e mettilo in small */ (4) temp=A[small]; (5) A[small]=A[i]; (6) A[i]=temp; /* scambia valori di A[i] ed A[small]*/ } Es. A=[5|7] i=0, small=0 j=1, A[1]>A[small] Scambia A[0] e A[0] Risultato A[5|7] Es. A=[7|5] i=0, small=0 j=1, A[1]<A[small], small=1 Scambia A[0] e A[1] Risultato A[5|7]

Es. A=[40|30|20|10] i=0, small=0 j=1, A[1]=30<A[small]=40, small=1 j=2, A[2]=20<A[small]=A[1]=30, small=2 j=3, A[3]=10<A[small]=A[2]=20, small=3 Scambia A[0] e A[3] Risultato Parziale A=[10|30|20|40] i=1, small=1 j=3, A[3]=40>A[small]=A[2]=20 Scambia A[1] e A[2] Risultato Parziale A=[10|20|30|40] i=2, small=2 j=3, A[3]=40>A[small]=A[2]=30 Scambia A[2] e A[2] Risultato A=[10|20|30|40] =[10|20|30|40] ordinato

Esercizi. Simulare l’esecuzione del selection sort per i seguenti array:

ORDINE LESSICOGRAFICO Possiamo ordinare ogni volta che esiste una relazione di “minore” ( < ). Ordina lessicografico: Dato un alfabeto A con un ordine sulle lettere (es. a<b<c<…<z) ed una coppia di sequenze c1c2 …ck, d1d2…dm risulta c1c2 …ck < d1d2…dm 1) se k<m e c1=d1,…,ck=dk (cioè la prima è l’inizio della seconda) 2) oppure c1=d1,..,ci-1=di-1, ci<di per qualche i. (cioè l’ordine è dato dal primo simbolo in cui le due sequenze differiscono) Es. 2) alano < alati (n < t) albero < foglia (a<f) Es. 1) ala < alato

SORTING ON KEYS A volte vogliamo ordinare usando solo una parte specifica dei valori (KEY). Se abbiamo delle strutture possiamo ordinare su di un solo campo Es. type struct studente { int matricola; chararray nome int voto} possiamo ordinare secondo uno dei 3 campi. Se ordiniamo per matricola allora dobbiamo confrontare i campi matricola.Nel SelectionSort, A è un array di strutture e si hanno i confronti A[j].matricola < A[small].matricola

Dimostrazioni Affermazione (o proposizione): può essere vera o falsa Dimostrazione: Data una affermazione S(n), vogliamo dimostrare che essa è vera. Es. S(n): risulta Si vuole dimostrare che S(n) vale per ogni n > 1.

Dimostrazioni Es. S(n): è primo Si vuole dimostrare che S(n) vale per ogni n > 1. Proviamo per qualche valore p(1)=43 primo P(2)=47 primo P(3)=53 primo … P(20)=461 primo P(39)=1601 primo VERA?

Dimostrazioni Es. S(n): è primo Si vuole dimostrare che S(n) vale per ogni n > 1. Proviamo per qualche valore p(1)=43 primo P(2)=47 primo P(3)=53 primo … P(20)=461 primo P(39)=1601 primo P(40)=40x40+40+41=41x41 FALSO!

Dimostrazioni Congettura di Goldbach (1742) S(n): n si può scrivere come somma di due primi S(n) vera per ogni n>2? S(n) vera per ogni n testato, ma non si conosce la risposta! Non possimo stabilire VERO provando per un numero finito di valori! Servono altri metodi

INDUZIONE Data una affermazione S(n), vogliamo dimostrare che essa vale per ogni intero n>a. Es. S(n): risulta Si vuole dimostrare che S(n) vale per ogni n > 1.

INDUZIONE Vogliamo dimostrare che S(n) vale per ogni intero n>a. Una dimostrazione per induzione consiste di 2 fasi BASE INDUTTIVA. Si dimostra che l’affermazione è vera per il primo valore, cioè S(a) è vera. PASSO INDUTTIVO. Assumiamo che S(n-1) è vera e dimostriamo che allora anche S(n) è vera.

INDUZIONE BASE INDUTTIVA. S(a) è vera. 2. PASSO INDUTTIVO. S(n-1) implica S(n) vera. Es. S(n): Si vuole dimostrare che S(n) vale per ogni n > 1. Base. S(1) è vera perché Passo. Ipotesi induttiva S(n-1): Si ha Quindi S(n) è vera.

INDUZIONE Esercizio. Dimostrare per induzione che la seguente affermazione S(n) è vera per ogni intero n>0. S(n):

VALIDITA’ delle dimostrazioni per INDUZIONE Base: S(a) vera Passo induttivo Dim. per induzione S(n) vera, ogni n>a Minimo controesempio. IPOTESI: S(n) falsa per qualche n. Sia b il più piccolo intero tale che S(b) falsa. DEDUCIAMO: Se b=a contraddiciamo la base. Quindi b>a. Essendo b-1>a e b = minimo intero per cui l’affermazione è falsa, risulta S(b-1) vera Per il Passo Induttivo, se S(b-1) è vera allora anche S(b) è vera. Abbiamo una contraddizione con assunzione che S(b) falsa. Quindi l’ipotesi è sbagliata e non esiste un intero per cui l’affermazione è falsa.

CORRETTEZZA DI PROGRAMMI Dato un programma (o frammento di programma) si vuole mostrare che il risultato è quello desiderato.

CORRETTEZZA DI PROGRAMMI Invariante di ciclo: proprietà vera ad ogni iterazione; al termine del ciclo fornisce il risultato desiderato.

CORRETTEZZA DI PROGRAMMI Invariante di ciclo: proprietà vera ad ogni iterazione; al termine del ciclo fornisce il risultato desiderato. small=i j=i+1 Falso, ESCI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; j<n vero (3) Si vuole mostrare che al termine del ciclo for la variabile small è tale che A[small] contiene il min A[i..n-1] j++

CORRETTEZZA DI PROGRAMMI Invariante di ciclo: proprietà vera ad ogni iterazione; al termine del ciclo fornisce il risultato desiderato. small=i j=i+1 Falso, ESCI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; j<n vero (3) Si vuole mostrare che al termine del ciclo for la variabile small è tale che A[small] contiene il min A[i..n-1] j++ Invariante di ciclo. S(k): Se si raggiunge il test “j<n” con valore di j pari a k allora A[small] contiene il valore minimo in A[i..k-1].

CORRETTEZZA DI PROGRAMMI Invariante di ciclo: proprietà vera ad ogni iterazione; al termine del ciclo fornisce il risultato desiderato. small=i j=i+1 Falso, ESCI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; j<n vero (3) Si vuole mostrare che al termine del ciclo for la variabile small è tale che A[small] contiene il min A[i..n-1] j++ Invariante di ciclo. S(k): Se si raggiunge il test “j<n” con valore di j pari a k,1<k<n, allora A[small] contiene il valore minimo in A[i..k-1]. Si esce dal for con k=n. => S(n)

CORRETTEZZA DI PROGRAMMI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; /* small: indice min A[i..n-1]*/ small=i j=i+1 Falso j<n Invariante di ciclo. S(k): Se si raggiunge il test “j<n” con valore di j pari a k, 1<k<n, allora A[small] contiene il min di A[i..k-1]. vero (3) DIMOSTRAZIONE (per induzione su k). BASE. k=i+1. Abbiamo small=i; min A[i..k-1]=min A[i]=A[i]. A[small]=A[i]= min A[i..k-1]. Ok! j++

CORRETTEZZA DI PROGRAMMI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; /* small: indice min A[i..n-1]*/ small=i j=i+1 Falso j<n Invariante di ciclo. S(k): Se si raggiunge il test “j<n” con valore di j pari a k, 1<k<n, allora A[small] contiene il min A[i..k-1]. vero (3) PASSO Induttivo. Sia S(k-1) vera. Eseguiamo il ciclo con j pari a k-1. Distinguiamo 2 casi: Se A[k-1] > A[small], small invariata A[small]=min A[i..k-2]=min A[i..k-1] ok! j++

CORRETTEZZA DI PROGRAMMI small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; /* small: indice min A[i..n-1]*/ small=i j=i+1 Falso j<n 2) Se A[k-1] < A[small], Per ipotesi ind. A[small]=min A[i..k-2] Quindi A[k-1]< A[small]= min A[i..k-2] Otteniamo A[k-1]=min{A[k-1], min A[i..k-2] } = min A[i..k-1] Quando small è posto a k-1, A[small]=min A[i..k-1]. A questo punto j è incrementato a k e si ritorna al test con valore di j pari a k e Quindi S(k) è vera. OK! vero (3) j++

CORRETTEZZA DI PROGRAMMI S(k) vera per ogni k=i+1,…, n. small=i; for(j=i+1, j<n, j++) if (A[j]<A[small]) small=j; small=i j=i+1 Falso, ESCI Invariante di ciclo. S(k): Se si raggiunge il test “j<n” con valore di j pari a k, i+1<k<n, allora A[small] contiene il min. di A[i..k-1]. j<n vero (3) BASE + PASSO Ind.  S(k) vera per ogni k=i+1,…, n. j++ Correttezza ciclo: si esce dal ciclo quando si raggiunge il test “j<n” con valore di j pari a n. L’invariante S(n) per k=n ci dice che A[small] contiene il min. di A[i..n-1].

CORRETTEZZA del SelectionSort For (i=0,i<n-1,i++){ “small=indice min A[i..n-1]; scambia A[i] ed A[small;} Falso i<n-1 vero Si vuole mostrare la Correttezza del ciclo, cioè che quando si esce dal ciclo l’array A[0..n-1] è ordinato. (2), (3) i++ Invariante di ciclo. T(m): Se si raggiunge il test “i<n-1” con valore di i pari a m, 0<m<n-1, allora A[0..m-1] è ordinato Ogni elemento di A[0..m-1] è < ogni elemento di A[m..n-1].

CORRETTEZZA del SelectionSort For (i=0,i<n-1,i++) { “small=indice min A[i..n-1]; scambia A[i] ed A[small;ù } Invariante. T(m): Se si raggiunge il test “i<n-1” con i pari a m, 0<m<n-1, 1) A[0..m-1] è ordinato 2) Ogni elemento di A[0..m-1] è < ogni elemento di A[m..n-1]. T(n-1) vera  CORRETTEZZA DEL CICLO Quando si raggiunge il test con i pari a n-1 si esce dal ciclo. T(n-1) vera  1) A[0..n-2] è ordinato 2) Ogni elemento di A[0..n-2] è < A[n-1]. Quindi (A[0]<A[1] < … < A[n-2]) < A[n-1]  A[0..n-1] è ordinato

CORRETTEZZA del SelectionSort For (i=0,i<n-1,i++) { “small=indice min A[i..n-1]; scambia A[i] ed A[small;ù } Invariante. T(m): Se si raggiunge il test “i<n-1” con i pari a m, 0<m<n-1, 1) A[0..m-1] è ordinato 2) Ogni elemento di A[0..m-1] è < ogni elemento di A[m..n-1]. Mostriamo per induzione che T(m) vera per ogni m>0.

CORRETTEZZA del SelectionSort For (i=0,i<n-1,i++) { “small=indice min A[i..n-1]; scambia A[i] ed A[small;ù } Invariante. T(m): Se si raggiunge il test “i<n-1” con i pari a m, 0<m<n-1, 1) A[0..m-1] è ordinato 2) Ogni elemento di A[0..m-1] è < ogni elemento di A[m..n-1]. BASE. m=0. Array A[0..m-1] è vuoto, niente da provare

CORRETTEZZA del SelectionSort For (i=0,i<n-1,i++) { (2) “small=indice min A[i..n-1]; (3) scambia A[i] ed A[small]; } Invariante. T(m): Se si raggiunge il test “i<n-1” con i pari a m, 0<m<n-1, 1) A[0..m-1] è ordinato 2) Ogni elemento di A[0..m-1] è < ogni elemento di A[m..n-1]. PASSO. Ipotesi induttiva (i.i.):T(m) vera. Mostriamo T(m+1) vera. Eseguiamo (2) e (3) con i pari a m. Abbiamo (2)  A[small]=min A[m..n-1] (3)  A[m]=min A[m..n-1] Usando 1) e 2) in i.i. A[0]<A[1]<…<A[m-1]<A[m] Quindi A[0..m-1] ordinato  1) vale per m. Inoltre elemento A[m+1..n-1] > elemento A[0..m-1] A[m] Quindi elemento in A[m+1..n-1] > elemento in A[0..m]  2) vale per m.

CORRETTEZZA CICLI WHILE Possiamo nuovamente provare la correttezza per induzione sul numero di volte per cui il ciclo è stato eseguito. Però può non esistere variabile che conta numero di esecuzioni. Inoltre bisogna anche provare che il ciclo termina.

CORRETTEZZA CICLI WHILE Possiamo nuovamente provare la correttezza per induzione sul numero di volte per cui il ciclo è stato eseguito. Però può non esistere variabile che conta numero di esecuzioni. Inoltre bisogna anche provare che il ciclo termina. i=1; s=0; while (i<n) { s=s+i; i=i+1; } Si vuole provare che al termine del ciclo la variabile s contiene la somma dei primi n interi, cioè 1+2+…+n.

CORRETTEZZA CICLI WHILE s=0; while (i<n) { s=s+i; i=i+1; } Terminazione. Ad ogni iterazione la variabile i è incrementata di 1, quindi raggiungerà il valore n+1 ed il ciclo termina.

CORRETTEZZA CICLI WHILE s=0; while (i<n) { s=s+i; i=i+1; } Invariante di cilclo T(j):Se si raggiunge il test “i<n” con i pari a j allora il valore di s è pari alla somma dei primi j-1 interi. Base. j=1. Quando j=1 si ha s=0. Quindi T(0) vera. Passo. Assumiamo per i.i. che T(j) vera. Proviamo T(j+1) vera. Se i vale n+1 si esce dal ciclo, altrimenti iteriamo il ciclo Eseguendo il ciclo con i pari a j, il valore di s è incrementato di j. Usando l’i.i. s vale (1+…+j-1)+j =1+…+j Inoltre i viene incrementata a j+1. Quindi quando si arriva al test con i pari a j+1 s vale 1+…+j  T(j+1) vera.

CORRETTEZZA CICLI WHILE s=0; while (i<n) { s=s+i; i=i+1; } Invariante di cilclo T(j):Se si raggiunge il test “i<n” con i pari a j allora il valore di s è pari alla somma dei primi j-1 interi. Correttezza. Usciamo dal ciclo quando eseguiamo il test con i pari a n+1. T(n+1)  valore di s è pari alla somma dei primi n interi.