LE STRUTTURE DATI DINAMICHE

Transcript

1 LE TRUTTURE DTI DIMICHE Talvolta è necessario allocare spazio di memoria durante l esecuzione di un programma oppure creare variabili di durata temporanea. Esempio: Leggere e memorizzare dei numeri interi inseriti da tastiera finché non si inserisce lo 0. Esiste una zona di memoria riservata a cui è possibile accedere per allocare dati durante l esecuzione del programma. avviene tra mite uso di puntatori ed è eseguita da apposite funzioni contenute nella libreria standard stdlib.h. void *malloc(int n); Le variabili statiche e dinamiche sono memorizzate in zone di memoria differenti. lloca dinamicamente una zona di memoria pari a n byte e restituisce un puntatore a void che punta alla zona di memoria allocata, contenente un tipo di indefinito. avviene tramite uso di puntatori ed è eseguita da apposite funzioni. void *calloc(int n, int dim); lloca dinamicamente una zona di memoria pari a n*dim, adatta a contenere n variabili ampie dim e la inizializza a 0. Restituisce un puntatore a void che punta alla zona di memoria allocata, contenente un tipo di indefinito. avviene tramite uso di puntatori ed è eseguita da apposite funzioni. void *realloc(void *p, int n); lloca dinamicamente una zona di memoria pari a n byte e vi colloca il contenuto della zona di memoria puntata da p, tagliando l eventuale eccesso in caso di spazio insufficiente. Restituisce p o un nuovo puntatore a void, in caso debba essere usata una nuova zona di memoria. 1

2 TTEZIOE: Tutte le funzioni che consentono l allocazione dinamica restituiscono un puntatore in caso di allocazione non riuscita (memoria insufficiente o altro tipo di errore). Questa eventualità deve essere gestita per non incorrere in errori. Due funzioni utili La funzione sizeof(tipo_) Riceve un tipo di e ne restituisce la dimensione espressa in byte. La funzione typedef oggetto nome ssegna un alias all oggetto, che da uel momento può essere invocato attraverso nome. Esempi: lloca dinamicamente int *p; una zona di memoria p=(int *)malloc(sizeof(int)); pari alla dimensione di un intero e la fa puntare *p=28; da p. char *p; lloca dinamicamente una p=(char *)malloc(80); zona di memoria pari ad 80 p= albero ; byte (cioè 80 caratteri). Esempi: struct studente {char nome[80]; int ;} *p; p=(struct studente*)malloc(sizeof(struct studente)); lloca dinamicamente una zona di memoria pari alla dimensione di una struttura di tipo studente e la fa puntare da p. Esempi: struct studente {char nome[80]; int ;}; typedef struct studente st; st *p; p=(st *)malloc(sizeof(st)); La de-allocazione La memoria allocata dinamicamente persiste fino al termine del programma o finché non viene esplicitamente liberata dal programmatore. E possibile liberare lo spazio di memoria precedentemente allocato dinamicamente attraverso la funzione free (p); dove p è stato precedentemente allocato attraverso malloc, calloc o realloc. 2

3 Le strutture dati dinamiche ono strutture dati che possono variare la loro dimensione durante l esecuzione del programma e possono contenere dati eterogenei. In uesto corso studieremo: Le liste concatenate Le pile Le code Le liste concatenate ono seuenze lineari (messe in fila indiana) di unità di informazione (strutture ricorsive), in cui inserimenti e cancellazioni possono avvenire in ualunue punto della lista. Le strutture ricorsive ono strutture contenenti un puntatore ad oggetto dello stesso tipo. Intero Le liste concatenate Ogni elemento della lista è detto nodo e si crea al bisogno, mediante allocazione dinamica. I puntatori sono detti link. E necessario avere un puntatore t al primo nodo che indichi l della lista e che non venga spostato, altrimenti si perde la possibilità di accedere ai dati. E opportuno porre a il puntatore dell ultimo elemento in modo da segnalare la fine della lista. Intero Intero Intero ssegnazione valori ad un nodo Dopo avere creato il nodo desiderato, si procede come nelle strutture accedute mediante puntatori. struct referendum{char ; struct referendum *;}*p, *; typedef struct referendum r; p=(r*)malloc(sizeof(r)); p->= ; p->=; =p; p postarsi in una lista postarsi di un elemento p=; i usa un puntatore ausiliario per evitare di p=p->; perdere l della lista. correre l intera lista p=; while(p) p=p->; Modifica valori di un nodo Dopo avere individuato il nodo desiderato, si procede come nelle strutture accedute mediante puntatori. E necessario usare un puntatore ausiliario che scorra la lista fino a posizionarsi ii inel nodo desiderato. Esempio: p=; p=p->; p->= ; p p In alternativa è possibile assegnare i valori dei dati tramite scanf o copia di valori contenuti in altri dati. 3

4 Visualizzazione valori di un nodo Dopo avere individuato il nodo desiderato, mediante l uso di un puntatore ausiliario, si procede come nelle strutture accedute mediante puntatori. Esempio: p=; p=p ; printf( %c, p->); p p Visualizzazione di una intera lista #include<stdio.h> #include<stdlib.h> TTEZIOE: Il puntatore ini è una variabile locale. L della lista non viene spostato typedef struct elemento ele; agendo su ini. i voidstampa(ele*); stampa (ele * ini) {while(ini) { {printf( %d,ini->); stampa (); ini=ini->;} } Contare gli elementi di una lista #include<stdio.h> #include<stdlib.h> typedef struct elemento ele; int conta (ele * ini) int conta (ele * ); {int x=0; while(ini) {int n; {x++; n=conta (); ini=ini->;} return (x);} Le pile Le pile o liste LIFO (Last Input First Output) sono particolari liste concatenate in cui inserimenti e cancellazioni avvengono solo in testa. Creazione di una pila Per creare una pila è necessario: 1. Creare un singolo elemento ed inserire i dati 2. e l elemento creato è il primo posizionare l. ltrimenti collegare col precedente e spostare l 1. Ripetere da p p Creazione di una pila #include<stdio.h> #include<stdlib.h> typedef struct elemento ele; ele * creapila (ele * ini, int a) ele * creapila(ele *, int ); {ele *p; p=(ele *)malloc(sizeof(ele)); {ele *=; p->=a; p->=ini; =creapila(, n); } return(p);} 4

5 Creazione di una pila ele * creapila (ele * ini, int a) {ele *p; {ele *=; p=(ele *)malloc(sizeof(ele)); p->=a; =creapila(, n); } p->=ini; return(p);} Le code o liste FIFO (Fist Input First Output) sono particolari liste concatenate in cui gli inserimenti avvengono in coda e le eliminazioni in testa. Le code ini p p ini Creazione di una coda Per creare una coda è necessario: 1. Creare un singolo elemento ed inserire i dati 2. e l elemento creato è il primo posizionare l. ltrimenti scorrere fino alla fine della lista e collegare con l elemento creato. 1. Ripetere da p 51 p Creazione di una coda #include<stdio.h> #include<stdlib.h> typedef struct elemento ele; ele * creacoda(ele *, int ); {ele *=; =creacoda(, n); ele * creacoda (ele * ini, int a) {ele *p,*aux; p=(ele *)malloc(sizeof(ele)); p->=a; p->=; if(!ini) return(p); {aux=ini; while(aux->) aux=aux->; aux->=p; return(ini);} Creazione di una coda {ele *=; =creacoda(, n); 36 ini p ele * creacoda (ele * ini, int a) {ele *p,*aux; p=(ele *)malloc(sizeof(ele)); p->=a; p->=; if(!ini) return(p); {aux=ini; while(aux->) aux=aux->; aux->=p; return(ini);} Creazione di una coda {ele *=; =creacoda(, n); ini aux p ele * creacoda (ele * ini, int a) {ele *p,*aux; p=(ele *)malloc(sizeof(ele)); p->=a; p->=; if(!ini) return(p); {aux=ini; while(aux->) aux=aux->; aux->=p; return(ini);} 5

6 Inserimento nodo in lista concatenata L inserimento di un nodo in una lista può avvenire in testa (LIFO), in coda (FIFO) o in un punto intermedio della lista. E bene deputare gli inserimenti ad apposite funzioni. =(r *)malloc(sizeof(r)); ->= ; ->=; =; Inserimento in testa La funzione deve restituire l =(r *)malloc(sizeof(r)); ->= ; ->=; aux=; while(aux->) aux=aux->; aux->=; Inserimento in coda La funzione non deve restituire nulla perché l non è stato spostato. aux aux Inserimento nodo dopo un elemento assegnato 1. corro la lista fino a posizionarmi nel punto desiderato. E necessario usare un puntatore ausiliario che scorra la lista fino a posizionarsi nel nodo in cui fare l inserimento senzaperderel l. 2. e il punto desiderato è stato trovato a) Creo il nuovo elemento b) Creo i collegamenti. Per non perdere i collegamenti è necessario collegare prima il nuovo elemento al successivo della lista e poi il precedente al nuovo elemento. Inserimento nodo dopo un elemento assegnato void inserisci_dopo(r*, int info, int dove) {r*, *aux; aux=; while(aux && (aux->!=dove)) aux=aux->; if(aux) {=(r *)malloc(sizeof(r)); ->=info; ->=aux->; aux->=;} aux aux Inserimento nodo prima di un elemento assegnato 1. corro la lista (mediante puntatore ausiliario) fino a posizionarmi nel nodo precedente a uello desiderato. 2. e il punto desiderato è stato trovato a) Creo il nuovo elemento b) Creo i collegamenti. Per non perdere i collegamenti è necessario collegare prima il nuovo elemento al successivo della lista e poi il precedente al nuovo elemento. e il punto desiderato è il primo elemento effettuo un inserimento in testa. ltrimenti stampo un messaggio. Inserimento nodo prima di un elemento assegnato r* inserisci_prima(r*, int info, int dove) {r *,*aux; if(->==dove) {=(r *)malloc(sizeof(r)); ->=info; ->=; =;} {aux=; while(aux-> && (aux->->!=dove)) aux=aux->; if(aux->) {=(r *)malloc(sizeof(r)); ->=info; ->=aux->; aux->=;} return ();} 6

7 Inserimento nodo prima di un elemento assegnato if(->==dove) {=(r *)malloc(sizeof(r)); ->=info; ->=; =;} { return(); Inserimento nodo prima di un elemento assegnato if {aux=; aux aux while(aux-> t&& (aux->->!=dove)) >d t d aux=aux ; if(aux->) {=(r *)malloc(sizeof(r)); ->=info; ->=aux->; aux->=;} return ();} 1. e l elemento da cancellare è il primo sposto l e libero l area di memoria. 2. ltrimenti scorro la lista (mediante puntatore ausiliario) fino a posizionarmi nel nodo precedente a uello desiderato. 3. e il punto desiderato è stato trovato a) Posiziono un puntatore nell area da cancellare b) Creo i collegamenti c) Libero l area di memoria ltrimenti stampo un messaggio. 4. Restituisco l. r* cancella(r*, int dove) {r *killer,*aux; if(->==dove) {killer=; =->; free(killer);} {killer=; while( killer-> && (killer->->!=dove) >d t d ) killer=killer->; if(killer->) {aux=killer->; killer->=aux->; free(aux); } return ();} if(->==dove) {killer=; =->; free(killer);} { return(); killer if {killer=; killer aux while(killer-> && (killer->->!=dove)) killer=killer ; if(killer->) {aux=killer->; killer->=aux->; free(aux); } return ();} 7

8 if {killer=; killer killer aux while (killer-> && (killer->->!=dove) ) killer=killer ; if(killer->) {aux=killer->; killer->=aux->; free(aux); } return ();} Ordinamento di una lista (per selezione) Ho necessità di due puntatori p1 e p2 che puntino a due elementi successivi da confrontare e di un terzo puntatore min che punti all elemento minimo. 1. Posiziono min all della lista e considero il puntato come minimo. ii Posiziono i p1 all i i dll della lista 2. Posiziono p2 nell elemento successivo a p1. corro la lista usando p2. 3. e trovo un elemento minore di uello puntato da min effettuo lo scambio. 4. posto p1 di una posizione e ripeto da 2. Ordinamento di una lista (per selezione) 1 Ordinamento di una lista (per selezione) 2 void ordina(r* ) {r *p1,*p2,*min; char park; p1=; while( p1->) {p2=p1->; min=p1; while(p2) min p1 {if(p2-> < min->) min=p2; p2=p2->;} min p2 p2 void ordina(r* ) {r *p1,*p2,*min; char park; p1=; while( p1->) {p2=p1->; min=p1; while(p2) {if(p2-> < min->) min=p2; p2=p2->;} min p1 min p2 } if(min!=p1) {park=p1->; p1->=min->; min->=park;} p1=p1->;} } if(min!=p1) {park=p1->; p1->=min->; min->=park;} p1=p1->;} Ordinamento di una lista (per selezione) 3 void ordina(r* ) {r *p1,*p2,*min; char park; p1=; while( p1->) {p2=p1->; min=p1; while(p2) {if(p2-> < min->) min=p2; p2=p2->;} p1 } if(min!=p1) {park=p1->; p1->=min->; min->=park;} p1=p1->;} 8