Scarica Appunti e funzioni su liste ed array e più Appunti in PDF di Programmazione C solo su Docsity!
PROCEDURA CHE LEGGE
DALL’ESTERNO I VALORI DELL’ARRAY.
#include <stdio.h>
int lettura (int a[], int dim)
Int i;
for (i=0, i<dim,i++)
scanf
(“%d”,&a[i]);
main()
Int a[5];
int b[10];
lettura (a,5);
lettura (b,10);
SCRIVI UNA FUNZIONE CHE
RESTITUISCA LA SOMMA DI TUTTI GLI
ELEMENTI DI UN ARRAY DI INTERI.
int somma ( int a[], int dim)
int i ; int s=0 ;
//var s salva di volta in
volta la somma parziale
for (i=0; i<dim; i++)
s=s+a[i];
return s;
SCRIVI UNA FUNZIONE CHE VALE VERO
SE L’ARRAY È ORDINATO IN SENSO
CRESCENTE, FALSO ALTRIMENTI.
In C non è predefinito il tipo di variabile
booleano ={true, false}. Lo possiamo
riprodurre utilizzando una variabile di tipo
int con la convenzione che 0 valga false e
1 valga true.
int crescente (int a[],int
dim)
int i; int ok=1;
while (i<dim-1 && ok)
if(a[i]<a[i+1]) i++;
else ok=0;
return ok;
INTERPRETAZIONE AND LOGICO &&
● Classica: si valutano gli operandi e
se sono entrambi vero il risultato è
TRUE altrimenti FALSE
● Condizionale: se il primo operando
è falso il secondo non viene
nemmeno valutato in quanto
l’intera espressione risulterebbe
falsa. Il C adotta questa
interpretazione
SCRIVERE UNA FUNZIONE CHE VALE
VERO SE UN ELEMENTO DATO COME
ARGOMENTO APPARTIENE AD UN
ARRAY
int member (int a[], int dim,
int el)
int i=0; int trovato=0;
/*la variabile trovato
diventa 1
se individuo el nell’array.
Appena ciò avviene il ciclo
deve terminare (iteraz.
indeterm.) */
while (trovato==0 && i<dim-1)
if(a[i]==el) trovato=1;
else i++;
return trovato;
Il nome delle variabili per chiarezza del
lettore deve essere significativo. In
programmi di grandi dimensioni il nome
delle variabili deve dare un’immediata
conoscenze del significato di esse.
SCRIVERE UNA FUNZIONE CHE
VERIFICHI SE UN ARRAY HA TUTTI
VALORI DISTINTI
/* sfrutto la possibilità di
chiamare una funzione
precedentemente definita in
un’altra funzione. uso la
funzione member prec. creata
con la modifica che la ricerca
del valore avviene tra due
indici passati come
parametro*/
int member1 (int el, int a[],
int inizio, int fine)
int i=inizio; int trovato=0;
while (i<fine && !trovato)
if(a[i]==el) trovato=1;
else i++;
return trovato;
/*La funzione determina un
“esistenziale”*/
int distinti (int a[],int dim)
int i=0; int ok=1; //suppongo
elem tutti diversi
while (i<dim-1 && ok)
if (member1(a[i],a,i+1,dim))
ok=0; else i++;
return ok;
/*L’elemento da cercare sarà
il valore contenuto all’indice
i e sarà cercato a partire
dall’elemento successivo,
ovvero quello di indice i+1.
Se la funzione member
restituirà 1 significa che
l’elemento cercato si trova
tra i valori successivi nel
vettore e quindi il ciclo deve
terminare perchè ho verificato
che ci sono valori duplicati*/
OPPURE
int distinti (int a[], int
dim)
int i=0; int ok=1;
while (i<dim && ok)
int j=i+1;
int trovato=0;
while (j<dim-1 &&
!trovato)
if(a[i]==a[j]
trovato=1;
else j++;
if (trovato==1) ok=0;
else i++;
return ok;
DATO UN ARRAY SCRIVERE UNA
FUNZIONE CHE È VERA SE ESISTE UN
ELEMENTO MINORE DEL SUO
SUCCESSIVO.
int b[5];
int controllo;
if(verifica(a,b,10,5))
printf(“Esiste almeno un
elemento che compare in
entrambi i vettori”); else
printf (“Nessun elemento
uguale”);
return;
PROCEDURA CHE ORDINA I VALORI DI UN ARRAY (Algoritmo Bubble Sort)
#include <stdio.h> void swap (int* a, int* b) { int temp=*b; b=a; *a=temp; } void bubble (int a[ ],int fine) { //porto il più grande in fondo int i; for (i=0;i<fine;i++) if (a[i]>a[i+1]) swap(&a[i],&a[i+1]); } void sort(int a[ ],int dim) { int i; for (i=dim; i>1; i--) bubble(a,i); }
FUNZIONE CHE RESTITUISCE L’INDICE DELLA PRIMA OCCORRENZA DEL VALORE
MASSIMO IN UN ARRAY
int indicemax (int a[ ], int dim) { int i, max=a[0], index=-1; for (i=1; i<dim; i++) if(a[i]>max) { max=a[i]; index=i; } return index; //Avessi messo >= avrei trovato l’indice dell’ultima occ. }
int stesseoccorrenze( int a[ ],int b[ ],int dim) { int i=0,ok=1; while (i<dim && ok) if (conta(a[i],a,dim)==conta(a[i],b,dim) i++; else ok=0; return ok; }
LE STRUTTURE DINAMICHE IN C
Una struttura dinamica è una struttura dati che può modificare la sua dimensione
durante l’esecuzione del programma. La struttura dato ARRAY/MATRICE è una
struttura statica mentre una struttura dinamica è rappresentata dalla LISTA. La
LISTA è una struttura omogenea (tutti gli elementi sono dello stesso tipo)
dinamica (posso aggiungere e togliere elementi).
Le strutture dinamiche non possono essere gestite sulla memoria a pila infatti
vengono gestite su una memoria dinamica detta HEAP.
Per capire come vengono trattate le strutture dinamiche, dobbiamo aggiungere
allo stato astratto ambiente-memoria, la memoria Heap. In concreto una parte
della memoria del calcolatore a disposizione del programma in esecuzione viene
gestita come una pila di frame mentre una parte come memoria dinamica. La
memoria dinamica è indipendente dalla gestione a blocchi e viene allocata
(riservata) e deallocata (liberata) in modo esplicito, cioè attraverso funzioni e
procedure predefinite. La memoria dinamica è gestita come una sequenza di
parole di memoria senza struttura.
Allocazione Esplicita
Funzione malloc () che ha per argomento lo spazio da allocare in memoria heap e
che restituisce l’indirizzo della prima parola di memoria riservata. Per effettuare
l’allocazione dobbiamo sapere prima quanto spazio necessitiamo per quel tipo di
struttura, per questo ci serviamo della funzione Sizeof() che, dato per parametro
un tipo, ci restituisce lo spazio che occupa in memoria un oggetto del tipo
passato.
In C è presente un costruttore di tipo, che permette di definire nuovi tipi a partire
da tipi conosciuti, che si chiama Struct. La struct permette di prendere oggetti di
tipo diverso e di costruire con essi un nuovo tipo.
Es. struct el { int a; int b; float c; } main() { struct el* p; struct el x; p=malloc(Sizeof(struct el)); //malloc restituisce indirizzo x.a=18; x.c=7.61; // Notazione x.a significa //l’elemento di nome a della //struttura associata ad x }
Alla chiusura del blocco main si effettua un pop su ambiente e memoria mentre
la mem H rimane riservata perché indipendente dalla gestione a blocchi. La
parola di memoria Hn rimane riservata e quindi non accessibile; si definisce
infatti “garbage” perché non più liberabile se si è perso il puntatore a quella
parola di memoria.
COME COSTRUIRE UNA LISTA CON UNA PROCEDURA
typedef struct edl { int info; struct edl* next; }edl; //elemento di lista void crealista(int n,edl*l) { l=NULL;//Creo la lista vuota int i; edl corr; if (n>0) { l=malloc(sizeof(edl)); (l)->info=1; corr=(l); //definisco l’elemento corrente for (i=2; i<=n;i++) { corr->next=malloc(sizeof(edl)); corr=corr->next; corr->info=i oppure scanf(“%d”,&corr->info) } corr->next=NULL;//per chiudere la lista } }
AGGIUNGERE AD UNA LISTA UN ELEMENTO V DOPO LA PRIMA OCCORRENZA DEL
VALORE EL. SE NON ESISTE LA LISTA RIMANE INVARIATA.
void addafter(edll,int v,int el) { int trovato=0; edl corr=l; while(!trovato && corr!=null) /Metto corr diverso da null perchè se scrivessi corr->next!=null non mi considererebbe l’ultimo elemento della lista/ { if(corr->info==el) trovato=1; else corr=corr->next; if (trovato) { edl* aus; aus=malloc(sizeof(edl); aus->info=v;
aus->next=corr->next corr->next=aus; } } }
AGGIUNGERE UN NUOVO EDL CONTENENTE V AD UNA LISTA PRIMA DELLA PRIMA
OCCORRENZA DEL VALORE EL
void addbefore(edl** l,int v,int el){ { int trovato=0; edl* prec=NULL;//puntatore all’elemento precedente edl* corr=l;//puntatore elemento corrente while(!trovato && corr!=NULL) { if(corr->info==el)trovato=1; else { prec=corr; //no prec=prec->next perchè inizializzato a NULL corr=corr->next; } if (trovato) { edl aus; aus=malloc(sizeof(edl)); aus->info=v; //Devo distinguere se attaccare in testa o no if(prec==NULL)//Primo elemento { aus->next=*l; *l=aus; } else { aus->next=corr; prec->next=aus; } } }
