Ricerca lineare: elementi ripetuti

Transcript

1 Ricerca lineare: elementi ripetuti Ricerca lineare: elementi ripetuti II caso. Supponiamo che gli elementi di A non siano tutti distinti tra loro e che vogliamo conoscere dove si trova l elemento: dovremo allora determinare il valore di tutti gli indici i per i quali si ha: a i = b Analisi. Cosa dobbiamo cambiare nell algoritmo? Ricerca lineare: elementi ripetuti La struttura iterativa dovrà proseguire fino alla fine della sequenza e non interrompersi con il primo valore trovato. Pertanto la variabile trovato non sarà più necessaria e rimarrà unicamente la condizione di esaminare tutti gli elementi dell array: il ciclo while dovrà essere sostituito con un ciclo for. Inoltre abbiamo bisogno di memorizzare i valori degli indici: pertanto utilizziamo un array. Ricerca lineare: elementi ripetuti Chiamiamo posiz l array che conterrà i valori degli indici. L array sarà di tipo intero (memorizziamo indici di array) e avrà la stessa dimensione dell arraya (gli elementi potrebbero essere tutti uguali). Scriviamo una variante dell algoritmo di ricerca lineare. Alla definizione delle variabili si dovrà aggiungere la definizione di una variabile k, indice dell arrayposiz. Ricerca lineare: elementi ripetuti Quando si memorizza un valore nell array posiz (ogni volta che il confronto a[i]==b è vero), si dovrà incrementare l indice k. Dobbiamo anche dare una risposta al caso non trovato. Dal momento che non abbiamo più la variabile trovato, dovremo esprimere il significato di elemento non presente mediante un altra variabile. Ricerca lineare: elementi ripetuti La variabile k viene inizializzata a 0; pertanto se k non varia dal suo valore iniziale significa che l elemento non è presente. Vediamo ora il progetto dell algoritmo. Algoritmo ricerca2 definizione variabili: a[100], b intero posiz[100], k, n, i //acquisire e stampare valori per b, n e a intero 1

2 Ricerca lineare: elementi ripetuti k 0 per i da primo a ultimo eseguire se a[i] == b allora k k+1 posiz[k] i //finescelta //fineciclo se k==0 allora stampa elemento non presente altrimenti stampare i primi k valori dell array posiz: posiz[1],, posiz[k] //finescelta Ricerca lineare: elementi ripetuti Codifica e implementazione. Scegliere i valori per primo e ultimo: acquisire i dati iniziando con l indice 0 oppure 1. La struttura iterativa da usare è il ciclo for (coerente con i valori scelti per primo e ultimo). Ricerca lineare: elementi ripetuti Esercizio: tradurre in C++ il progetto di algoritmo e scegliere dei casi di prova significativi: elemento non presente (posiz è vuoto) elemento presente al primo e all ultimo posto elementi tutti uguali (posiz contiene tutti gli indici di a) elemento presente una, due, volte in posizioni alterne. Eseguire la verifica con valori noti. Ricerca lineare: array ordinato III caso. Supponiamo ora che gli elementi dell array siano ordinati. Vediamo come cambia l algoritmo di ricerca. Analisi. Essendo gli elementi ordinati, ha senso solo considerare il caso di elementi distinti (gli eventuali elementi ripetuti sarebbero consecutivi e non distribuiti nell array): a primo < < a i < a i+1 <. < a ultimo Ricerca lineare: array ordinato Per prima cosa si deve verificare se la ricerca è compatibile con i dati; ha senso eseguire la ricerca solo se: a primo b a ultimo La struttura iterativa, vista nel primo algoritmo, cambia nuovamente, per tenere conto di questa nuova ipotesi di dati ordinati. Ricerca lineare: array ordinato Dato l ordinamento, se si trova un valore dell indice i per il quale si ha b < a i allora è inutile proseguire. Esempio. b=7 a= (1, 3, 6, 9, 11, 23, 45, 56, 57, 70, 102) dopo il confronto con il valore 9, i successivi confronti sono inutili (le operazioni inutili non si devono eseguire). 2

3 Ricerca lineare: array ordinato Consideriamo l algoritmo ricercalineare: l iterazione aveva le due istruzioni passare al successivo confronto a[i] == b Tale iterazione viene così modificata: se a i < b allora passare al successivo altrimenti se a i == b allora trovato vero altrimenti non è più trovabile Ricerca lineare: array ordinato Nel caso in cui non sia più trovabile, dobbiamo interrompere la ricerca. Possiamo usare ancora una variabile booleana: stabiliamo che il suo valore è vero, se la ricerca è possibile, e il suo valore diventa falso se a i > b. Il predicato è composto: tre predicati uniti con and. Esercizio: codifica e implementazione. Esercizi sull uso di cicli e array Problema1. Dati n numeri (distinti oppure no) a 1, a 2, a n determinare quanti sono minori di a 1. Analisi. Dobbiamo esaminare tutti gli elementi a partire dal secondo e quando un elemento verifica la condizione: a[i] < a[1] allora si incrementa un contatore. Esercizi sull uso di cicli e array Codifica..... //acquisire e stampare a[1],... a[n] int cont =0; for(i = 2; i <= n; i++) if(a[i]<a[1]) cont++; //fine if e fine for cout<<"ci sono "<< cont << " numeri piu piccoli di " <<a[1]<<endl;.... Esercizi sull uso di cicli e array Casi di prova. 1. a 1 è il più piccolo cont = 0 2. a 1 è il più grande cont = n-1 3. caso medio con a 1 che compare 2, 3,.. volte 4. elementi tutti uguali ad a 1 cont = 0 Esercizio. Implementare l algoritmo eseguire i casi di prova; provare a sostituire < con <= e vedere se e come cambia il valore di cont. Esercizi sull uso di cicli e array Problema2. Dati n numeri a 1, a 2,, a n determinare quanti sono minori di a 1, a 2,, a n Analisi. Ripetiamo ciò che è stato fatto per a 1 anche per gli altri elementi: quindi avremo una struttura iterativa che esamina gli n elementi e al suo interno una struttura iterativa analoga a quella del Problema1. Avendo bisogno di vari contatori, uno per ogni elemento dell array a, conviene utilizzare un array di contatori (di tipo intero e con dimensione uguale a quella di a). 3

4 Esercizi sull uso di cicli e array Codifica. for(int k = 1; k <= n; k++){ //contare quanti sono minori di a[k] cont[k] =0; for(int i = 1; i <= n; i++) if(a[i]<a[k]) cont[k] = cont[k]+1; //fine if }//fine for esterno //ciclo di stampa: ci sono << cont[i] << numeri piu piccoli di << a[i]; //i = k confronto inutile, ma conviene... Esercizi sull uso di cicli e array Casi di prova. 1. elementi distinti in ordine crescente il valore dei contatori sarà: 0,1, 2,, n-1 2. elementi distinti in ordine decrescente il valore dei contatori sarà: n-1, n-2,, 0 3. elementi tutti uguali tra loro e minori di un a i 4. caso medio con valori diversi Esercizio. Implementare l algoritmo eseguire i casi di prova; provare a sostituire < con <=. Complessità degli algoritmi L'efficienza di un algoritmo si valuta in base all'utilizzo che l'algoritmo fa delle risorse del calcolatore: CPU Memoria tempo spazio Algoritmi diversi, pur occupando lo stesso spazio, possono richiedere tempi diversi: due algoritmi richiedono l utilizzo di un array, ma uno richiede la scansione di tutto l array, e impiega un tempo t 1, l altro richiede la scansione solo di una parte dell array, e impiega un tempo t 2 <t 1. Si preferisce valutare l'efficienza in base al tempo impiegato per risolvere il problema. Come si può misurare il tempo impiegato dall algoritmo? Con un cronometro? Ogni linguaggio ammette delle funzioni per calcolare il tempo: in alcuni si accede ad un orologio della macchina; spesso viene fornito un tempo calcolato in secondi o millisecondi e viene indicato il tempo trascorso a partire da una data fissa. (Cap. 5) In questo caso per calcolare il tempo si effettuano due successive chiamate della funzione tempo e si fa la differenza tra le due misure di tempo ottenute. È una buona misurazione? Lo è solo in parte; non lo è in senso assoluto. 4

5 Infatti il tempo misurato in tale modo dipende: dal calcolatore usato dal linguaggio usato dai dati che sono elaborati in quel momento. Non ha perciò senso dire che l algoritmo di ricerca impiega 10 sec. ; il tempo dipende anche da fattori estranei all algoritmo. Se vogliamo confrontare algoritmi che risolvono lo stesso problema misurando il tempo che impiegano, dovremo: usare la stessa macchina usare lo stesso linguaggio usare gli stessi dati. Si potrà costruire un array di dati abbastanza grande; tale vettore sarà l unico ingresso per confrontare algoritmi che risolvono quel problema in prove eseguite sullo stesso calcolatore e con lo stesso linguaggio. Come possiamo stimare il tempo per l algoritmo in modo da avere una misura assoluta, vale a dire, una misura che dipenda solo dall algoritmo? Osserviamo che il tempo di esecuzione è una funzione crescente della dimensione dei dati di ingresso. Esempio. Sommare n numeri dove n può assumere i valori n = 10, 1000, Il tempo per calcolare la somma aumenta con n n + T(n) + Non per tutti gli algoritmi è così: nell algoritmo che calcola il massimo tra due numeri, in quello che calcola l area del trapezio, nell algoritmo che esegue delle prove sul troncamento della divisione tra interi, i dati di ingresso sono una quantità fissa e non variano di dimensione. Nel calcolo della somma e del massimo su n dati, nell algoritmo di ricerca, andiamo ad acquisire il valore di n e gli n valori dell array: la dimensione dei dati varia con n. Osserviamo che il numero dei dati di ingresso fa variare il numero di operazioni: n = 10 l algoritmo esegue 10 somme n = l algoritmo esegue somme Si chiama complessità computazionale la funzione F(n) che calcola il numero di operazioni eseguite dall algoritmo: n N dimensione dei dati di ingresso F(n) numero di operazioni n + F(n) + Ha interesse sapere come la funzione F(n) cresce, vale a dire quale è il suo ordine di infinito. 5

6 Confrontiamo le due funzioni y = x e y = x 2 osservando i valori che assumono per x = 5, 10, 100 x y = x y = x intuiamo che y=x 2 tende a + più rapidamente di y=x; y=x 2 ha un ordine di infinito maggiore di y=x. Quali sono le operazioni che un algoritmo esegue? operazioni elementari assegnazioni (accesso e assegnamento) confronti lettura/scrittura invocazione di funzioni (passaggio parametri e gruppi di istruzioni all interno della funzione) strutture di controllo Dobbiamo sommare i tempi delle varie istruzioni, in tale modo troviamo il tempo totale. Si valuta un tempo t a (assegnazione) e t c (confronto) indipendentemente dalla semplicità o meno dell espressione. Non dobbiamo però essere così possiamo fare delle semplificazioni. Le operazioni fondamentali sono: confronti e assegnazioni precisi: Si può anche calcolare il numero di accessi eseguiti per alcune variabili fondamentali nell algoritmo: contare quante volte la variabile compare in un confronto o in un assegnazione. Assegnazione. 1) a = 25; 2) a = sqrt(3*sin(x) + cos(y)/7); Queste due assegnazioni necessitano di due tempi diversi e sicuramente sarà: t 1 < t 2 perché l espressione 2) richiede più calcoli. Indichiamo con t a assegnazione. il tempo per una Sequenza di assegnazioni. <a 1 > <a 2 > k costante. <a k > non dipende da n il numero di istruzioni Sommiamo i tempi: k t a ~ t a k non dipende da n Se abbiamo due funzioni F 1 (n) F 2 (n) con lo stesso ordine di infinito, può essere importante stimare anche il valore di k. 6

7 Struttura condizionale. se P allora <a1> altrimenti <a2> //finese <a1> e <a2> rappresentano gruppi di istruzioni Il predicato P potrà essere: 1) a<b 2) (a<b) o (non S) e ((a==c) o (c!=h) Certamente si avrà t 1 < t 2 ma consideriamo t p il tempo per valutare un predicato. Avremo t p + t a1 t p + t a2 Se <a1> e <a2> non dipendono da n (sequenza di istruzioni) t p + t a1 ~ t p + t a2 ~ t p abbiamo un numero costante di operazioni, come nell algoritmo del max(a,b). Quali sono le strutture che variano con n? Quando eseguiamo una scansione di un array (lettura, stampa, somma, ricerca, ) consideriamo un numero n (n>0) di dati di ingresso. Struttura iterativa. Consideriamo un ciclo con incremento fisso e passo 1: per i da 1 a n eseguire iterazione //indipendente da n //fineper Indichiamo con t p il tempo per il predicato e con t i il tempo per l'iterazione (per ora indipendente da n): Avremo: t p : eseguito n+1 volte (n volte con P vero, 1 volta con P falso) t i : eseguito n volte (n+1) t p + n t i ~ n c c = costante: costo dell'iterazione: (n+1) t p + n t i = n t p + t p + n t i n t p + n t p + n t i = 2n t p + n t i = n ( 2 t p + t i ) = n c (n > 0 quindi n 1) Cosa cambia se anche l iterazione dipende da n? Supponiamo che l iterazione sia un ciclo dello stesso tipo, che viene eseguito n volte: 1. per i da 1 a n eseguire 2. per k da 1 a n eseguire iterazione //fineper //fineper (n+1) t p1 + ((n+1) t p2 + n t i ) n = = (n+1) t p1 + ((n+1) t p2 ) n + n 2 t i 2n t p1 + 2n t p2 n + n 2 t i n 2 (2 t p1 + 2 t p2 + t i ) = n 2 c avendo considerato: n+1 2n, 2n 2n 2 con n naturale (positivo) c= costante : costo dell'iterazione 7

8 Consideriamo delle funzioni di riferimento e calcoliamo la complessità degli algoritmi confrontandola con queste funzioni. y = log x y = x y = x log x y = x 2 y = 2 x y = e x y = x 2 e y = 2 x si incontrano per x=2 e x=4 Notazione O (o-grande), Ω, Θ. Ci interessa sapere come cresce F(n) al crescere di n, sempre nell ipotesi che F(n) + quando n + Sia f(n) la funzione di complessità che cerchiamo. Si dice che f(n) è O(g(n)) se c, n 0 > 0 n n 0 f(n) c g(n) Come ordine di infinito f non cresce più di g. Se f(n) = O(g(n)) significa che g(n) è una limitazione superiore per f(n): il calcolo esatto di f(n) è troppo complicato e ci limitiamo a stimarne una limitazione superiore. Esempio. n 2 + n è O(n 2 ) infatti: n 2 + n n 2 + n 2 = 2 n 2 Sia f(n) la funzione di complessità che cerchiamo. Si dice che f(n) è Ω(g(n)) se c, n 0 > 0 n n 0 c g(n) f(n) Come ordine di infinito f cresce almeno quanto g; g(n) è una limitazione inferiore per f(n). Esempio. n 2 + n è Ω(n) infatti: 2n = n + n n 2 + n Sia f(n) la funzione di complessità che cerchiamo. Si dice che f(n) èθ(g(n)) se c 1, c 2, n 0 > 0 n n 0 c 1 g(n) f(n) c 2 g(n) Come ordine di infinito f cresce quanto g. Esempio. n 2, 1000 n 2, 1/100 n 2 sono tutte Θ(n 2 ) varia solo la costante moltiplicativa. 8

9 Classi di complessità Quando scriviamo un algoritmo, vogliamo stimare la sua complessità cercando di individuare la funzione g(n) che approssima f(n). In tale modo gli algoritmi vengono suddivisi in classi di complessità: costanti k (non dipendono da n) logaritmo log n, log 2 n lineari n n log n polinomiali n k k = 2, 3, esponenziali n!, a n, n n a 0, 1 Casi di prova per stimare la complessità Quando si scrive un algoritmo si deve sempre dare una stima della limitazione superiore. È opportuno dare una stima della limitazione inferiore e sarebbe importante stimare anche un comportamento medio tra le due stime, ma questo spesso è difficile. O(g) limitazione superiore: sono richieste al più g(n) operazioni Ω(g) limitazione inferiore: sono richieste almeno g(n) operazioni. Casi di prova per stimare la complessità Casi di prova. Caso peggiore: i dati sui quali l algoritmo richiede il massimo numero di operazioni. Caso favorevole: i dati sui quali l algoritmo richiede il minor numero di operazioni. Caso medio: i dati che richiedono un numero medio di operazioni. Nel calcolo della complessità non si considerano i cicli per acquisire i dati: sono uguali per tutti gli algoritmi e sono Θ(n). ricerca lineare Caso I: elementi distinti. i 0 trovato falso mentre i n e non trovato eseguire i i+1 se a[i] == b allora trovato vero //fine //fine se trovato allora stampa trovato al posto i altrimenti stampa elemento non presente //fine ricerca lineare Caso favorevole. Si ha quando a[1] = b: primo elemento dell array: 2t a + t p + t a + t c + t a + t p + t c + t stampa inizio V i i+1 a[i] == b trovato F se risultato la funzione non dipende da n, quindi è costante: Ω(1) è il caso con il minimo numero di operazioni. ricerca lineare Caso peggiore. Si ha quando il ciclo viene eseguito fino in fondo. 1) l elemento non c è: 2t a + (n+1) t p + nt a + nt c + t c + t stampa inizio predicato i i+1 a[i] == b se risultato la funzione è del tipo c n, quindi O(n). 9

10 ricerca lineare 2) l elemento c è ed è l ultimo: a[n] = b 2t a + (n+1) t p + nt a + nt c + t a + t c + t stampa inizio predicato i i+1 a[i] == b trovato se risultato la funzione è del tipo c n, quindi O(n). Il massimo numero di operazioni è dato da una funzione lineare. ricerca lineare Caso II: elementi ripetuti. k 0 per i da 1 a n eseguire se a[i] == b allora k k+1 posiz[k] i //finescelta //fineciclo se k==0 allora stampa elemento non presente altrimenti stampare i primi k valori dell array posiz: posiz[1],, posiz[k] ricerca lineare La struttura iterativa for ( per ) viene eseguita sempre completamente. Caso peggiore. Gli elementi sono tutti uguali a b: ogni volta si assegna un valore a posiz t a + (n+1)t p + nt c + 2nt a + t c + t stampa O(n) Caso favorevole. L elemento non c è: il numero di assegnazioni è 0 t a + (n+1)t p + nt c + t c + t stampa Ω(n) Pertanto la complessità è: Θ(n) ricerca lineare Caso III. Ricerca su dati ordinati. La complessità è: Ω(1) nel caso favorevole (primo elemento) ed è O(n) nel caso peggiore (ultimo o mancante). Esercizio. Dimostrare l affermazione precedente. Con un array ordinato si ha anche un altro algoritmo che non esamina tutti gli elementi. Ricerca binaria (dicotomica) Supponiamo di cercare un nome in un elenco ordinato di nomi: vocabolario, elenco telefonico. Sfruttiamo l ordine lessicografico (alfabetico) e incominciamo a dividere l elenco in due parti pensando alla iniziale del nome, poi alla lettera successiva,... non iniziamo dalla prima parola dell elenco se cerchiamo un nome che inizia per M. Analogamente se pensiamo dei numeri appartenenti ad un intervallo sulla retta. Ricerca binaria (dicotomica) Analisi. Consideriamo l array a = (a 1, a 2, a n ) a 1 a im a n con im = (1+n)/2 indice di mezzo Esaminiamo a im : se b = a im allora abbiamo trovato l elemento, altrimenti vediamo se risulta b<a im oppure b>a im e proseguiamo la ricerca solo nella parte possibile. 10

11 Ricerca binaria (dicotomica) Caso b < a im Gli elementi di destra non si guardano a 1 b a im a n Caso b > a im Gli elementi di sinistra non si guardano a 1 a im b a n Ricerca binaria (dicotomica) Indichiamo con is e id gli estremi della parte di array che stiamo guardando: a is b a id. Tali valori vengono inizializzati con i valori della prima e dell ultima componente (prima =0,1; ultima = n-1, n). Si confronta b con a im e se risulta a im b cambiamo il valore degli estremi is e id; questo è il modo per non guardare più una parte di array: se b < a im cambierà id se b > a im cambierà is Perciò il valore di id diminuisce e quello di is aumenta: per proseguire la ricerca dovrà essere sempre is id. Ricerca binaria (dicotomica) Vediamo con un esempio che questo meccanismo funziona : a = ( 1, 5, 6, 8, 11, 15) n = 6 b = 5 1) is = 1 id = 6 im = (1+6)/2 = 7/2 = 3 a im = a 3 = 6 e 6 5 a im > b id varia e assume il valore im-1: id=2 2) is = 1 id = 2 im = (1+2)/2 = 3/2 = 1 a im = a 1 = 1 e 1 5 a im < b is varia e assume il valore im+1: is=2 3) a im = a 2 = 5 e 5=5 trovato= vero Ricerca binaria (dicotomica) Algoritmo ricerca binaria definizione variabili a array, b intero n, is, id, im intero trovato logico acquisire e stampare n, a, b se a[1] <= b e b <= a[n] allora //eseguire la ricerca is 1 id n trovato falso Ricerca binaria (dicotomica) mentre non trovato e is <= id eseguire im (is+id)/2 se a[im] == b allora trovato vero altrimenti //scegliere dove proseguire se b < a[im] allora id im-1 altrimenti is im+1 //finese //finese //finementre Ricerca binaria (dicotomica) se trovato allora stampa trovato al posto im altrimenti non trovato //finese altrimenti stampa b è esterno ad a //finese //fine algoritmo Calcoliamo la complessità di questo algoritmo. 11

12 ricerca binaria Il primo confronto a[1] <= b e b <= a[n] viene eseguito per verificare se è oppure no possibile eseguire la ricerca: nel caso in cui questo predicato fosse falso, non si esegue l algoritmo. Questo non viene considerato come caso favorevole, perché di fatto l algoritmo non inizia nemmeno. ricerca binaria Caso favorevole. L elemento viene trovato con un solo confronto; ma non è il primo elemento, è quello centrale: b = a[(1+n)/2] 3t a + t p + t a + t c + t a + t p + t c + t stampe a[im]==b trovato se numero costante di operazioni: Ω(1) ricerca binaria Caso peggiore. Si esegue l iterazione il massimo numero di volte quando: l elemento o è l ultimo guardato oppure non è presente. Quante operazioni ci sono nel ciclo? t a + t c + t c + t a numero costante a[im]==b a[im]>b is o id Quante iterazioni? Facciamo una stima del numero di iterazioni eseguite valutando quanti elementi restano ad ogni divisione dell array (gli elementi sono in numero finito). ricerca binaria Supponiamo che n = 2 k 1 a iterazione restano 2 k-1 elementi 2 a iterazione restano 2 k-2 elementi 3 a iterazione restano 2 k-3 elementi.. k-esima iterazione restano 2 k-k = 1 elementi: is=id (k+1)-esima iterazione: se l elemento è presente trovato diventa vero, altrimenti trovato è falso e is>id: il ciclo termina: O(k) con k = log 2 n : O(log 2 n) Si può dimostrare anche per valori di n qualunque (2 k-1 n 2 k ). Casi di prova Casi di prova Quando si vuole testare un algoritmo si devono costruire vari casi di prova. Invece di eseguire il programma più volte si può costruire un file di dati contenente tutti i casi che si vogliono provare. Esempio. Supponiamo di voler provare un algoritmo di ricerca: l array sarà uno solo e i casi di prova saranno costituiti da diversi valori di b (esterno, presente, presente più volte, ecc.) 12

13 Casi di prova Lo schema del programma sarà perciò del tipo: //acquisire e stampare l array //acquisire la quantità dei casi di prova: // numprove for(int k = 1; k <= numprove; k++){ //acquisire l elemento b da cercare //chiamare il metodo di ricerca //stampa risultati cout<< prova numero <<k << elemento cercato = <<b<<endl; } Casi di prova Il file dei dati avrà pertanto la seguente organizzazione: il valore di n e gli n elementi per l array il valore di numprove gli elementi da cercare (tanti quanto è il valore di numprove) Il programma viene eseguito una sola volta e produce i vari risultati dell esecuzione dell algoritmo, ottenuti con i diversi valori da cercare. Stringhe Stringhe Una costante stringa è rappresentata da un gruppo di caratteri racchiuso tra virgolette: "ciao a tutti" "a = " "123" Per definire in C++ una variabile di tipo stringa si definisce un array di caratteri: char nome[15]; Le stringhe possono anche essere considerate come una unità, oltre che un insieme di caratteri, e il C++ possiede delle funzioni particolari per gestire stringhe. Stringhe Una stringa possiede un carattere di terminazione, indicato con \0, che indica la fine della stringa; questo rappresenta il carattere null del codice ASCII (il primo carattere di posto 0). Consideriamo la stringa "ciao" Essa è composta da 4 caratteri più il carattere di terminazione e pertanto se vogliamo memorizzarne il valore in una variabile di nome saluto dobbiamo scrivere: char saluto[5]="ciao"; Consideriamo: Stringhe char vuota [1] = ""; cout<<"la stringa vuota ha lunghezza" <<strlen(vuota); //0 char elem [2] = "a"; cout<<"la stringa elem ha lunghezza" <<strlen(elem); //1 La dimensione dell array è la lunghezza +1 13

14 Stringhe Abbiamo utilizzato la funzione strlen(nomestringa) Questa funzione ha per argomento la stringa e restituisce un intero che rappresenta il numero di caratteri che compongono la stringa. Per poter utilizzare tale funzione si deve inserire il file di intestazione string.h : #include <string.h> Confrontare stringhe Abbiamo visto che per confrontare numeri interi si usa l operatore di uguaglianza ==. Abbiamo visto che anche i numeri reali si possono confrontare con lo stesso operatore == ma che a volte è preferibile usare un confronto del tipo fabs(a-b) < epsilon (con epsilon=10 -n e n compatibile con la precisione float o double), dato che i reali sono rappresentati in maniera approssimata. Confrontare stringhe Per confrontare stringhe si utilizza la funzione strcmp(stringa1,stringa2) che restituisce un valore intero: >0 se s1 segue s2 strcmp(s1, s2) =0 se s1 è uguale s2 <0 se s1 precede s2 Confrontare stringhe Pertanto, date le stringhe s1 e s2 : if(strcmp(s1,s2) > 0) //s1 è più grande di s2: s1 segue if(strcmp(s1,s2) < 0) //s1 è più piccola di s2: s1 precede if(strcmp(s1,s2) == 0) //s1 è uguale a s2 Confrontare stringhe Si effettua un confronto lessicografico secondo l ordine dei caratteri ASCII. Il confronto procede a partire dal primo carattere delle stringhe confrontando a due a due i caratteri nelle posizioni corrispondenti, finché una delle stringhe termina oppure due caratteri sono diversi: se una stringa termina, essa precede l altra se terminano entrambe, o sono uguali (ultimo) oppure, l ordinamento tra le due stringhe è uguale all ordinamento alfabetico tra i due caratteri diversi. Confrontare stringhe c a r t o l i n a c a r t o l a i o c a r t a c a r car < carta < cartolaio < cartolina < cartoline 14

15 Confrontare stringhe Il confronto lessicografico genera un ordinamento simile a quello di un dizionario: infatti l ordinamento tra caratteri ASCII è diverso perché tra i caratteri non ci sono solo le lettere, ed inoltre: i numeri precedono le lettere tutte le lettere maiuscole precedono tutte le lettere minuscole il carattere di spazio precede tutti gli altri caratteri. 15